def feature_py(self): install_path=getattr(self,'install_path','${PYTHONDIR}') install_from=getattr(self,'install_from',None) if install_from and not isinstance(install_from,Node.Node): install_from=self.path.find_dir(install_from) inputs=[] for x in Utils.to_list(self.source): if isinstance(x,Node.Node): y=x else: y=self.path.find_resource(x) inputs.append(y) if install_path: if install_from: pyd=Utils.subst_vars("%s/%s"%(install_path,y.path_from(install_from)),self.env) else: pyd=Utils.subst_vars("%s/%s"%(install_path,y.path_from(self.path)),self.env) else: pyd=y.abspath() for ext in("pyc","pyo"): if install_from: pyobj=self.path.get_bld().make_node(y.change_ext(".%s"%ext).get_bld().path_from(install_from.get_bld())) else: pyobj=self.path.get_bld().make_node(y.change_ext(".%s"%ext).name) pyobj.parent.mkdir() tsk=self.create_task(ext,y,pyobj) tsk.pyd=pyd if install_path: self.bld.install_files(install_path,pyobj,cwd=self.path.get_bld(),relative_trick=True) if install_path: if install_from: self.bld.install_files(install_path,inputs,cwd=install_from,relative_trick=True) else: self.bld.install_files(install_path,inputs)
def process_py(self,node): assert(node.get_bld_sig()) assert(getattr(self,'install_path')),'add features="py"' if self.install_path: if self.install_from: self.bld.install_files(self.install_path,[node],cwd=self.install_from,relative_trick=True) else: self.bld.install_files(self.install_path,[node],relative_trick=True) lst=[] if self.env.PYC: lst.append('pyc') if self.env.PYO: lst.append('pyo') if self.install_path: if self.install_from: pyd=Utils.subst_vars("%s/%s"%(self.install_path,node.path_from(self.install_from)),self.env) else: pyd=Utils.subst_vars("%s/%s"%(self.install_path,node.path_from(self.path)),self.env) else: pyd=node.abspath() for ext in lst: if self.env.PYTAG: name=node.name[:-3] pyobj=node.parent.get_bld().make_node('__pycache__').make_node("%s.%s.%s"%(name,self.env.PYTAG,ext)) pyobj.parent.mkdir() else: pyobj=node.change_ext(".%s"%ext) tsk=self.create_task(ext,node,pyobj) tsk.pyd=pyd if self.install_path: self.bld.install_files(os.path.dirname(pyd),pyobj,cwd=node.parent.get_bld(),relative_trick=True)
def prepare_env(self,env): if not env.PREFIX: env.PREFIX=os.path.abspath(os.path.expanduser(Options.options.prefix)) if not env.BINDIR: env.BINDIR=Utils.subst_vars('${PREFIX}/bin',env) if not env.LIBDIR: env.LIBDIR=Utils.subst_vars('${PREFIX}/lib',env)
def prepare_env(self, env): """insert various variables in the environment""" if not env.PREFIX: env.PREFIX = os.path.abspath(os.path.expanduser(Options.options.prefix)) if not env.BINDIR: env.BINDIR = Utils.subst_vars('${PREFIX}/bin', env) if not env.LIBDIR: env.LIBDIR = Utils.subst_vars('${PREFIX}/lib', env)
def process_py(self, node): """ Add signature of .py file, so it will be byte-compiled when necessary """ assert hasattr(self, "install_path"), 'add features="py"' # where to install the python file if self.install_path: if self.install_from: self.add_install_files( install_to=self.install_path, install_from=node, cwd=self.install_from, relative_trick=True, ) else: self.add_install_files(install_to=self.install_path, install_from=node, relative_trick=True) lst = [] if self.env.PYC: lst.append("pyc") if self.env.PYO: lst.append("pyo") if self.install_path: if self.install_from: pyd = Utils.subst_vars( "{}/{}".format(self.install_path, node.path_from(self.install_from)), self.env) else: pyd = Utils.subst_vars( "{}/{}".format(self.install_path, node.path_from(self.path)), self.env) else: pyd = node.abspath() for ext in lst: if self.env.PYTAG and not self.env.NOPYCACHE: # __pycache__ installation for python 3.2 - PEP 3147 name = node.name[:-3] pyobj = (node.parent.get_bld().make_node("__pycache__").make_node( f"{name}.{self.env.PYTAG}.{ext}")) pyobj.parent.mkdir() else: pyobj = node.change_ext(".%s" % ext) tsk = self.create_task(ext, node, pyobj) tsk.pyd = pyd if self.install_path: self.add_install_files( install_to=os.path.dirname(pyd), install_from=pyobj, cwd=node.parent.get_bld(), relative_trick=True, )
def run(self): cmd = [ Utils.subst_vars("${PYTHON}", self.env), Utils.subst_vars("${PYFLAGS_OPT}", self.env), "-c", INST, self.inputs[0].abspath(), self.outputs[0].abspath(), self.pyd, ] ret = self.generator.bld.exec_command(cmd) return ret
def prepare_env(self, env): """ Insert *PREFIX*, *BINDIR* and *LIBDIR* values into ``env`` :type env: :py:class:`waflib.ConfigSet.ConfigSet` :param env: a ConfigSet, usually ``conf.env`` """ if not env.PREFIX: env.PREFIX = os.path.abspath(os.path.expanduser(Options.options.prefix)) if not env.BINDIR: env.BINDIR = Utils.subst_vars('${PREFIX}/bin', env) if not env.LIBDIR: env.LIBDIR = Utils.subst_vars('${PREFIX}/lib', env)
def add_dependency(bld, tgt, src): # Expand configuration variables (e.g. # "${root}/tools" -> "/home/.../tenshi/tools") tgt = Utils.subst_vars(tgt, bld.env) src = Utils.subst_vars(src, bld.env) # Handle paths relative the current wscript src_node = bld.path.find_resource(src) if src_node is None: # Handle paths relative to the root and absolute paths. src_node = bld.root.find_resource(src) if src_node is None: bld.fatal("Could not find manual dependency '{}'".format(src)) bld.add_manual_dependency(tgt, src_node)
def dep_build(self, *k, **kw): """Configure/Make/Make install to the dist directory""" k, kw = base(self, *k, **kw) k, kw = fetch(self, *k, **kw) self.start_msg("Building %s" % kw["name"]) if not os.path.isdir(kw["prefix"]): config_cmd = kw.get("config_cmd", "%(src)s/configure --prefix=%(prefix)s") build_cmd = kw.get("build_cmd", Utils.subst_vars('${MAKE} ${JOBS}',self.env)) install_cmd = kw.get("install_cmd", Utils.subst_vars('${MAKE} ${JOBS} install', self.env)) self.end_msg("...") if not os.path.exists(kw["build"]): if kw.get("build_dir", True): os.makedirs(kw["build"]) self.start_msg(" Configure %s" % kw["name"]) self.cmd_and_log( config_cmd % kw, #(config_cmd % kw).split(' '), output=Context.BOTH, shell=True, cwd=kw.get("config_cwd",kw["build"]) % kw ) self.end_msg("Ok") self.start_msg(" Compile %s" % kw["name"]) self.cmd_and_log( build_cmd % kw, #(build_cmd % kw).split(' '), output=Context.BOTH, shell=True, cwd=kw.get("build_cwd",kw["build"]) % kw ) self.end_msg("Ok") if not os.path.exists(kw["prefix"]): self.start_msg(" Install %s" % kw["name"]) self.cmd_and_log( install_cmd % kw, #(install_cmd % kw).split(' '), output=Context.BOTH, shell=True, cwd=kw.get("install_cwd",kw["build"]) % kw ) self.end_msg("Ok") else: self.end_msg("Already done")
def apply_vnum(self): if not getattr(self,'vnum','')or os.name!='posix'or self.env.DEST_BINFMT not in('elf','mac-o'): return link=self.link_task nums=self.vnum.split('.') node=link.outputs[0] libname=node.name if libname.endswith('.dylib'): name3=libname.replace('.dylib','.%s.dylib'%self.vnum) name2=libname.replace('.dylib','.%s.dylib'%nums[0]) else: name3=libname+'.'+self.vnum name2=libname+'.'+nums[0] if self.env.SONAME_ST: v=self.env.SONAME_ST%name2 self.env.append_value('LINKFLAGS',v.split()) self.create_task('vnum',node,[node.parent.find_or_declare(name2),node.parent.find_or_declare(name3)]) if getattr(self.bld,'is_install',None): self.install_task.hasrun=Task.SKIP_ME bld=self.bld path=self.install_task.dest t1=bld.install_as(path+os.sep+name3,node,env=self.env,chmod=self.link_task.chmod) t2=bld.symlink_as(path+os.sep+name2,name3) t3=bld.symlink_as(path+os.sep+libname,name3) self.vnum_install_task=(t1,t2,t3) if'-dynamiclib'in self.env['LINKFLAGS']: try: inst_to=self.install_path except AttributeError: inst_to=self.link_task.__class__.inst_to if inst_to: p=Utils.subst_vars(inst_to,self.env) path=os.path.join(p,self.link_task.outputs[0].name) self.env.append_value('LINKFLAGS',['-install_name',path])
def get_install_path(self): "installation path prefixed by the destdir, the variables like in '${PREFIX}/bin' are substituted" dest = self.dest.replace('/', os.sep) dest = Utils.subst_vars(self.dest, self.env) if Options.options.destdir: dest = os.path.join(Options.options.destdir, dest.lstrip(os.sep)) return dest
def configure(self): try: if sys.version_info >= (3, 0): self.find_program('virtualenv', var="VIRTUALENV", mandatory=True, okmsg="ok") else: self.find_program('virtualenv2', var="VIRTUALENV", mandatory=True, okmsg="ok") except ConfigurationError as e: name = "virtualenv" version = "trunk" self.dep_fetch( name = name, version = version, git_url = "https://github.com/pypa/virtualenv.git", ) self.find_program('virtualenv.py', var="VIRTUALENV", mandatory=True, okmsg="ok", path_list=[self.dep_path(name, version)]) self.start_msg("Create python virtualenv") self.env["VENV_PATH"] = os.path.join(self.bldnode.abspath(), ".conf_check_venv") self.cmd_and_log( [Utils.subst_vars('${VIRTUALENV}',self.env), "-p", sys.executable, self.env.VENV_PATH], output=Context.BOTH, cwd=self.bldnode.abspath() ) self.end_msg("ok") self.find_program('python', var="VPYTHON", mandatory=True, okmsg="ok", path_list=[os.path.join(self.env.VENV_PATH, "bin")]) self.find_program('pip', var="VPIP", mandatory=True, okmsg="ok", path_list=[os.path.join(self.env.VENV_PATH, "bin")])
def collect_properties(self): """ Visual studio projects are associated with platforms and configurations (for building especially) """ super(vsnode_target, self).collect_properties() for x in self.build_properties: variant_name = x.configuration.lower() + '_' + ( 'x86' if x.platform == 'Win32' else 'x64') target = self.ctx.get_target_variant(self.tg.name, variant_name) install_path = '' if hasattr(target, 'install_path'): # TODO: # The folowing code is very ungly, fix this! try: install_path = Utils.subst_vars( getattr(target, 'install_path', ''), target.env) except Exception, e: pass x.outdir = install_path x.preprocessor_definitions = '' x.includes_search_path = '' try: tsk = target.link_task except AttributeError: pass else: x.output_file = os.path.join( install_path, os.path.basename(tsk.outputs[0].abspath())) x.preprocessor_definitions = ';'.join(tsk.env.DEFINES) x.includes_search_path = ';'.join(target.env.INCPATHS)
def setup_py_build(task): """ """ if bld.env.IS_WINDOWS: wsdk_env = cls._get_wdsk_env() cmd = Utils.subst_vars('${PYTHON} setup.py build'\ ' --build-base="${BUILD_DIR}/3rdParty/python/${MODULE_NAME}_${MODULE_VERSION}"'\ ' --build-platlib="${BUILD_DIR}/3rdParty/python/${MODULE_NAME}_${MODULE_VERSION}/${PLATFORM_NAME}"'\ ' --compiler=msvc', bld.env) task.exec_command(cmd, cwd=bld.path.abspath(), env=wsdk_env) else: cmd = Utils.subst_vars('${PYTHON} setup.py build'\ ' --build-base="${BUILD_DIR}/3rdParty/python/${MODULE_NAME}_${MODULE_VERSION}"'\ ' --build-platlib="${BUILD_DIR}/3rdParty/python/${MODULE_NAME}_${MODULE_VERSION}/${PLATFORM_NAME}"', bld.env) task.exec_command(cmd, cwd=bld.path.abspath(), env=wsdk_env)
def prepare_env(self,env): if not env.PREFIX: if Options.options.prefix or Utils.is_win32: env.PREFIX=Options.options.prefix else: env.PREFIX='/' if not env.BINDIR: if Options.options.bindir: env.BINDIR=Options.options.bindir else: env.BINDIR=Utils.subst_vars('${PREFIX}/bin',env) if not env.LIBDIR: if Options.options.libdir: env.LIBDIR=Options.options.libdir else: env.LIBDIR=Utils.subst_vars('${PREFIX}/lib%s'%Utils.lib64(),env)
def ApplyCustomManifestsSubTask(parent_task): # CATEGORIZE THE OUTPUT RESOURCE. output_node = parent_task.outputs[0] is_exe = (output_node.suffix() == '.exe') EXE_MODE = 1 DLL_MODE = 2 resource_id = EXE_MODE if is_exe else DLL_MODE # FORM THE COMMAND TO CALL THE MANIFEST TOOL. # See http://msdn.microsoft.com/en-us/library/aa375649%28v=vs.100%29.aspx for more info. # Multiple manifests can be specified in a single call by forming a space-separated list. get_quoted_path = lambda node: '"{}"'.format(node.abspath()) manifest_tool_path = Utils.subst_vars('"${MT}"', parent_task.env) manifest_file_nodes = parent_task.generator.manifest_files quoted_manifest_paths = ' '.join(map(get_quoted_path, manifest_file_nodes)) manifest_tool_command = ' '.join([ '{manifest_tool}', '-manifest {manifest_paths}', '-outputresource:{exe_path};{resource_id}']).format( manifest_tool = manifest_tool_path, manifest_paths = quoted_manifest_paths, exe_path = get_quoted_path(output_node), resource_id = resource_id) # CALL THE MANIFEST TOOL. manifest_tool_result = parent_task.exec_command(manifest_tool_command) return manifest_tool_result
def get_inst_node(self, dest, name): dest = Utils.subst_vars(dest, self.env) dest = dest.replace('/', os.sep) if Options.options.destdir: dest = os.path.join(Options.options.destdir, os.path.splitdrive(dest)[1].lstrip(os.sep)) return self.bld.srcnode.make_node([dest, name])
def configure(conf): def get_param(varname,default): return getattr(Options.options,varname,'')or default env=conf.env env.LIBDIR=env.BINDIR=[] env.EXEC_PREFIX=get_param('EXEC_PREFIX',env.PREFIX) corner_case=False if str(env.PREFIX)=='/usr': corner_case=True env.PREFIX='' env.PACKAGE=getattr(Context.g_module,'APPNAME',None)or env.PACKAGE complete=False iter=0 while not complete and iter<len(_options)+1: iter+=1 complete=True for name,help,default in _options: name=name.upper() if not env[name]: try: env[name]=Utils.subst_vars(get_param(name,default).replace('/',os.sep),env) except TypeError: complete=False if corner_case: env.PREFIX='/usr' if not complete: lst=[name for name,_,_ in _options if not env[name.upper()]] raise conf.errors.WafError('Variable substitution failure %r'%lst)
def configure(self): try: if sys.version_info >= (3, 0): self.find_program(['virtualenv', 'virtualenv.py', 'virtualenv.exe'], var="VIRTUALENV", mandatory=True, okmsg="ok") else: self.find_program(['virtualenv2', 'virtualenv2.py', 'virtualenv2.exe', 'virtualenv', 'virtualenv.py', 'virtualenv.exe'], var="VIRTUALENV", mandatory=True, okmsg="ok") except ConfigurationError as e: name = "virtualenv" version = "trunk" self.dep_fetch( name = name, version = version, git_url = "https://github.com/pypa/virtualenv.git", ) self.find_program(['virtualenv', 'virtualenv.py', 'virtualenv.exe'], var="VIRTUALENV", mandatory=True, okmsg="ok", path_list=[self.dep_path(name, version)]) self.start_msg("Create python virtualenv") self.env["VENV_PATH"] = os.path.join(self.bldnode.abspath(), ".conf_check_venv") self.cmd_and_log( [Utils.subst_vars('${VIRTUALENV}',self.env), "-p", sys.executable, self.env.VENV_PATH], output=Context.BOTH, cwd=self.bldnode.abspath() ) self.end_msg("ok") self.find_program('python', var="VPYTHON", mandatory=True, okmsg="ok", path_list=[os.path.join(self.env.VENV_PATH, "bin")]) self.find_program('pip', var="VPIP", mandatory=True, okmsg="ok", path_list=[os.path.join(self.env.VENV_PATH, "bin")])
def run(self): if not self.env['VALADOCFLAGS']: self.env['VALADOCFLAGS'] = '' cmd = [Utils.subst_vars(VALADOC_STR, self.env)] cmd.append ('-o %s' % self.output_dir) if getattr(self, 'doclet', None): cmd.append ('--doclet %s' % self.doclet) cmd.append ('--package-name %s' % self.package_name) if getattr(self, 'package_version', None): cmd.append ('--package-version %s' % self.package_version) if getattr(self, 'packages', None): for package in self.packages: cmd.append ('--pkg %s' % package) if getattr(self, 'vapi_dirs', None): for vapi_dir in self.vapi_dirs: cmd.append ('--vapidir %s' % vapi_dir) if not getattr(self, 'protected', None): cmd.append ('--no-protected') if getattr(self, 'private', None): cmd.append ('--private') if getattr(self, 'inherit', None): cmd.append ('--inherit') if getattr(self, 'deps', None): cmd.append ('--deps') if getattr(self, 'enable_non_null_experimental', None): cmd.append ('--enable-non-null-experimental') if getattr(self, 'force', None): cmd.append ('--force') cmd.append (' '.join ([x.abspath() for x in self.files])) return self.generator.bld.exec_command(' '.join(cmd))
def prepare_env(self,env): if not env.PREFIX: if Options.options.prefix or Utils.is_win32: env.PREFIX=os.path.abspath(os.path.expanduser(Options.options.prefix)) else: env.PREFIX='' if not env.BINDIR: if Options.options.bindir: env.BINDIR=os.path.abspath(os.path.expanduser(Options.options.bindir)) else: env.BINDIR=Utils.subst_vars('${PREFIX}/bin',env) if not env.LIBDIR: if Options.options.libdir: env.LIBDIR=os.path.abspath(os.path.expanduser(Options.options.libdir)) else: env.LIBDIR=Utils.subst_vars('${PREFIX}/lib%s'%Utils.lib64(),env)
def configure(conf): """ Read the command-line options to set lots of variables in *conf.env*. The variables BINDIR and LIBDIR will be overwritten. """ def get_param(varname, default): return getattr(Options.options, varname, '') or default env = conf.env conf.env.LIBDIR = conf.env.BINDIR = [] env['EXEC_PREFIX'] = get_param('EXEC_PREFIX', env['PREFIX']) env['PACKAGE'] = getattr(Context.g_module, 'APPNAME', None) or env['PACKAGE'] complete = False iter = 0 while not complete and iter < len(_options) + 1: iter += 1 complete = True for name, help, default in _options: name = name.upper() if not env[name]: try: env[name] = Utils.subst_vars(get_param(name, default).replace('/', os.sep), env) except TypeError: complete = False if not complete: lst = [name for name, _, _ in _options if not env[name.upper()]] raise conf.errors.WafError('Variable substitution failure %r' % lst)
def apply_target_framework(self): if getattr(self.bld, 'is_idegen', False): return # Add TargetFrameworkAttribute to the assembly self.env.EMIT_SOURCE = Utils.subst_vars(target_framework_template, self.env) name = '.NETFramework,Version=%s.AssemblyAttributes.cs' % self.env.TARGET_FRAMEWORK target = self.path.find_or_declare(name) tsk = self.create_task('emit', None, [ target ]) self.source = self.to_nodes(self.source) + tsk.outputs # For any use entries that can't be resolved to a task generator # assume they are system reference assemblies and add them to the # ASSEMBLIES variable so they get full path linkage automatically added filtered = [] names = self.to_list(getattr(self, 'use', [])) get = self.bld.get_tgen_by_name for x in names: try: y = get(x) if 'fake_lib' in getattr(y, 'features', ''): y.post() install_outputs(y) filtered.append(x) except Errors.WafError: self.env.append_value('ASSEMBLIES', x) self.use = filtered
def scan(self): """ Scan gresource dependencies through ``glib-compile-resources --generate-dependencies command`` """ bld = self.generator.bld kw = {} try: if not kw.get('cwd', None): kw['cwd'] = bld.cwd except AttributeError: bld.cwd = kw['cwd'] = bld.variant_dir kw['quiet'] = Context.BOTH cmd = Utils.subst_vars('${GLIB_COMPILE_RESOURCES} --sourcedir=%s --sourcedir=%s --generate-dependencies %s' % ( self.inputs[0].parent.srcpath(), self.inputs[0].bld_dir(), self.inputs[0].bldpath() ), self.env) output = bld.cmd_and_log(cmd, **kw) nodes = [] names = [] for dep in output.splitlines(): if dep: node = bld.bldnode.find_node(dep) if node: nodes.append(node) else: names.append(dep) return (nodes, names)
def apply_bdevnum(self): if (not getattr(self, 'bdevnum', '') or os.name != 'posix' or self.env.DEST_BINFMT not in ('elf', 'mac-o')): return link = self.link_task nums = self.bdevnum.split('.') node = link.outputs[0] libname = node.name if libname.endswith('.dylib'): name3 = libname.replace('.dylib', '.%s.dylib' % self.bdevnum) name2 = libname.replace('.dylib', '.%s.dylib' % (nums[0] + '.' + nums[1])) else: name3 = libname + '.' + self.bdevnum name2 = libname + '.' + nums[0] + '.' + nums[1] # add the so name for the ld linker - to disable, just unset env.SONAME_ST if self.env.SONAME_ST: if getattr(self, 'bdesoname', None): v = self.env.SONAME_ST % self.bdesoname else: v = self.env.SONAME_ST % name2 self.env.append_value('LINKFLAGS', v.split()) # the following task is just to enable execution from the build dir :-/ if self.env.DEST_OS != 'openbsd': self.create_task('vnum', node, [node.parent.find_or_declare(name2), node.parent.find_or_declare(name3)]) if getattr(self, 'install_task', None): self.install_task.hasrun = Task.SKIP_ME bld = self.bld path = self.install_task.dest if self.env.DEST_OS == 'openbsd': libname = self.link_task.outputs[0].name t1 = bld.install_as('%s%s%s' % (path, os.sep, libname), node, env=self.env, chmod=self.link_task.chmod) self.vnum_install_task = (t1,) else: t1 = bld.install_as(path + os.sep + name3, node, env=self.env, chmod=self.link_task.chmod) t2 = bld.symlink_as(path + os.sep + name2, name3) t3 = bld.symlink_as(path + os.sep + libname, name3) self.vnum_install_task = (t1, t2, t3) if '-dynamiclib' in self.env['LINKFLAGS']: # this requires after(propagate_uselib_vars) try: inst_to = self.install_path except AttributeError: inst_to = self.link_task.__class__.inst_to if inst_to: p = Utils.subst_vars(inst_to, self.env) path = os.path.join(p, self.link_task.outputs[0].name) self.env.append_value('LINKFLAGS', ['-install_name', path])
def get_ssh_hosts(self): lst = [] for v in Context.g_module.variants: self.env.HOST = self.login_to_host(self.variant_to_login(v)) cmd = Utils.subst_vars('${SSH_KEYSCAN} -t rsa,ecdsa ${HOST}', self.env) out, err = self.cmd_and_log(cmd, output=Context.BOTH, quiet=Context.BOTH) lst.append(out.strip()) return lst
def python_get(self, name): self.start_msg("Install %s into virtualenv" % (name)) self.cmd_and_log( [Utils.subst_vars('${VPIP}',self.env), "install", name], output=Context.BOTH, cwd=self.env.VENV_PATH ) self.end_msg("ok")
def run(self): code='\n'.join(['%s = %s'%(x,self.pars[x])for x in self.pars]) code=code cmd=Utils.subst_vars(DOXY_STR,self.env) env=self.env.env or None proc=Utils.subprocess.Popen(cmd,shell=True,stdin=Utils.subprocess.PIPE,env=env,cwd=self.generator.bld.path.get_bld().abspath()) proc.communicate(code) return proc.returncode
def run(self): from waflib import Utils if getattr(self, 'code', None): txt = self.code else: txt = self.inputs[0].read() txt = Utils.subst_vars(txt, self.env) self.outputs[0].write(txt)
def run(self): code = '\n'.join(['%s = %s' % (x, self.pars[x]) for x in self.pars]) code = code.encode() # for python 3 #fmt = DOXY_STR % (self.inputs[0].parent.abspath()) cmd = Utils.subst_vars(DOXY_STR, self.env) proc = Utils.subprocess.Popen(cmd, shell=True, stdin=Utils.subprocess.PIPE) proc.communicate(code) return proc.returncode
def get_install_path(self,destdir=True): if isinstance(self.install_to,Node.Node): dest=self.install_to.abspath() else: dest=Utils.subst_vars(self.install_to,self.env) if destdir and Options.options.destdir: dest=os.path.join(Options.options.destdir,os.path.splitdrive(dest)[1].lstrip(os.sep)) return dest
def run(self): dct=self.pars.copy() code='\n'.join(['%s = %s'%(x,dct[x])for x in self.pars]) code=code cmd=Utils.subst_vars(DOXY_STR,self.env) env=self.env.env or None proc=Utils.subprocess.Popen(cmd,shell=True,stdin=Utils.subprocess.PIPE,env=env,cwd=self.inputs[0].parent.abspath()) proc.communicate(code) return proc.returncode
def get_zip_src(self, tsk): destpath = Utils.subst_vars(tsk.dest, tsk.env).replace('/', os.sep) bindir = Utils.subst_vars('${BINDIR}', tsk.env) destpath = os.path.relpath(destpath, bindir) for src in tsk.source: if not hasattr(tsk, 'relative_trick'): destfile = destpath elif tsk.relative_trick: destfile = os.path.join(destpath, src.path_from(tsk.path)) else: destfile = os.path.join(destpath, src.name) external_attr = tsk.chmod << 16L destfile = os.path.normpath(destfile).replace('\\', '/') self.zip_inputs.append((src, destfile, external_attr))
def apply_vnum(self): """ Enforce version numbering on shared libraries. The valid version numbers must have at most two dots:: def build(bld): bld.shlib(source='a.c', target='foo', vnum='14.15.16') In this example, ``libfoo.so`` is installed as ``libfoo.so.1.2.3``, and the following symbolic links are created: * ``libfoo.so → libfoo.so.1.2.3`` * ``libfoo.so.1 → libfoo.so.1.2.3`` """ if not getattr(self, 'vnum', '') or os.name != 'posix' or self.env.DEST_BINFMT not in ('elf', 'mac-o'): return link = self.link_task if not re_vnum.match(self.vnum): raise Errors.WafError('Invalid version %r for %r' % (self.vnum, self)) nums = self.vnum.split('.') node = link.outputs[0] libname = node.name if libname.endswith('.dylib'): name3 = libname.replace('.dylib', '.%s.dylib' % self.vnum) name2 = libname.replace('.dylib', '.%s.dylib' % nums[0]) else: name3 = libname + '.' + self.vnum name2 = libname + '.' + nums[0] # add the so name for the ld linker - to disable, just unset env.SONAME_ST if self.env.SONAME_ST: v = self.env.SONAME_ST % name2 self.env.append_value('LINKFLAGS', v.split()) # the following task is just to enable execution from the build dir :-/ self.create_task('vnum', node, [node.parent.find_or_declare(name2), node.parent.find_or_declare(name3)]) if getattr(self, 'install_task', None): self.install_task.hasrun = Task.SKIP_ME bld = self.bld path = self.install_task.dest t1 = bld.install_as(path + os.sep + name3, node, env=self.env, chmod=self.link_task.chmod) t2 = bld.symlink_as(path + os.sep + name2, name3) t3 = bld.symlink_as(path + os.sep + libname, name3) self.vnum_install_task = (t1, t2, t3) if '-dynamiclib' in self.env['LINKFLAGS']: # this requires after(propagate_uselib_vars) try: inst_to = self.install_path except AttributeError: inst_to = self.link_task.__class__.inst_to if inst_to: p = Utils.subst_vars(inst_to, self.env) path = os.path.join(p, self.link_task.outputs[0].name) self.env.append_value('LINKFLAGS', ['-install_name', path])
def get_install_path(self, destdir=True): """ Installation path obtained from ``self.dest`` and prefixed by the destdir. The variables such as '${PREFIX}/bin' are substituted. """ dest = Utils.subst_vars(self.dest, self.env) dest = dest.replace('/', os.sep) if destdir and Options.options.destdir: dest = os.path.join(Options.options.destdir, os.path.splitdrive(dest)[1].lstrip(os.sep)) return dest