def FindLib(conf, lib, hdr, managers = ['port', 'fink']): global pkgmans if conf.CheckLib(lib) and conf.CheckHeader(hdr): return True if not IsMac(conf): return False conf.env.Append(LIBPATH = []) # ensure it exists conf.env.Append(CPPPATH = []) # ensure it exists for pkgman in managers: if pkgman in pkgmans: continue # already have it loc = WhereIs(pkgman) if not loc: continue loc = os.path.realpath(loc) bin = 'bin/%s' % pkgman pre, sep, post = loc.partition(bin) if sep != bin or post != '': continue orig_libpath = conf.env['LIBPATH'] orig_cpppath = conf.env['CPPPATH'] conf.env.Append(LIBPATH = [pre + "/lib"]) conf.env.Append(CPPPATH = [pre + "/include"]) print "Try package manager '%s'..." % pkgman if conf.CheckLib(lib) and conf.CheckHeader(hdr): pkgmans[pkgman] = True return True conf.env.Replace(LIBPATH = orig_libpath) conf.env.Replace(CPPPATH = orig_cpppath) return False
def FindLib(conf, lib, managers=['port', 'fink']): global pkgmans if conf.CheckLib(*lib): return True if not IsMac(conf): return False conf.env.Append(LIBPATH=[]) # ensure it exists for pkgman in managers: if pkgman in pkgmans: continue # already have it loc = WhereIs(pkgman) if not loc: continue loc = os.path.realpath(loc) bin = 'bin/%s' % pkgman pre, sep, post = loc.partition(bin) if sep != bin or post != '': continue orig = conf.env['LIBPATH'] conf.env.Append(LIBPATH=[pre + "/lib"]) print "Try package manager '%s'..." % pkgman if conf.CheckLib(*lib): conf.env.Append(CPPPATH=[pre + "/include"]) pkgmans[pkgman] = True return True conf.env.Replace(LIBPATH=orig) return False
def generate(env): try: env["MSGFMT"] except KeyError: env["XGETTEXT"] = WhereIs("xgettext") or 'xgettext' env["MSGFMT"] = WhereIs("msgfmt") msgfmt = Builder(action = "$MSGFMT -c --statistics -o $TARGET $SOURCE", src_suffix = ".po", suffix = ".mo", single_source = True) env["BUILDERS"]["Msgfmt"] = msgfmt env["MSGMERGE"] = WhereIs("msgmerge") or 'msgmerge' msgmerge = Builder(action = "$MSGMERGE $TARGET $SOURCE -o $TARGET", src_suffix = ".pot", suffix = ".po", single_source = True) env["BUILDERS"]["MsgMerge"] = msgmerge env["MSGINIT"] = WhereIs("msginit") or 'msginit' msginit = Builder(action = "$MSGINIT -i $SOURCE -o $TARGET --no-translator", src_suffix = ".pot", suffix = ".po", single_source = True) env["BUILDERS"]["MsgInit"] = msginit def MsgInitMerge(env, target, source): #print target[0].path, os.path.exists(target[0].abspath) if os.path.exists(target[0].abspath): return env.MsgMerge(target, source) else: return env.MsgInit(target, source) env["BUILDERS"]["MsgInitMerge"] = MsgInitMerge
def run_closure_compiler(target, source, env, for_signature): closure_bin = os.path.join(os.path.dirname(WhereIs("emcc")), "node_modules", ".bin", "google-closure-compiler") cmd = [WhereIs("node"), closure_bin] cmd.extend(["--compilation_level", "ADVANCED_OPTIMIZATIONS"]) for f in env["JSEXTERNS"]: cmd.extend(["--externs", f.get_abspath()]) for f in source: cmd.extend(["--js", f.get_abspath()]) cmd.extend(["--js_output_file", target[0].get_abspath()]) return " ".join(cmd)
def generate(env): env.AppendENVPath("PATH", join(env["gettextdir"], "bin")) env["MSGFMT"] = WhereIs("msgfmt") msgfmt = Builder( action = "$MSGFMT --check-domain --statistics -o $TARGET $SOURCE", src_suffix = ".po", suffix = ".mo", single_source = True ) env["BUILDERS"]["Msgfmt"] = msgfmt env["MSGMERGE"] = WhereIs("msgmerge") msgmerge = Builder( action = "$MSGMERGE --backup=none --previous -U $TARGET $SOURCE", src_suffix = ".pot", suffix = ".po", single_source = True ) env["BUILDERS"]["MsgMerge"] = msgmerge env["MSGINIT"] = WhereIs("msginit") msginit = Builder( action = "$MSGINIT -i $SOURCE -o $TARGET -l $MSGINIT_LINGUA --no-translator", src_suffix = ".pot", suffix = ".po", single_source = True ) env["BUILDERS"]["MsgInit"] = msginit env["ENV"]["LANG"] = os.environ.get("LANG") env["MSGINIT_LINGUA"] = "C" def MsgInitMerge(env, target, source, **kw): if os.path.exists(target + ".po"): return env.MsgMerge(target, source, **kw) else: return env.MsgInit(target, source, **kw) env.AddMethod(MsgInitMerge) env["PO4A_GETTEXTIZE"] = WhereIs("po4a-gettextize") po4a_gettextize = Builder( action = "$PO4A_GETTEXTIZE -f $PO4A_FORMAT ${''.join([' -m ' + str(source) for source in SOURCES])} -p $TARGET", ) env["BUILDERS"]["Po4aGettextize"] = po4a_gettextize env["PO4A_TRANSLATE"] = WhereIs("po4a-translate") po4a_translate = Builder( action = "$PO4A_TRANSLATE -f $PO4A_FORMAT -L $PO4A_CHARSET -m ${SOURCES[0]} -p ${SOURCES[1]} -l $TARGET" ) env["BUILDERS"]["Po4aTranslate"] = po4a_translate
def find(self, env): # Only search for it if not specified already if self.pysteScriptPath == None: # Try to find it in path somehow print " searching for pyste.py in path..." if (WhereIs('pyste.py') != None): self.pysteScriptPath = WhereIs('pyste.py') self.pysteScriptCommand = "python " + self.pysteScriptPath print " found: %s" % self.pysteScriptPath else: self.checkRequired(" could not find pyste.py script.\n") return assert self.pysteScriptPath assert self.pysteScriptCommand
def ParseConfig(env, command, options): "Parses xxx-config style output for compilation directives" # Run the command where = WhereIs(command) if not where: print '%s not found in PATH' % command sys.exit(-1) print "Found " + str(command) + ": " + where cmd = where + ' ' + string.join(options) params = string.split(os.popen(cmd).read()) # Parse its output for arg in params: switch = arg[0:1] option = arg[1:2] if switch == '-': if option == 'I': env.Append(CPPPATH=[arg[2:]]) elif option == 'L': env.Append(LIBPATH=[arg[2:]]) elif option == 'l': env.Append(LIBS=[arg[2:]]) elif arg[0:11] == '-Wl,-rpath,': env.Append(LINKFLAGS=[arg]) elif arg[0:15] == '-Wl,-framework,': env.Append(LINKFLAGS=[arg]) else: env.Append(CXXFLAGS=[arg]) else: # Must be a static library, add it to the libs env.Append(LIBS=[arg])
def get_fb_info(fbc = 'fbc'): """Find fbc and query its version and default target and arch. 'fbc' is the program name to use.""" if not os.path.isfile (fbc): fbc = WhereIs (fbc) if not fbc: raise Exception("FreeBasic compiler is not installed!") # Newer versions of fbc (1.0+) print e.g. "FreeBASIC Compiler - Version $VER ($DATECODE), built for linux-x86 (32bit)" # older versions printed "FreeBASIC Compiler - Version $VER ($DATECODE) for linux" # older still printed "FreeBASIC Compiler - Version $VER ($DATECODE) for linux (target:linux)" fbcinfo = get_command_output(fbc, ["-version"]) version, date = re.findall("Version ([0-9.]+) ([0-9()-]+)", fbcinfo)[0] fullfbcversion = version + ' ' + date # Convert e.g. 1.04.1 into 1041 fbcversion = (lambda x,y,z: int(x)*1000 + int(y)*10 + int(z))(*version.split('.')) fbtarget = re.findall("target:([a-z]*)", fbcinfo) # Old versions of fbc. if len(fbtarget) == 0: # New versions of fbc. Format is os-cpufamily, and it is the # directory name where libraries are kept in non-standalone builds. fbtarget = re.findall(" built for ([a-zA-Z0-9-_]+)", fbcinfo) if len(fbtarget) == 0: raise Exception("Couldn't determine fbc default target") fbtarget = fbtarget[0] if fbtarget == 'win64': # Special case (including new versions of fbc) default_target, default_arch = 'win32', 'x86_64' elif '-' in fbtarget: # New versions of fbc default_target, default_arch = fbtarget.split('-') else: # Old versions of fbc, and special case for dos, win32, xbox default_target, default_arch = fbtarget, 'x86' return fbc, fbcversion, fullfbcversion, default_target, default_arch
def find(self, env): # Quick exit if nothing to find because it is already specified if self.baseDir != None: assert self.baseDir assert self.wxwidgetsconfig_cmd return else: self.checkRequired("wxwidgets base dir not found") return # Find cppunit-config and call it to get the other arguments sys.stdout.write("searching...\n") self.wxwidgetsconfig_cmd = WhereIs('wx-config') if None == self.wxwidgetsconfig_cmd: self.checkRequired( " could not find wx-config. Use %s to specify it: Ex: %s=/usr/local" % (self.baseDirKey, self.baseDirKey)) else: sys.stdout.write(" found wx-config.\n") found_ver_str = os.popen(self.wxwidgetsconfig_cmd + " --version").read().strip() sys.stdout.write(" version:%s" % found_ver_str) # find base dir self.baseDir = os.popen(self.wxwidgetsconfig_cmd + " --prefix").read().strip() if not os.path.isdir(self.baseDir): self.checkRequired(" returned directory does not exist:%s" % self.baseDir) self.baseDir = None else: print " found at: ", self.baseDir
def find(self, env): # quick exit if nothing to find if self.baseDir != None: return sys.stdout.write("searching...\n") self.plxconfig_cmd = WhereIs('plexus-config') if None == self.plxconfig_cmd: self.checkRequired(" could not find plexus-config") else: sys.stdout.write(" found plexus-config.\n") found_ver_str = os.popen(self.plxconfig_cmd + " --version").read().strip() sys.stdout.write(" version:%s" % found_ver_str) self.baseDir = os.popen(self.plxconfig_cmd + " --prefix").read().strip() if not os.path.isdir(self.baseDir): self.checkRequired(" returned directory does not exist:%s" % self.baseDir) self.baseDir = None else: print " found at: ", self.baseDir
def find(self, env): # Quick exit if nothing to find if self.baseDir != None: return # Find osg-config and call it to get the other arguments sys.stdout.write("searching for osg-config...\n") self.osgconfig_cmd = WhereIs('osg-config') if not self.osgconfig_cmd: self.checkRequired(" could not find osg-config.") self.osgconfig_cmd = None return else: try: sys.stdout.write(" found osg-config.\n") found_ver_str = os.popen(self.osgconfig_cmd + " --version").read().strip() sys.stdout.write(" version:%s" % found_ver_str) # find base dir self.baseDir = os.popen(self.osgconfig_cmd + " --prefix").read().strip() if not os.path.isdir(self.baseDir): self.checkRequired( " returned directory does not exist:%s" % self.baseDir) self.baseDir = None else: print " found at: ", self.baseDir except Exception, ex: print "using osg-config failed." self.osgconfig_cmd = None
def generate_linux(env): icc = WhereIs('icc') if not icc: warnings.warn("icc not found") topdir = normpath(pjoin(pdirname(icc), os.pardir, os.pardir)) abi = get_abi(env) return old_generate(env, abi=abi, topdir=topdir)
def find(self, env): # Quick exit if nothing to find if self.baseDir != None: return # Find cmd-config and call it to get the other arguments sys.stdout.write("searching...\n") self.configCmdFullPath = WhereIs(self.configCmdName) if None == self.configCmdFullPath: self.checkRequired(" could not find %s." % self.configCmdName) else: sys.stdout.write(" found %s.\n" % self.configCmdName) found_ver_str = os.popen(self.configCmdFullPath + " --version").read().strip() sys.stdout.write(" version:%s" % found_ver_str) # find base dir self.baseDir = os.popen(self.configCmdFullPath + " --prefix").read().strip() if not os.path.isdir(self.baseDir): self.checkRequired(" returned directory does not exist:%s" % self.baseDir) self.baseDir = None else: print " found at: ", self.baseDir
def __init__(self, moduleName, fpcFile=None): " moduleName: The config command to call " self.moduleName = moduleName self.fpcFile = fpcFile if self.fpcFile is not None: self.fpcFile = self.fpcFile.strip() self.valid = True self.flagpoll_cmd = WhereIs('flagpoll') if None == self.flagpoll_cmd: print "FlagPollParser: Could not find flagpoll." self.valid = False return if self.fpcFile is not None and not os.path.isfile(self.fpcFile): print "FlagPollParser: Could not find fpc file:", self.fpcFile self.valid = False return # All calls to flagpoll need module name now. if 'win32' == GetPlatform(): self.flagpoll_cmd = '"%s" %s' % (self.flagpoll_cmd, self.moduleName) else: self.flagpoll_cmd += " %s" % self.moduleName # Find out if the module exists. exists_resp = self.callFlagPoll("--exists") if "yes" != exists_resp.strip().lower(): self.valid = False return # Initialize regular expressions # Res that when matched against config output should match the options we want # In future could try to use INCPREFIX and other platform neutral stuff self.inc_re = re.compile(r'(?: |^)[-/]I\s*("[^"]+"|\S+)', re.MULTILINE) self.framework_re = re.compile(r'(?: |^)-framework (\S+)', re.MULTILINE) self.link_flag_re = re.compile(r'(?: |^)([-/]\S*)', re.MULTILINE) if 'win32' == GetPlatform(): self.lib_re = re.compile(r'(?: |^)(\S*\.lib)', re.MULTILINE) self.cxx_flags_re = re.compile(r'(?: |^)/D(\S*)', re.MULTILINE) #self.lib_path_re = re.compile(r'(?: |^)/LIBPATH:(\S*)', re.M | re.I) self.lib_path_re = re.compile(r'(?: |^)/LIBPATH:("[^"]+"|\S+)', re.M | re.I) else: self.lib_re = re.compile(r'(?: |^)-l(\S*)', re.MULTILINE) self.lib_path_re = re.compile(r'(?: |^)-L(\S*)', re.MULTILINE) self.cxx_flags_re = re.compile(r'(?: |^)-D(\S*)', re.MULTILINE)
def strip_nonfunction_symbols(binary, target_prefix, builddir, env): """Modifies a binary in-place, stripping symbols for global variables and undefined symbols (e.g. left behind by --gc-sections)""" nm = WhereIs(target_prefix + "nm") syms = get_command_output(nm, [binary], False) symfilename = os.path.relpath(builddir + binary + '.unwanted_symbols') with open(symfilename, 'w') as symfile: for line in syms.split('\n'): toks = line.strip().split(' ') if len(toks) == 3: address, symtype, symbol = toks else: symtype, symbol = toks assert len(symtype) == 1 # Remove the following symbols: # U: undefined symbols # b/B, d/D, r/R: local/global variables (uninitialised, initalised, readonly) # These are no use to the crash handler, only to gdb. # i: DLL junk (Windows only), not needed in a linked binary if symtype in 'UbBdDrRi': if symbol not in keep_symbols: symfile.write(symbol + '\n') objcopy = WhereIs(target_prefix + "objcopy") env.Execute(objcopy + ' --strip-symbols ' + symfilename + ' ' + binary)
def generate(env): env["MSGFMT"] = WhereIs("msgfmt") action = [[ "$MSGFMT", "--check-format", "--check-domain", "-f", "-o", "$TARGET", "$SOURCE" ]] env["GETTEXTSTR"] = action env["BUILDERS"]["Gettext"] = Builder( action = Action( action, "$GETTEXTSTR" ), src_suffix = ".po", suffix = ".mo", single_source = True )
def findtool(module, envvars, toolname, always_expand=False): """Look for a callable program, checking envvars, module variables, relative paths, PATH, and $target_prefix. Returns None if not found.""" if not isinstance(envvars, (list, tuple)): envvars = envvars, for envvar in envvars: if os.environ.get(envvar): ret = os.environ.get(envvar) break else: if WhereIs(module['target_prefix'] + toolname): ret = module['target_prefix'] + toolname else: ret = toolname # standalone builds of FB on Windows do not search $PATH for binaries, # so we have to do so for it! ret = expand_tool_path(ret, module['win32'] or always_expand) return ret
def expand_tool_path(path, always_expand=False): """Try to find the file a path refers to, allowing absolute and relative paths and checking PATH; returns None if it can't be found. If it's in PATH, expand only if always_expand. """ path = os.path.expanduser(path) # expand ~ if os.path.isfile(path): return path ret = WhereIs(path) if ret: if always_expand: return ret return path # The CWD gets changed to build/ while SConscript is processed, so look # relative to original directory, but then it gets changed back to original # dir while compiling, so convert to abspath ret = os.path.join("..", path) if os.path.isfile(ret): return os.path.abspath(ret) return None
def find(self, env): # Quick exit if nothing to find because it is already specified if self.baseDir !=None: assert self.baseDir return # Find gmtl-config and call it to get the other arguments sys.stdout.write("searching...\n") self.gmtlconfig_cmd = WhereIs('gmtl-config') if None == self.gmtlconfig_cmd: self.checkRequired(" could not find gmtl-config") else: sys.stdout.write(" found gmtl-config.\n") # find base dir self.baseDir = os.popen(self.gmtlconfig_cmd + " --prefix").read().strip() if not os.path.isdir(self.baseDir): self.checkRequired(" returned directory does not exist:%s"%self.baseDir) self.baseDir = None else: print " found at: ", self.baseDir
def _build_scons(environment, source, arguments, target): """Builds another SCons script. @param environment Environment that will be used to search for the SCons executable @param source Input file(s) for the build @param arguments Arguments that will be passed to SCons @param target Output file(s) produced by the build @returns A scons build action producing the target file""" # Clone the environment and use the real search PATH. This will not pollute # the environment in which the SCons subprocess runs, but is the only way # to invoke SCons in Windows because it's a batch file that exepcts Python # to also be in the system search PATH. cloned_environment = environment.Clone(ENV=os.environ) # Try to locate SCons with the environment's new search path scons_path = cloned_environment.WhereIs('scons') # If not found, try with SCons.Util.WhereIs() which actually works differently # from environment.WhereIs()... if scons_path is None: scons_path = WhereIs('scons') # Still not found? Just blindly shout 'scons' and if it fails that will # at least produce a meaningful error message that might make the user add # SCons to the system search PATH. if scons_path is None: scons_path = 'scons' if platform.system() == 'Windows': return cloned_environment.Command( source = source, action = '"' + scons_path + '" ' + arguments, target = target ) else: return cloned_environment.Command( source = source, action = scons_path + ' ' + arguments, target = target )
def find_sundials_config(env): """ Try and figure out if sundials-config is installed on this machine, and if so, where. """ if SCons.Util.can_read_reg: # If we can read the registry, get the NSIS command from it try: # 0x20019 is KEY_READ, k = SCons.Util.RegOpenKeyEx(SCons.Util.hkey_mod.HKEY_LOCAL_MACHINE, 'SOFTWARE\\SUNDIALS', 0, 0x20019) val, tok = SCons.Util.RegQueryValueEx(k, None) ret = val + os.path.sep + 'makensis.exe' if os.path.exists(ret): return '"' + ret + '"' else: return None except: pass # Couldn't find the key, just act like we can't read the registry # Hope it's on the path, but note that we have to be careful with PATHEXT since sundials-config doesn't have an # an executable-signifying suffix (seems like a weakness with env.WhereIs in SCons?? return WhereIs('sundials-config', path=os.environ['PATH'], pathext="")
def find(self, env): # Quick exit if nothing to find because it is already specified if self.baseDir != None: assert self.baseDir return # Find osg2-config and call it to get the other arguments sys.stdout.write("searching...\n") self.config_script = WhereIs('osg2-config', pathext='') if None == self.config_script: self.checkRequired(" could not find osg2-config") else: sys.stdout.write(" found osg2-config.\n") full_command = sys.executable + ' ' + self.config_script # find base dir self.baseDir = os.popen(full_command + " --prefix").read().strip() if not os.path.isdir(self.baseDir): self.checkRequired(" returned directory does not exist:%s" % self.baseDir) self.baseDir = None else: print " found at: ", self.baseDir
def can_build(): return WhereIs("emcc") is not None
def test_WhereIs(self): test = TestCmd.TestCmd(workdir='') sub1_xxx_exe = test.workpath('sub1', 'xxx.exe') sub2_xxx_exe = test.workpath('sub2', 'xxx.exe') sub3_xxx_exe = test.workpath('sub3', 'xxx.exe') sub4_xxx_exe = test.workpath('sub4', 'xxx.exe') test.subdir('subdir', 'sub1', 'sub2', 'sub3', 'sub4') if sys.platform != 'win32': test.write(sub1_xxx_exe, "\n") os.mkdir(sub2_xxx_exe) test.write(sub3_xxx_exe, "\n") os.chmod(sub3_xxx_exe, 0o777) test.write(sub4_xxx_exe, "\n") os.chmod(sub4_xxx_exe, 0o777) env_path = os.environ['PATH'] try: pathdirs_1234 = [ test.workpath('sub1'), test.workpath('sub2'), test.workpath('sub3'), test.workpath('sub4'), ] + env_path.split(os.pathsep) pathdirs_1243 = [ test.workpath('sub1'), test.workpath('sub2'), test.workpath('sub4'), test.workpath('sub3'), ] + env_path.split(os.pathsep) os.environ['PATH'] = os.pathsep.join(pathdirs_1234) wi = WhereIs('xxx.exe') assert wi == test.workpath(sub3_xxx_exe), wi wi = WhereIs('xxx.exe', pathdirs_1243) assert wi == test.workpath(sub4_xxx_exe), wi wi = WhereIs('xxx.exe', os.pathsep.join(pathdirs_1243)) assert wi == test.workpath(sub4_xxx_exe), wi wi = WhereIs('xxx.exe', reject=sub3_xxx_exe) assert wi == test.workpath(sub4_xxx_exe), wi wi = WhereIs('xxx.exe', pathdirs_1243, reject=sub3_xxx_exe) assert wi == test.workpath(sub4_xxx_exe), wi os.environ['PATH'] = os.pathsep.join(pathdirs_1243) wi = WhereIs('xxx.exe') assert wi == test.workpath(sub4_xxx_exe), wi wi = WhereIs('xxx.exe', pathdirs_1234) assert wi == test.workpath(sub3_xxx_exe), wi wi = WhereIs('xxx.exe', os.pathsep.join(pathdirs_1234)) assert wi == test.workpath(sub3_xxx_exe), wi if sys.platform == 'win32': wi = WhereIs('xxx', pathext='') assert wi is None, wi wi = WhereIs('xxx', pathext='.exe') assert wi == test.workpath(sub4_xxx_exe), wi wi = WhereIs('xxx', path=pathdirs_1234, pathext='.BAT;.EXE') assert wi.lower() == test.workpath(sub3_xxx_exe).lower(), wi # Test that we return a normalized path even when # the path contains forward slashes. forward_slash = test.workpath('') + '/sub3' wi = WhereIs('xxx', path=forward_slash, pathext='.EXE') assert wi.lower() == test.workpath(sub3_xxx_exe).lower(), wi del os.environ['PATH'] wi = WhereIs('xxx.exe') assert wi is None, wi finally: os.environ['PATH'] = env_path
def where_is(program): path = WhereIs(program) if path: path = os.path.dirname(path) return path
def add_builders(env): from sys import executable from SCons.Util import WhereIs pandoc_exec = WhereIs('pandoc') dot_exec = WhereIs('dot') assets = ' '.join(["--css=assets/" + str(x) for x in SlideExtraCSSFiles]) template = ("--template=" + SlideTemplateName) if SlideTemplateName else ' ' env.Append(BUILDERS={ 'WSD':env.Builder( action=['{0} -m websequence --style magazine '.format(executable) + '--format=png --in $SOURCE --out $TARGET'], suffix='.png', src_suffix='.wsd'), 'Dot':env.Builder( action=["{0} -Tpng $SOURCE -o $TARGET".format(dot_exec)], suffix=".png", src_suffix=".dot"), 'Neato':env.Builder( action=["neato -Tpng $SOURCE -o $TARGET"], suffix=".png", src_suffix=".dot"), 'Python':env.Builder( action=["{0} $SOURCE $TARGET".format(executable)], suffix='.png', src_suffix='.py'), 'Shell':env.Builder( action=['bash $SOURCE $TARGET'], suffix='.png', src_suffix='.sh'), 'Wget':env.Builder( action=wget_each_url, emitter=yaml_emitter), 'PandocSlides': env.Builder( generator = lambda source, target, env, for_signature: ( '{pandoc} -t revealjs -s -V theme={theme}' \ ' --css=assets/{theme}.css' \ ' --css=assets/{theme}-ucl-overlay.css' \ ' --css=assets/local_styles.css' \ ' {template} ' \ ' {assets} ' \ ' --default-image-extension=png' \ ' --highlight-style={highlight}' \ ' --mathjax' \ ' -V revealjs-url=http://lab.hakim.se/reveal-js/' \ ' {sources} ' \ '-o {output}'.format( pandoc = pandoc_exec, theme = SlideStyle, template = template, assets = assets, highlight = SlideSyntaxHighlightingStyle, sources = ' '.join([str(x) for x in source]), output = target[0] ) ) ), 'PandocLatex':env.Builder( action=['{0} --template=report '.format(pandoc_exec) + '-V documentclass=scrartcl ' + '-V links-as-notes ' + '--filter pandoc-citeproc ' + '--default-image-extension=png '+ '-V linkcolor="uclmidgreen" ' + '--number-sections $SOURCES -o $TARGET'], ), 'PandocJekyll':env.Builder( action=['{0} -thtml -s --template=jekyll'.format(pandoc_exec)+ ' --default-image-extension=png'+ ' --mathjax '+ ' $SOURCES -o $TARGET'] ), 'Browse':env.Builder(action=browse_each_url, emitter=yaml_emitter), 'Carousel':env.Builder( action=carousel.carousel_action, suffix=".png", src_suffix=".carousel"), 'Cp':env.Builder( action=["cp $SOURCES $TARGET"] ), 'R': env.Builder( action=['RScript $SOURCE $TARGET'] ), # Assume R script expects dest file as first clarg 'Bib': env.Builder( action=tidybib.tidybib_action, suffix=".bib", source_suffix=".zbib" ) }) env['ENV']["PYTHONPATH"] = sys.path
def generate_linux(env): ifort = WhereIs('ifort') if not ifort: warnings.warn("ifort not found") return old_generate(env)