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)
