def asm_incflags(self): if self.env["ASINCFLAGS"]: self.env["_ASINCFLAGS"] = self.env["ASINCFLAGS"] if "cxx" in self.features: self.env["_ASINCFLAGS"] = self.env["_CXXINCFLAGS"] else: self.env["_ASINCFLAGS"] = self.env["_CCINCFLAGS"] def detect(conf): comp = os.environ.get("AS", "") if not comp: comp = conf.find_program("as", var="AS") if not comp: comp = conf.find_program("gas", var="AS") if not comp: comp = conf.env["CC"] if not comp: return v = conf.env v["ASFLAGS"] = "" extension(EXT_ASM)(asm_hook) taskgen(asm_incflags) after("apply_obj_vars_cc")(asm_incflags) after("apply_obj_vars_cxx")(asm_incflags) before("apply_link")(asm_incflags)
feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib')(default_link_install) after('apply_link', 'vars_target_cprogram', 'vars_target_cshlib')(default_link_install) feature('cc', 'cxx')(apply_incpaths) after('apply_type_vars', 'apply_lib_vars', 'apply_core')(apply_incpaths) feature('cc', 'cxx')(apply_type_vars) after('init_cc', 'init_cxx')(apply_type_vars) before('apply_lib_vars')(apply_type_vars) feature('cprogram', 'cshlib', 'cstaticlib')(apply_link) after('apply_core')(apply_link) feature('cc', 'cxx')(apply_lib_vars) after('apply_link', 'init_cc', 'init_cxx', 'apply_core')(apply_lib_vars) feature('cprogram', 'cstaticlib', 'cshlib')(apply_objdeps) after('init_cc', 'init_cxx', 'apply_link')(apply_objdeps) feature('cprogram', 'cshlib', 'cstaticlib')(apply_obj_vars) after('apply_lib_vars')(apply_obj_vars) after('apply_link')(process_obj_files) taskgen(add_obj_file) feature('cc', 'cxx')(add_extra_flags) before('init_cxx', 'init_cc')(add_extra_flags) before('apply_lib_vars', 'apply_obj_vars', 'apply_incpaths', 'init_cc')(add_extra_flags) feature('cshlib')(apply_implib) after('apply_link', 'default_cc')(apply_implib) before('apply_lib_vars', 'apply_objdeps', 'default_link_install')(apply_implib) feature('cshlib')(apply_vnum) after('apply_link')(apply_vnum) before('apply_lib_vars', 'default_link_install')(apply_vnum) conftest(add_as_needed)
task.inputs = [node] task.outputs = [node.change_ext(obj_ext)] self.compiled_tasks.append(task) self.meths.append('asm_incflags') def asm_incflags(self): if self.env['ASINCFLAGS']: self.env['_ASINCFLAGS'] = self.env['ASINCFLAGS'] if 'cxx' in self.features: self.env['_ASINCFLAGS'] = self.env['_CXXINCFLAGS'] else: self.env['_ASINCFLAGS'] = self.env['_CCINCFLAGS'] def detect(conf): comp = conf.environ.get('AS', '') if not comp: comp = conf.env['AS'] if not comp: comp = conf.find_program('as', var='AS') if not comp: comp = conf.find_program('gas', var='AS') if not comp: comp = conf.env['CC'] if not comp: return v = conf.env v['ASFLAGS'] = '' extension(EXT_ASM)(asm_hook) taskgen(asm_incflags) after('apply_obj_vars_cc')(asm_incflags) after('apply_obj_vars_cxx')(asm_incflags) before('apply_link')(asm_incflags)
return 0 def plist_build(task): env = task.env f = open(task.outputs[0].abspath(env), "w") f.write(task.mac_plist) f.close() return 0 Task.task_type_from_func("macapp", vars=[], func=app_build, after="cxx_link cc_link static_link") Task.task_type_from_func("macplist", vars=[], func=plist_build, after="cxx_link cc_link static_link") feature("cc", "cxx")(set_macosx_deployment_target) before("apply_lib_vars")(set_macosx_deployment_target) feature("cc", "cxx")(apply_framework) after("apply_lib_vars")(apply_framework) taskgen(create_bundle_dirs) taskgen(create_task_macapp) after("apply_link")(create_task_macapp) feature("cprogram")(create_task_macapp) after("apply_link")(create_task_macplist) feature("cprogram")(create_task_macplist) after("apply_link")(apply_link_osx) feature("cshlib")(apply_link_osx) before("apply_link", "apply_lib_vars")(apply_bundle) feature("cc", "cxx")(apply_bundle) after("apply_link")(apply_bundle_remove_dynamiclib) feature("cshlib")(apply_bundle_remove_dynamiclib)
self.header_lst.append([filename,install_path]) def process_header(self): env=self.env for i in getattr(self,'header_lst',[]): node=self.path.find_resource(i[0]) if not node: raise Utils.WafError('file not found on d obj '+i[0]) task=self.create_task('d_header') task.set_inputs(node) task.set_outputs(node.change_ext('.di')) d_header_str='${D_COMPILER} ${D_HEADER} ${SRC}' Task.simple_task_type('d_header',d_header_str,color='BLUE') feature('d')(init_d) before('apply_type_vars')(init_d) feature('d')(init_d) before('apply_d_libs')(init_d) feature('d')(apply_d_libs) after('apply_d_link')(apply_d_libs) before('apply_vnum')(apply_d_libs) feature('dprogram','dshlib','dstaticlib')(apply_d_link) after('apply_core')(apply_d_link) feature('d')(apply_d_vars) after('apply_core')(apply_d_vars) feature('dshlib')(add_shlib_d_flags) after('apply_d_vars')(add_shlib_d_flags) extension(EXT_D)(d_hook) taskgen(generate_header) taskgen(process_header) before('apply_core')(process_header)
outputs.append(node) if not inputs: raise Utils.WafError("command-output objects must have at least one input file") if not outputs: raise Utils.WafError("command-output objects must have at least one output file") task=command_output(self.env,cmd,cmd_node,self.argv,stdin,stdout,cwd,self.os_env,stderr) Utils.copy_attrs(self,task,'before after ext_in ext_out',only_if_set=True) self.tasks.append(task) task.set_inputs(inputs) task.set_outputs(outputs) task.dep_vars=self.to_list(self.dep_vars) for dep in self.dependencies: assert dep is not self dep.post() for dep_task in dep.tasks: task.set_run_after(dep_task) Task.task_type_from_func('copy',vars=[],func=action_process_file_func) TaskGen.task_gen.classes['command-output']=cmd_output_taskgen taskgen(apply_cmd) feature('cmd')(apply_cmd) taskgen(apply_copy) feature('copy')(apply_copy) taskgen(apply_subst) feature('subst')(apply_subst) taskgen(init_cmd_output) feature('command-output')(init_cmd_output) taskgen(apply_cmd_output) feature('command-output')(apply_cmd_output) after('init_cmd_output')(apply_cmd_output)
if value: core=env[coreval] accu=[] for lib in value: if var!='QTCORE': if lib in core: continue accu.append('-Wl,--rpath='+lib) env['RPATH_'+var]=accu process_rpath(vars,'LIBPATH_QTCORE') process_rpath(vars_debug,'LIBPATH_QTCORE_DEBUG') env['QTLOCALE']=str(env['PREFIX'])+'/share/locale' def detect(conf): if sys.platform=='win32':conf.fatal('Qt4.py will not work on win32 for now - ask the author') detect_qt4(conf) def set_options(opt): opt.add_option('--want-rpath',type='int',default=1,dest='want_rpath',help='set rpath to 1 or 0 [Default 1]') opt.add_option('--header-ext',type='string',default='',help='header extension for moc files',dest='qt_header_ext') for i in"qtdir qtincludes qtlibs qtbin".split(): opt.add_option('--'+i,type='string',default='',dest=i) if sys.platform=="darwin": opt.add_option('--no-qt4-framework',action="store_false",help='do not use the framework version of Qt4 in OS X',dest='use_qt4_osxframework',default=True) opt.add_option('--translate',action="store_true",help="collect translation strings",dest="trans_qt4",default=False) extension(EXT_RCC)(create_rcc_task) extension(EXT_UI)(create_uic_task) taskgen(apply_qt4) feature('qt4')(apply_qt4) after('apply_link')(apply_qt4) extension(EXT_QT4)(cxx_hook)
conf.env.rubyext_PATTERN='%s.'+read_config('DLEXT')[0] flags=read_config('LDSHARED') while flags and flags[0][0]!='-': flags=flags[1:] if len(flags)>1 and flags[1]=="ppc": flags=flags[2:] conf.env.LINKFLAGS_RUBYEXT=flags conf.env.LINKFLAGS_RUBYEXT+=read_config("LIBS") conf.env.LINKFLAGS_RUBYEXT+=read_config("LIBRUBYARG_SHARED") if Options.options.rubyarchdir: conf.env.ARCHDIR_RUBY=Options.options.rubyarchdir else: conf.env.ARCHDIR_RUBY=read_config('sitearchdir')[0] if Options.options.rubylibdir: conf.env.LIBDIR_RUBY=Options.options.rubylibdir else: conf.env.LIBDIR_RUBY=read_config('sitelibdir')[0] def set_options(opt): opt.add_option('--with-ruby-archdir',type='string',dest='rubyarchdir',help='Specify directory where to install arch specific files') opt.add_option('--with-ruby-libdir',type='string',dest='rubylibdir',help='Specify alternate ruby library path') opt.add_option('--with-ruby-binary',type='string',dest='rubybinary',help='Specify alternate ruby binary') taskgen(init_rubyext) before('apply_incpaths','apply_type_vars','apply_lib_vars')(init_rubyext) feature('rubyext')(init_rubyext) before('apply_bundle')(init_rubyext) before('apply_link')(apply_ruby_so_name) feature('rubyext')(apply_ruby_so_name) conf(check_ruby_version) conf(check_ruby_ext_devel)
print"libtool-config version %s"%REVISION return 0 ltf=libtool_config(args[0]) if options.debug: print(ltf) if options.atleast_version: if ltf>=options.atleast_version:return 0 sys.exit(1) if options.exact_version: if ltf==options.exact_version:return 0 sys.exit(1) if options.max_version: if ltf<=options.max_version:return 0 sys.exit(1) def p(x): print" ".join(x) if options.libs:p(ltf.get_libs()) elif options.libs_only_l:p(ltf.get_libs_only_l()) elif options.libs_only_L:p(ltf.get_libs_only_L()) elif options.libs_only_other:p(ltf.get_libs_only_other()) return 0 if __name__=='__main__': useCmdLine() taskgen(apply_link_libtool) feature("libtool")(apply_link_libtool) after('apply_link')(apply_link_libtool) taskgen(apply_libtool) feature("libtool")(apply_libtool) before('apply_core')(apply_libtool)
# encoding: utf-8 import os import TaskGen,Task from TaskGen import taskgen,before,extension nasm_str='${NASM} ${NASM_FLAGS} ${NASM_INCLUDES} ${SRC} -o ${TGT}' EXT_NASM=['.s','.S','.asm','.ASM','.spp','.SPP'] def apply_nasm_vars(self): if hasattr(self,'nasm_flags'): for flag in self.to_list(self.nasm_flags): self.env.append_value('NASM_FLAGS',flag) if hasattr(self,'includes'): for inc in self.to_list(self.includes): self.env.append_value('NASM_INCLUDES','-I %s'%inc.srcpath(self.env)) def nasm_file(self,node): o_node=node.change_ext('.o') task=self.create_task('nasm') task.set_inputs(node) task.set_outputs(o_node) self.compiled_tasks.append(task) self.meths.append('apply_nasm_vars') Task.simple_task_type('nasm',nasm_str,color='BLUE',ext_out='.o') def detect(conf): nasm=conf.find_program('nasm',var='NASM') if not nasm:nasm=conf.find_program('yasm',var='NASM') if not nasm:conf.fatal('could not find nasm (or yasm), install it or set PATH env var') taskgen(apply_nasm_vars) before('apply_link')(apply_nasm_vars) extension(EXT_NASM)(nasm_file)
conf.check_message("perl module %s"%module,"",r) return r def check_perl_ext_devel(conf): if not conf.env['PERL']: return False perl=conf.env['PERL'] conf.env["LINKFLAGS_PERLEXT"]=Utils.cmd_output(perl+" -MConfig -e'print $Config{lddlflags}'") conf.env["CPPPATH_PERLEXT"]=Utils.cmd_output(perl+" -MConfig -e'print \"$Config{archlib}/CORE\"'") conf.env["CCFLAGS_PERLEXT"]=Utils.cmd_output(perl+" -MConfig -e'print \"$Config{ccflags} $Config{cccdlflags}\"'") conf.env["XSUBPP"]=Utils.cmd_output(perl+" -MConfig -e'print \"$Config{privlib}/ExtUtils/xsubpp$Config{exe_ext}\"'") conf.env["EXTUTILS_TYPEMAP"]=Utils.cmd_output(perl+" -MConfig -e'print \"$Config{privlib}/ExtUtils/typemap\"'") if not getattr(Options.options,'perlarchdir',None): conf.env["ARCHDIR_PERL"]=Utils.cmd_output(perl+" -MConfig -e'print $Config{sitearch}'") else: conf.env["ARCHDIR_PERL"]=getattr(Options.options,'perlarchdir') conf.env['perlext_PATTERN']='%s.'+Utils.cmd_output(perl+" -MConfig -e'print $Config{dlext}'") return True def detect(conf): pass def set_options(opt): opt.add_option("--with-perl-binary",type="string",dest="perlbinary",help='Specify alternate perl binary',default=None) opt.add_option("--with-perl-archdir",type="string",dest="perlarchdir",help='Specify directory where to install arch specific files',default=None) taskgen(init_pyext) before('apply_incpaths')(init_pyext) feature('perlext')(init_pyext) extension(EXT_XS)(xsubpp_file) conf(check_perl_version) conf(check_perl_module) conf(check_perl_ext_devel)
def detect(conf): opt=conf.find_program('ocamlopt',var='OCAMLOPT') occ=conf.find_program('ocamlc',var='OCAMLC') if(not opt)or(not occ): conf.fatal('The objective caml compiler was not found:\ninstall it or make it available in your PATH') conf.env['OCAMLC']=occ conf.env['OCAMLOPT']=opt conf.env['OCAMLLEX']=conf.find_program('ocamllex',var='OCAMLLEX') conf.env['OCAMLYACC']=conf.find_program('ocamlyacc',var='OCAMLYACC') conf.env['OCAMLFLAGS']='' conf.env['OCAMLLIB']=Utils.cmd_output(conf.env['OCAMLC']+' -where').strip()+os.sep conf.env['LIBPATH_OCAML']=Utils.cmd_output(conf.env['OCAMLC']+' -where').strip()+os.sep conf.env['CPPPATH_OCAML']=Utils.cmd_output(conf.env['OCAMLC']+' -where').strip()+os.sep conf.env['LIB_OCAML']='camlrun' taskgen(init_ml) feature('ocaml')(init_ml) taskgen(init_envs_ml) feature('ocaml')(init_envs_ml) after('init_ml')(init_envs_ml) taskgen(apply_incpaths_ml) feature('ocaml')(apply_incpaths_ml) before('apply_vars_ml')(apply_incpaths_ml) after('init_envs_ml')(apply_incpaths_ml) taskgen(apply_vars_ml) feature('ocaml')(apply_vars_ml) before('apply_core')(apply_vars_ml) taskgen(apply_link_ml) feature('ocaml')(apply_link_ml) after('apply_core')(apply_link_ml) extension(EXT_MLL)(mll_hook)
path=self.install_path libname=task.outputs[0].name name3=libname.replace('.dylib','.%s.dylib'%task.vnum) name2=libname.replace('.dylib','.%s.dylib'%nums[0]) name1=libname filename=task.outputs[0].abspath(task.env) bld=Build.bld bld.install_as(path+name3,filename,env=task.env) bld.symlink_as(path+name2,name3) bld.symlink_as(path+name1,name3) def install_target_osx_cshlib(self): if not Options.is_install:return if getattr(self,'vnum','')and sys.platform!='win32': self.link_task.install=install_shlib Task.task_type_from_func('macapp',vars=[],func=app_build,after="cxx_link cc_link ar_link_static") taskgen(create_task_macapp) taskgen(apply_link_osx) after('apply_link')(apply_link_osx) feature('cc','cxx')(apply_link_osx) taskgen(apply_bundle) before('apply_link')(apply_bundle) before('apply_lib_vars')(apply_bundle) feature('cc','cxx')(apply_bundle) taskgen(apply_bundle_remove_dynamiclib) after('apply_link')(apply_bundle_remove_dynamiclib) feature('cc','cxx')(apply_bundle_remove_dynamiclib) taskgen(install_target_osx_cshlib) feature('osx')(install_target_osx_cshlib) after('install_target_cshlib')(install_target_osx_cshlib)
if enum[param]: options.append('%s %r' % (option, enum[param])) env['GLIB_MKENUMS_OPTIONS'] = ' '.join(options) task.set_inputs(inputs) task.set_outputs(tgt_node) Task.task_type_from_func('glib_genmarshal', func=genmarshal_func, vars=['GLIB_GENMARSHAL_PREFIX', 'GLIB_GENMARSHAL'], color='BLUE', before='cc') Task.simple_task_type( 'glib_mkenums', '${GLIB_MKENUMS} ${GLIB_MKENUMS_OPTIONS} ${GLIB_MKENUMS_SOURCE} > ${GLIB_MKENUMS_TARGET}', color='PINK', before='cc') def detect(conf): glib_genmarshal = conf.find_program('glib-genmarshal', var='GLIB_GENMARSHAL') mk_enums_tool = conf.find_program('glib-mkenums', var='GLIB_MKENUMS') taskgen(add_marshal_file) before('apply_core')(process_marshal) taskgen(add_enums_from_template) taskgen(add_enums) before('apply_core')(process_enums)
val=self.env[v+'_'+var] if val:self.env.append_value(v,val) def apply_cs(self): assemblies_flags=[] for i in self.to_list(self.assemblies)+self.env['ASSEMBLIES']: assemblies_flags+='/r:'+i self.env['_ASSEMBLIES']+=assemblies_flags for i in self.to_list(self.resources): self.env['_RESOURCES'].append('/resource:'+i) self.env['_FLAGS']+=self.to_list(self.flags)+self.env['FLAGS'] curnode=self.path nodes=[] for i in self.to_list(self.source): nodes.append(curnode.find_resource(i)) task=self.create_task('mcs') task.inputs=nodes task.set_outputs(self.path.find_or_declare(self.target)) Task.simple_task_type('mcs','${MCS} ${SRC} /out:${TGT} ${_FLAGS} ${_ASSEMBLIES} ${_RESOURCES}',color='YELLOW') def detect(conf): mcs=conf.find_program('mcs',var='MCS') if not mcs:mcs=conf.find_program('gmcs',var='MCS') taskgen(init_cs) feature('cs')(init_cs) taskgen(apply_uselib_cs) feature('cs')(apply_uselib_cs) after('init_cs')(apply_uselib_cs) taskgen(apply_cs) feature('cs')(apply_cs) after('apply_uselib_cs')(apply_cs)
env['GLIB_MKENUMS_SOURCE']=[k.srcpath(env)for k in source_list] if not enum['target']: raise Utils.WafError('missing target '+str(enum)) tgt_node=self.path.find_or_declare(enum['target']) if tgt_node.name.endswith('.c'): self.allnodes.append(tgt_node) env['GLIB_MKENUMS_TARGET']=tgt_node.abspath(env) options=[] if enum['template']: template_node=self.path.find_resource(enum['template']) options.append('--template %s'%(template_node.abspath(env))) inputs.append(template_node) params={'file-head':'--fhead','file-prod':'--fprod','file-tail':'--ftail','enum-prod':'--eprod','value-head':'--vhead','value-prod':'--vprod','value-tail':'--vtail','comments':'--comments'} for param,option in params.iteritems(): if enum[param]: options.append('%s %r'%(option,enum[param])) env['GLIB_MKENUMS_OPTIONS']=' '.join(options) task.set_inputs(inputs) task.set_outputs(tgt_node) Task.task_type_from_func('glib_genmarshal',func=genmarshal_func,vars=['GLIB_GENMARSHAL_PREFIX','GLIB_GENMARSHAL'],color='BLUE',before='cc cxx') Task.simple_task_type('glib_mkenums','${GLIB_MKENUMS} ${GLIB_MKENUMS_OPTIONS} ${GLIB_MKENUMS_SOURCE} > ${GLIB_MKENUMS_TARGET}',color='PINK',before='cc cxx') def detect(conf): glib_genmarshal=conf.find_program('glib-genmarshal',var='GLIB_GENMARSHAL') mk_enums_tool=conf.find_program('glib-mkenums',var='GLIB_MKENUMS') taskgen(add_marshal_file) before('apply_core')(process_marshal) taskgen(add_enums_from_template) taskgen(add_enums) before('apply_core')(process_enums)
self.dbus_lst.append([filename, prefix, mode]) def process_dbus(self): for filename, prefix, mode in getattr(self, 'dbus_lst', []): env = self.env.copy() node = self.path.find_resource(filename) if not node: raise Utils.WafError('file not found ' + filename) env['DBUS_BINDING_TOOL_PREFIX'] = prefix env['DBUS_BINDING_TOOL_MODE'] = mode task = self.create_task('dbus_binding_tool', env) task.set_inputs(node) task.set_outputs(node.change_ext('.h')) Task.simple_task_type( 'dbus_binding_tool', '${DBUS_BINDING_TOOL} --prefix=${DBUS_BINDING_TOOL_PREFIX} --mode=${DBUS_BINDING_TOOL_MODE} --output=${TGT} ${SRC}', color='BLUE', before='cc') def detect(conf): dbus_binding_tool = conf.find_program('dbus-binding-tool', var='DBUS_BINDING_TOOL') taskgen(add_dbus_file) before('apply_core')(process_dbus)
debug_level=Options.options.debug_level.upper() except AttributeError: debug_level=ccroot.DEBUG_LEVELS.CUSTOM v['CCFLAGS']+=v['CCFLAGS_'+debug_level] v['CXXFLAGS']+=v['CXXFLAGS_'+debug_level] v['LINKFLAGS']+=v['LINKFLAGS_'+debug_level] v['shlib_CCFLAGS']=[''] v['shlib_CXXFLAGS']=[''] v['shlib_LINKFLAGS']=['/DLL'] v['shlib_PATTERN']='%s.dll' v['staticlib_LINKFLAGS']=[''] v['staticlib_PATTERN']='%s.lib' v['program_PATTERN']='%s.exe' def set_options(opt): opt.add_option('-d','--debug-level',action='store',default=ccroot.DEBUG_LEVELS.DEBUG,help="Specify the debug level, does nothing if CFLAGS is set in the environment. [Allowed Values: '%s']"%"', '".join(ccroot.DEBUG_LEVELS.ALL),choices=ccroot.DEBUG_LEVELS.ALL,dest='debug_level') taskgen(apply_msvc_obj_vars) feature('cc','cxx')(apply_msvc_obj_vars) after('apply_obj_vars_cc')(apply_msvc_obj_vars) after('apply_obj_vars_cxx')(apply_msvc_obj_vars) taskgen(apply_link_msvc) feature('cc','cxx')(apply_link_msvc) after('apply_core')(apply_link_msvc) before('apply_obj_vars_cc')(apply_link_msvc) before('apply_obj_vars_cxx')(apply_link_msvc) taskgen(init_msvc) feature('cc','cxx')(init_msvc) before('apply_core')(init_msvc) conftest(find_msvc) conftest(msvc_common_flags)
#! /usr/bin/env python # encoding: utf-8 import Task,Utils from TaskGen import taskgen,before,after,feature def add_dbus_file(self,filename,prefix,mode): if not hasattr(self,'dbus_lst'): self.dbus_lst=[] self.meths.append('process_dbus') self.dbus_lst.append([filename,prefix,mode]) def process_dbus(self): for filename,prefix,mode in getattr(self,'dbus_lst',[]): env=self.env.copy() node=self.path.find_resource(filename) if not node: raise Utils.WafError('file not found '+filename) env['DBUS_BINDING_TOOL_PREFIX']=prefix env['DBUS_BINDING_TOOL_MODE']=mode task=self.create_task('dbus_binding_tool',env) task.set_inputs(node) task.set_outputs(node.change_ext('.h')) Task.simple_task_type('dbus_binding_tool','${DBUS_BINDING_TOOL} --prefix=${DBUS_BINDING_TOOL_PREFIX} --mode=${DBUS_BINDING_TOOL_MODE} --output=${TGT} ${SRC}',color='BLUE',before='cc') def detect(conf): dbus_binding_tool=conf.find_program('dbus-binding-tool',var='DBUS_BINDING_TOOL') taskgen(add_dbus_file) taskgen(process_dbus) before('apply_core')(process_dbus)
#!/usr/bin/env python2 # encoding: utf-8 import Task,Utils from TaskGen import taskgen,before,after,feature def add_dbus_file(self,filename,prefix,mode): if not hasattr(self,'dbus_lst'): self.dbus_lst=[] self.meths.append('process_dbus') self.dbus_lst.append([filename,prefix,mode]) def process_dbus(self): for filename,prefix,mode in getattr(self,'dbus_lst',[]): node=self.path.find_resource(filename) if not node: raise Utils.WafError('file not found '+filename) tsk=self.create_task('dbus_binding_tool',node,node.change_ext('.h')) tsk.env.DBUS_BINDING_TOOL_PREFIX=prefix tsk.env.DBUS_BINDING_TOOL_MODE=mode Task.simple_task_type('dbus_binding_tool','${DBUS_BINDING_TOOL} --prefix=${DBUS_BINDING_TOOL_PREFIX} --mode=${DBUS_BINDING_TOOL_MODE} --output=${TGT} ${SRC}',color='BLUE',before='cc') def detect(conf): dbus_binding_tool=conf.find_program('dbus-binding-tool',var='DBUS_BINDING_TOOL') taskgen(add_dbus_file) before('apply_core')(process_dbus)
raise Utils.WafError('missing target '+str(enum)) tgt_node=self.path.find_or_declare(enum['target']) if tgt_node.name.endswith('.c'): self.allnodes.append(tgt_node) env['GLIB_MKENUMS_TARGET']=tgt_node.abspath(env) options=[] if enum['template']: template_node=self.path.find_resource(enum['template']) options.append('--template %s'%(template_node.abspath(env))) inputs.append(template_node) params={'file-head':'--fhead','file-prod':'--fprod','file-tail':'--ftail','enum-prod':'--eprod','value-head':'--vhead','value-prod':'--vprod','value-tail':'--vtail','comments':'--comments'} for param,option in params.iteritems(): if enum[param]: options.append('%s %r'%(option,enum[param])) env['GLIB_MKENUMS_OPTIONS']=' '.join(options) task.set_inputs(inputs) task.set_outputs(tgt_node) Task.simple_task_type('glib_genmarshal','${GLIB_GENMARSHAL} ${SRC} --prefix=${GLIB_GENMARSHAL_PREFIX} ${GLIB_GENMARSHAL_MODE} > ${TGT}',color='BLUE',before='cc') Task.simple_task_type('glib_mkenums','${GLIB_MKENUMS} ${GLIB_MKENUMS_OPTIONS} ${GLIB_MKENUMS_SOURCE} > ${GLIB_MKENUMS_TARGET}',color='PINK',before='cc') def detect(conf): glib_genmarshal=conf.find_program('glib-genmarshal',var='GLIB_GENMARSHAL') mk_enums_tool=conf.find_program('glib-mkenums',var='GLIB_MKENUMS') taskgen(add_marshal_file) taskgen(process_marshal) before('apply_core')(process_marshal) taskgen(add_enums_from_template) taskgen(add_enums) taskgen(process_enums) before('apply_core')(process_enums)
app_dirs=['Contents','Contents/MacOS','Contents/Resources'] def app_build(task): env=task.env shutil.copy2(task.inputs[0].srcpath(env),task.outputs[0].abspath(env)) return 0 def plist_build(task): env=task.env f=open(task.outputs[0].abspath(env),"w") f.write(task.mac_plist) f.close() return 0 Task.task_type_from_func('macapp',vars=[],func=app_build,after="cxx_link cc_link static_link") Task.task_type_from_func('macplist',vars=[],func=plist_build,after="cxx_link cc_link static_link") feature('cc','cxx')(set_macosx_deployment_target) before('apply_lib_vars')(set_macosx_deployment_target) feature('cc','cxx')(apply_framework) after('apply_lib_vars')(apply_framework) taskgen(create_bundle_dirs) taskgen(create_task_macapp) after('apply_link')(create_task_macapp) feature('cprogram')(create_task_macapp) after('apply_link')(create_task_macplist) feature('cprogram')(create_task_macplist) after('apply_link')(apply_link_osx) feature('cshlib')(apply_link_osx) before('apply_link','apply_lib_vars')(apply_bundle) feature('cc','cxx')(apply_bundle) after('apply_link')(apply_bundle_remove_dynamiclib) feature('cshlib')(apply_bundle_remove_dynamiclib)
f = open(file, "r") txt = f.read() f.close() except (OSError, IOError): conf.fatal("could not read %s" % file) txt = txt.replace("\\\n", "\n") fu = re.compile("#(.*)\n") txt = fu.sub("", txt) setregexp = re.compile('([sS][eE][tT]\s*\()\s*([^\s]+)\s+"([^"]+)"\)') found = setregexp.findall(txt) for (_, key, val) in found: conf.env[key] = val conf.env["LIB_KDECORE"] = "kdecore" conf.env["LIB_KDEUI"] = "kdeui" conf.env["LIB_KIO"] = "kio" conf.env["LIB_KHTML"] = "khtml" conf.env["LIB_KPARTS"] = "kparts" conf.env["LIBPATH_KDECORE"] = conf.env["KDE4_LIB_INSTALL_DIR"] conf.env["CPPPATH_KDECORE"] = conf.env["KDE4_INCLUDE_INSTALL_DIR"] conf.env.append_value("CPPPATH_KDECORE", conf.env["KDE4_INCLUDE_INSTALL_DIR"] + "/KDE") conf.env["MSGFMT"] = conf.find_program("msgfmt") Task.simple_task_type("msgfmt", "${MSGFMT} ${SRC} -o ${TGT}", color="BLUE") taskgen(init_msgfmt) feature("msgfmt")(init_msgfmt) taskgen(apply_msgfmt) feature("msgfmt")(apply_msgfmt) after("init_msgfmt")(apply_msgfmt)
before('apply_core')(vars_target_cprogram) after('default_cc')(vars_target_cshlib) feature('cshlib','dshlib')(vars_target_cshlib) before('apply_core')(vars_target_cshlib) feature('cprogram','dprogram','cstaticlib','dstaticlib','cshlib','dshlib')(default_link_install) after('apply_link','vars_target_cprogram','vars_target_cshlib')(default_link_install) feature('cc','cxx')(apply_incpaths) after('apply_type_vars','apply_lib_vars','apply_core')(apply_incpaths) feature('cc','cxx')(apply_type_vars) after('init_cc','init_cxx')(apply_type_vars) before('apply_lib_vars')(apply_type_vars) feature('cprogram','cshlib','cstaticlib')(apply_link) after('apply_core')(apply_link) feature('cc','cxx')(apply_lib_vars) after('apply_link','init_cc','init_cxx')(apply_lib_vars) feature('cprogram','cstaticlib','cshlib')(apply_objdeps) after('apply_link')(apply_objdeps) feature('cprogram','cshlib','cstaticlib')(apply_obj_vars) after('apply_lib_vars')(apply_obj_vars) after('apply_link')(process_obj_files) taskgen(add_obj_file) feature('cc','cxx')(add_extra_flags) before('init_cxx','init_cc')(add_extra_flags) before('apply_lib_vars','apply_obj_vars','apply_incpaths','init_cc')(add_extra_flags) feature('cshlib')(apply_implib) after('apply_link','default_cc')(apply_implib) before('apply_lib_vars','apply_objdeps','default_link_install')(apply_implib) feature('cshlib')(apply_vnum) after('apply_link')(apply_vnum) before('apply_lib_vars','default_link_install')(apply_vnum)
#! /usr/bin/env python # encoding: utf-8 import TaskGen from TaskGen import taskgen,feature TaskGen.declare_chain(name='luac',action='${LUAC} -s -o ${TGT} ${SRC}',ext_in='.lua',ext_out='.luac',reentrant=0,install='LUADIR',) def init_lua(self): self.default_chmod=0755 def detect(conf): luac=conf.find_program('luac',var='LUAC') if not luac:conf.fatal('cannot find the compiler "luac"') taskgen(init_lua) feature('lua')(init_lua)
conf.define('ENABLE_NLS',1) conf.define('HAVE_BIND_TEXTDOMAIN_CODESET',1) conf.define('HAVE_DCGETTEXT',1) conf.check(header_name='dlfcn.h',define_name='HAVE_DLFCN_H') conf.define('HAVE_GETTEXT',1) conf.check(header_name='inttypes.h',define_name='HAVE_INTTYPES_H') conf.check(header_name='locale.h',define_name='HAVE_LOCALE_H') conf.check(header_name='memory.h',define_name='HAVE_MEMORY_H') conf.check(header_name='stdint.h',define_name='HAVE_STDINT_H') conf.check(header_name='stdlib.h',define_name='HAVE_STDLIB_H') conf.check(header_name='strings.h',define_name='HAVE_STRINGS_H') conf.check(header_name='string.h',define_name='HAVE_STRING_H') conf.check(header_name='sys/stat.h',define_name='HAVE_SYS_STAT_H') conf.check(header_name='sys/types.h',define_name='HAVE_SYS_TYPES_H') conf.check(header_name='unistd.h',define_name='HAVE_UNISTD_H') def set_options(opt): opt.add_option('--want-rpath',type='int',default=1,dest='want_rpath',help='set rpath to 1 or 0 [Default 1]') taskgen(init_gnome_doc) feature('gmome_doc')(init_gnome_doc) taskgen(apply_gnome_doc) feature('gnome_doc')(apply_gnome_doc) after('init_gnome_doc')(apply_gnome_doc) taskgen(init_xml_to) feature('xml_to')(init_xml_to) taskgen(apply_xml_to) feature('xml_to')(apply_xml_to) after('init_xml_to')(apply_xml_to) taskgen(apply_gnome_sgml2man) feature('gnome_sgml2man')(apply_gnome_sgml2man)
if not result: conf.fatal("Python module not found.") def detect(conf): python=conf.find_program('python',var='PYTHON') if not python:return v=conf.env v['PYCMD']='"import sys, py_compile;py_compile.compile(sys.argv[1], sys.argv[2])"' v['PYFLAGS']='' v['PYFLAGS_OPT']='-O' v['PYC']=getattr(Options.options,'pyc',1) v['PYO']=getattr(Options.options,'pyo',1) def set_options(opt): opt.add_option('--nopyc',action='store_false',default=1,help='Do not install bytecode compiled .pyc files (configuration) [Default:install]',dest='pyc') opt.add_option('--nopyo',action='store_false',default=1,help='Do not install optimised compiled .pyo files (configuration) [Default:install]',dest='pyo') taskgen(init_pyext) before('apply_incpaths')(init_pyext) feature('pyext')(init_pyext) before('apply_bundle')(init_pyext) taskgen(pyext_shlib_ext) before('apply_link')(pyext_shlib_ext) before('apply_lib_vars')(pyext_shlib_ext) after('apply_bundle')(pyext_shlib_ext) feature('pyext')(pyext_shlib_ext) taskgen(init_pyembed) before('apply_incpaths')(init_pyembed) feature('pyembed')(init_pyembed) extension(EXT_PY)(process_py) taskgen(init_py) before('apply_core')(init_py) after('vars_target_cprogram')(init_py)
nums=task.vnum.split('.') path=self.install_path libname=task.outputs[0].name name3=libname.replace('.dylib','.%s.dylib'%task.vnum) name2=libname.replace('.dylib','.%s.dylib'%nums[0]) name1=libname filename=task.outputs[0].abspath(task.env) bld=task.outputs[0].__class__.bld bld.install_as(path+name3,filename,env=task.env) bld.symlink_as(path+name2,name3) bld.symlink_as(path+name1,name3) def install_target_osx_cshlib(self): if not self.bld.is_install:return if getattr(self,'vnum','')and sys.platform!='win32': self.link_task.install=install_shlib Task.task_type_from_func('macapp',vars=[],func=app_build,after="cxx_link cc_link ar_link_static") feature('cc','cxx')(set_macosx_deployment_target) before('apply_lib_vars')(set_macosx_deployment_target) feature('cc','cxx')(apply_framework) after('apply_lib_vars')(apply_framework) taskgen(create_task_macapp) after('apply_link')(apply_link_osx) feature('cc','cxx')(apply_link_osx) before('apply_link','apply_lib_vars')(apply_bundle) feature('cc','cxx')(apply_bundle) after('apply_link')(apply_bundle_remove_dynamiclib) feature('cshlib')(apply_bundle_remove_dynamiclib) feature('osx')(install_target_osx_cshlib) after('install_target_cshlib')(install_target_osx_cshlib)
pdftask.set_outputs(node.change_ext(".pdf")) elif self.type == "pdflatex": if "ps" in outs: pstask = self.create_task("pdf2ps") pstask.set_inputs(task.outputs) pstask.set_outputs(node.change_ext(".ps")) def detect(conf): v = conf.env for p in "tex latex pdflatex bibtex dvips dvipdf ps2pdf makeindex pdf2ps".split(): conf.find_program(p, var=p.upper()) v[p.upper() + "FLAGS"] = "" v["DVIPSFLAGS"] = "-Ppdf" b = Task.simple_task_type b("tex", "${TEX} ${TEXFLAGS} ${SRC}", color="BLUE") b("bibtex", "${BIBTEX} ${BIBTEXFLAGS} ${SRC}", color="BLUE") b("dvips", "${DVIPS} ${DVIPSFLAGS} ${SRC} -o ${TGT}", color="BLUE", after="latex pdflatex tex bibtex") b("dvipdf", "${DVIPDF} ${DVIPDFFLAGS} ${SRC} ${TGT}", color="BLUE", after="latex pdflatex tex bibtex") b("pdf2ps", "${PDF2PS} ${PDF2PSFLAGS} ${SRC} ${TGT}", color="BLUE", after="dvipdf pdflatex") b = Task.task_type_from_func cls = b("latex", latex_build, vars=latex_vardeps) cls.scan = scan cls = b("pdflatex", pdflatex_build, vars=pdflatex_vardeps) cls.scan = scan taskgen(apply_tex) feature("tex")(apply_tex)
Task.simple_task_type('d_header',d_header_str,color='BLUE',shell=False) def d_platform_flags(conf): v=conf.env binfmt=v.DEST_BINFMT or Utils.unversioned_sys_platform_to_binary_format(v.DEST_OS or Utils.unversioned_sys_platform()) if binfmt=='pe': v['D_program_PATTERN']='%s.exe' v['D_shlib_PATTERN']='lib%s.dll' v['D_staticlib_PATTERN']='lib%s.a' else: v['D_program_PATTERN']='%s' v['D_shlib_PATTERN']='lib%s.so' v['D_staticlib_PATTERN']='lib%s.a' feature('d')(init_d) before('apply_type_vars')(init_d) feature('d')(init_d) before('apply_d_libs')(init_d) feature('d')(apply_d_libs) after('apply_d_link','init_d')(apply_d_libs) before('apply_vnum')(apply_d_libs) feature('dprogram','dshlib','dstaticlib')(apply_d_link) after('apply_core')(apply_d_link) feature('d')(apply_d_vars) after('apply_core')(apply_d_vars) feature('dshlib')(add_shlib_d_flags) after('apply_d_vars')(add_shlib_d_flags) extension(EXT_D)(d_hook) taskgen(generate_header) before('apply_core')(process_header) conftest(d_platform_flags)
System.err.println("ClassNotFoundException"); System.exit(1); } lib = null; System.exit(0); } } """ import shutil javatestdir='.waf-javatest' classpath=javatestdir if conf.env['CLASSPATH']: classpath+=os.pathsep+conf.env['CLASSPATH'] if isinstance(with_classpath,str): classpath+=os.pathsep+with_classpath shutil.rmtree(javatestdir,True) os.mkdir(javatestdir) java_file=open(os.path.join(javatestdir,'Test.java'),'w') java_file.write(class_check_source) java_file.close() os.popen(conf.env['JAVAC']+' '+os.path.join(javatestdir,'Test.java')) (jstdin,jstdout,jstderr)=os.popen3(conf.env['JAVA']+' -cp '+classpath+' Test '+classname) found=not bool(jstderr.read()) conf.check_message('Java class %s'%classname,"",found) shutil.rmtree(javatestdir,True) return found taskgen(apply_java) feature('java')(apply_java) conf(check_java_class)
v = conf.env binfmt = v.DEST_BINFMT or Utils.unversioned_sys_platform_to_binary_format( v.DEST_OS or Utils.unversioned_sys_platform()) if binfmt == 'pe': v['D_program_PATTERN'] = '%s.exe' v['D_shlib_PATTERN'] = 'lib%s.dll' v['D_staticlib_PATTERN'] = 'lib%s.a' else: v['D_program_PATTERN'] = '%s' v['D_shlib_PATTERN'] = 'lib%s.so' v['D_staticlib_PATTERN'] = 'lib%s.a' feature('d')(init_d) before('apply_type_vars')(init_d) feature('d')(init_d) before('apply_d_libs')(init_d) feature('d')(apply_d_libs) after('apply_d_link', 'init_d')(apply_d_libs) before('apply_vnum')(apply_d_libs) feature('dprogram', 'dshlib', 'dstaticlib')(apply_d_link) after('apply_core')(apply_d_link) feature('d')(apply_d_vars) after('apply_core')(apply_d_vars) feature('dshlib')(add_shlib_d_flags) after('apply_d_vars')(add_shlib_d_flags) extension(EXT_D)(d_hook) taskgen(generate_header) before('apply_core')(process_header) conftest(d_platform_flags)
feature('cc','cxx')(default_cc) before('init_cc','init_cxx')(default_cc) feature('cprogram','dprogram','cstaticlib','dstaticlib','cshlib','dshlib')(apply_verif) feature('cprogram','dprogram')(vars_target_cprogram) before('apply_core')(vars_target_cprogram) feature('cstaticlib','dstaticlib','cshlib','dshlib')(vars_target_cstaticlib) before('apply_core')(vars_target_cstaticlib) feature('cprogram','dprogram','cstaticlib','dstaticlib','cshlib','dshlib')(install_target_cstaticlib) after('apply_objdeps','apply_link')(install_target_cstaticlib) feature('cshlib','dshlib')(install_target_cshlib) after('apply_objdeps','apply_link')(install_target_cshlib) feature('cc','cxx')(apply_incpaths) after('apply_type_vars')(apply_incpaths) feature('cc','cxx')(apply_type_vars) taskgen(apply_link) feature('cprogram','cshlib','cstaticlib')(apply_link) after('apply_core')(apply_link) feature('cc','cxx')(apply_lib_vars) after('apply_vnum')(apply_lib_vars) feature('objects')(apply_objdeps) after('apply_obj_vars','apply_vnum')(apply_objdeps) feature('cprogram','cshlib','cstaticlib')(apply_obj_vars) after('apply_lib_vars')(apply_obj_vars) feature('cprogram','cshlib','cstaticlib')(apply_vnum) after('apply_link')(apply_vnum) taskgen(process_obj_files) after('apply_link')(process_obj_files) taskgen(add_obj_file) feature('objects')(make_objects_available) after('apply_core')(make_objects_available)
for name,value in cmd.env_vars.iteritems(): env_vars[name]=self._subst_arg(value,None,namespace) cmd.env_vars=env_vars elif isinstance(cmd,shellcmd.Chdir): cmd.dir=self._subst_arg(cmd.dir,None,namespace) return pipeline.run(verbose=(Options.options.verbose>0)) def init_command(self): Utils.def_attrs(self,variables=None) def apply_command(self): self.meths.remove('apply_core') task=self.create_task('command') setattr(task,"dep_vars",getattr(self,"dep_vars",None)) inputs=[] for src in self.to_list(self.source): node=self.path.find_resource(src) if node is None: raise Utils.WafError("source %s not found"%src) inputs.append(node) task.set_inputs(inputs) task.set_outputs([self.path.find_or_declare(tgt)for tgt in self.to_list(self.target)]) class command_taskgen(task_gen): def __init__(self,*k,**kw): task_gen.__init__(self,*k,**kw) self.features.append('command') taskgen(init_command) feature('command')(init_command) taskgen(apply_command) feature('command')(apply_command) before('apply_core')(apply_command)
name1 = libname filename = task.outputs[0].abspath(task.env) bld = task.outputs[0].__class__.bld bld.install_as(path + name3, filename, env=task.env) bld.symlink_as(path + name2, name3) bld.symlink_as(path + name1, name3) def install_target_osx_cshlib(self): if not self.bld.is_install: return if getattr(self, "vnum", "") and sys.platform != "win32": self.link_task.install = install_shlib Task.task_type_from_func("macapp", vars=[], func=app_build, after="cxx_link cc_link ar_link_static") feature("cc", "cxx")(set_macosx_deployment_target) before("apply_lib_vars")(set_macosx_deployment_target) feature("cc", "cxx")(apply_framework) after("apply_lib_vars")(apply_framework) taskgen(create_task_macapp) after("apply_link")(apply_link_osx) feature("cc", "cxx")(apply_link_osx) before("apply_link", "apply_lib_vars")(apply_bundle) feature("cc", "cxx")(apply_bundle) after("apply_link")(apply_bundle_remove_dynamiclib) feature("cshlib")(apply_bundle_remove_dynamiclib) feature("osx")(install_target_osx_cshlib) after("install_target_cshlib")(install_target_osx_cshlib)