text_ux 0.0.1

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/dbus.py

@@ -0,0 +1,30 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+from waflib import Task,Errors
+from waflib.TaskGen import taskgen_method,before_method
+def add_dbus_file(self,filename,prefix,mode):
+	if not hasattr(self,'dbus_lst'):
+		self.dbus_lst=[]
+	if not'process_dbus'in self.meths:
+		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 Errors.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
+class dbus_binding_tool(Task.Task):
+	color='BLUE'
+	ext_out=['.h']
+	run_str='${DBUS_BINDING_TOOL} --prefix=${DBUS_BINDING_TOOL_PREFIX} --mode=${DBUS_BINDING_TOOL_MODE} --output=${TGT} ${SRC}'
+	shell=True
+def configure(conf):
+	dbus_binding_tool=conf.find_program('dbus-binding-tool',var='DBUS_BINDING_TOOL')
+
+taskgen_method(add_dbus_file)
+before_method('apply_core')(process_dbus)

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/dmd.py

@@ -0,0 +1,43 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import sys
+from waflib.Tools import ar,d
+from waflib.Configure import conf
+def find_dmd(conf):
+	conf.find_program(['dmd','ldc'],var='D')
+def common_flags_ldc(conf):
+	v=conf.env
+	v['DFLAGS']=['-d-version=Posix']
+	v['LINKFLAGS']=[]
+	v['DFLAGS_dshlib']=['-relocation-model=pic']
+def common_flags_dmd(conf):
+	v=conf.env
+	v['D_SRC_F']=['-c']
+	v['D_TGT_F']='-of%s'
+	v['D_LINKER']=v['D']
+	v['DLNK_SRC_F']=''
+	v['DLNK_TGT_F']='-of%s'
+	v['DINC_ST']='-I%s'
+	v['DSHLIB_MARKER']=v['DSTLIB_MARKER']=''
+	v['DSTLIB_ST']=v['DSHLIB_ST']='-L-l%s'
+	v['DSTLIBPATH_ST']=v['DLIBPATH_ST']='-L-L%s'
+	v['LINKFLAGS_dprogram']=['-quiet']
+	v['DFLAGS_dshlib']=['-fPIC']
+	v['LINKFLAGS_dshlib']=['-L-shared']
+	v['DHEADER_ext']='.di'
+	v.DFLAGS_d_with_header=['-H','-Hf']
+	v['D_HDR_F']='%s'
+def configure(conf):
+	conf.find_dmd()
+	conf.load('ar')
+	conf.load('d')
+	conf.common_flags_dmd()
+	conf.d_platform_flags()
+	if str(conf.env.D).find('ldc')>-1:
+		conf.common_flags_ldc()
+
+conf(find_dmd)
+conf(common_flags_ldc)
+conf(common_flags_dmd)

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/errcheck.py

@@ -0,0 +1,153 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+typos={'feature':'features','sources':'source','targets':'target','include':'includes','export_include':'export_includes','define':'defines','importpath':'includes','installpath':'install_path',}
+meths_typos=['__call__','program','shlib','stlib','objects']
+from waflib import Logs,Build,Node,Task,TaskGen,ConfigSet,Errors,Utils
+import waflib.Tools.ccroot
+def check_same_targets(self):
+	mp=Utils.defaultdict(list)
+	uids={}
+	def check_task(tsk):
+		if not isinstance(tsk,Task.Task):
+			return
+		for node in tsk.outputs:
+			mp[node].append(tsk)
+		try:
+			uids[tsk.uid()].append(tsk)
+		except:
+			uids[tsk.uid()]=[tsk]
+	for g in self.groups:
+		for tg in g:
+			try:
+				for tsk in tg.tasks:
+					check_task(tsk)
+			except AttributeError:
+				check_task(tg)
+	dupe=False
+	for(k,v)in mp.items():
+		if len(v)>1:
+			dupe=True
+			msg='* Node %r is created by more than once%s. The task generators are:'%(k,Logs.verbose==1 and" (full message on 'waf -v -v')"or"")
+			Logs.error(msg)
+			for x in v:
+				if Logs.verbose>1:
+					Logs.error('  %d. %r'%(1+v.index(x),x.generator))
+				else:
+					Logs.error('  %d. %r in %r'%(1+v.index(x),x.generator.name,getattr(x.generator,'path',None)))
+	if not dupe:
+		for(k,v)in uids.items():
+			if len(v)>1:
+				Logs.error('* Several tasks use the same identifier. Please check the information on\n   http://waf.googlecode.com/git/docs/apidocs/Task.html#waflib.Task.Task.uid')
+				for tsk in v:
+					Logs.error('  - object %r (%r) defined in %r'%(tsk.__class__.__name__,tsk,tsk.generator))
+def check_invalid_constraints(self):
+	feat=set([])
+	for x in list(TaskGen.feats.values()):
+		feat.union(set(x))
+	for(x,y)in TaskGen.task_gen.prec.items():
+		feat.add(x)
+		feat.union(set(y))
+	ext=set([])
+	for x in TaskGen.task_gen.mappings.values():
+		ext.add(x.__name__)
+	invalid=ext&feat
+	if invalid:
+		Logs.error('The methods %r have invalid annotations:  @extension <-> @feature/@before_method/@after_method'%list(invalid))
+	for cls in list(Task.classes.values()):
+		for x in('before','after'):
+			for y in Utils.to_list(getattr(cls,x,[])):
+				if not Task.classes.get(y,None):
+					Logs.error('Erroneous order constraint %r=%r on task class %r'%(x,y,cls.__name__))
+def replace(m):
+	oldcall=getattr(Build.BuildContext,m)
+	def call(self,*k,**kw):
+		ret=oldcall(self,*k,**kw)
+		for x in typos:
+			if x in kw:
+				err=True
+				Logs.error('Fix the typo %r -> %r on %r'%(x,typos[x],ret))
+		return ret
+	setattr(Build.BuildContext,m,call)
+def enhance_lib():
+	for m in meths_typos:
+		replace(m)
+	old_ant_glob=Node.Node.ant_glob
+	def ant_glob(self,*k,**kw):
+		if k:
+			lst=Utils.to_list(k[0])
+			for pat in lst:
+				if'..'in pat.split('/'):
+					Logs.error("In ant_glob pattern %r: '..' means 'two dots', not 'parent directory'"%k[0])
+		return old_ant_glob(self,*k,**kw)
+	Node.Node.ant_glob=ant_glob
+	old=Task.is_before
+	def is_before(t1,t2):
+		ret=old(t1,t2)
+		if ret and old(t2,t1):
+			Logs.error('Contradictory order constraints in classes %r %r'%(t1,t2))
+		return ret
+	Task.is_before=is_before
+	def check_err_features(self):
+		lst=self.to_list(self.features)
+		if'shlib'in lst:
+			Logs.error('feature shlib -> cshlib, dshlib or cxxshlib')
+		for x in('c','cxx','d','fc'):
+			if not x in lst and lst and lst[0]in[x+y for y in('program','shlib','stlib')]:
+				Logs.error('%r features is probably missing %r'%(self,x))
+	TaskGen.feature('*')(check_err_features)
+	def check_err_order(self):
+		if not hasattr(self,'rule'):
+			for x in('before','after','ext_in','ext_out'):
+				if hasattr(self,x):
+					Logs.warn('Erroneous order constraint %r on non-rule based task generator %r'%(x,self))
+		else:
+			for x in('before','after'):
+				for y in self.to_list(getattr(self,x,[])):
+					if not Task.classes.get(y,None):
+						Logs.error('Erroneous order constraint %s=%r on %r'%(x,y,self))
+	TaskGen.feature('*')(check_err_order)
+	def check_compile(self):
+		check_invalid_constraints(self)
+		try:
+			ret=self.orig_compile()
+		finally:
+			check_same_targets(self)
+		return ret
+	Build.BuildContext.orig_compile=Build.BuildContext.compile
+	Build.BuildContext.compile=check_compile
+	def use_rec(self,name,**kw):
+		try:
+			y=self.bld.get_tgen_by_name(name)
+		except Errors.WafError:
+			pass
+		else:
+			idx=self.bld.get_group_idx(self)
+			odx=self.bld.get_group_idx(y)
+			if odx>idx:
+				msg="Invalid 'use' across build groups:"
+				if Logs.verbose>1:
+					msg+='\n  target %r\n  uses:\n  %r'%(self,y)
+				else:
+					msg+=" %r uses %r (try 'waf -v -v' for the full error)"%(self.name,name)
+				raise Errors.WafError(msg)
+		self.orig_use_rec(name,**kw)
+	TaskGen.task_gen.orig_use_rec=TaskGen.task_gen.use_rec
+	TaskGen.task_gen.use_rec=use_rec
+	def getattri(self,name,default=None):
+		if name=='append'or name=='add':
+			raise Errors.WafError('env.append and env.add do not exist: use env.append_value/env.append_unique')
+		elif name=='prepend':
+			raise Errors.WafError('env.prepend does not exist: use env.prepend_value')
+		if name in self.__slots__:
+			return object.__getattr__(self,name,default)
+		else:
+			return self[name]
+	ConfigSet.ConfigSet.__getattr__=getattri
+def options(opt):
+	enhance_lib()
+def configure(conf):
+	pass

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/fc.py

@@ -0,0 +1,123 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import re
+from waflib import Utils,Task,TaskGen,Logs
+from waflib.Tools import ccroot,fc_config,fc_scan
+from waflib.TaskGen import feature,before_method,after_method,extension
+from waflib.Configure import conf
+ccroot.USELIB_VARS['fc']=set(['FCFLAGS','DEFINES','INCLUDES'])
+ccroot.USELIB_VARS['fcprogram_test']=ccroot.USELIB_VARS['fcprogram']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS'])
+ccroot.USELIB_VARS['fcshlib']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS'])
+ccroot.USELIB_VARS['fcstlib']=set(['ARFLAGS','LINKDEPS'])
+def dummy(self):
+	pass
+def fc_hook(self,node):
+	return self.create_compiled_task('fc',node)
+def modfile(conf,name):
+	return{'lower':name.lower()+'.mod','lower.MOD':name.upper()+'.MOD','UPPER.mod':name.upper()+'.mod','UPPER':name.upper()+'.MOD'}[conf.env.FC_MOD_CAPITALIZATION or'lower']
+def get_fortran_tasks(tsk):
+	bld=tsk.generator.bld
+	tasks=bld.get_tasks_group(bld.get_group_idx(tsk.generator))
+	return[x for x in tasks if isinstance(x,fc)and not getattr(x,'nomod',None)and not getattr(x,'mod_fortran_done',None)]
+class fc(Task.Task):
+	color='GREEN'
+	run_str='${FC} ${FCFLAGS} ${FCINCPATH_ST:INCPATHS} ${FCDEFINES_ST:DEFINES} ${_FCMODOUTFLAGS} ${FC_TGT_F}${TGT[0].abspath()} ${FC_SRC_F}${SRC[0].abspath()}'
+	vars=["FORTRANMODPATHFLAG"]
+	def scan(self):
+		tmp=fc_scan.fortran_parser(self.generator.includes_nodes)
+		tmp.task=self
+		tmp.start(self.inputs[0])
+		if Logs.verbose:
+			Logs.debug('deps: deps for %r: %r; unresolved %r'%(self.inputs,tmp.nodes,tmp.names))
+		return(tmp.nodes,tmp.names)
+	def runnable_status(self):
+		if getattr(self,'mod_fortran_done',None):
+			return super(fc,self).runnable_status()
+		bld=self.generator.bld
+		lst=get_fortran_tasks(self)
+		for tsk in lst:
+			tsk.mod_fortran_done=True
+		for tsk in lst:
+			ret=tsk.runnable_status()
+			if ret==Task.ASK_LATER:
+				for x in lst:
+					x.mod_fortran_done=None
+				return Task.ASK_LATER
+		ins=Utils.defaultdict(set)
+		outs=Utils.defaultdict(set)
+		for tsk in lst:
+			key=tsk.uid()
+			for x in bld.raw_deps[key]:
+				if x.startswith('MOD@'):
+					name=bld.modfile(x.replace('MOD@',''))
+					node=bld.srcnode.find_or_declare(name)
+					tsk.set_outputs(node)
+					outs[id(node)].add(tsk)
+		for tsk in lst:
+			key=tsk.uid()
+			for x in bld.raw_deps[key]:
+				if x.startswith('USE@'):
+					name=bld.modfile(x.replace('USE@',''))
+					node=bld.srcnode.find_resource(name)
+					if node and node not in tsk.outputs:
+						if not node in bld.node_deps[key]:
+							bld.node_deps[key].append(node)
+						ins[id(node)].add(tsk)
+		for k in ins.keys():
+			for a in ins[k]:
+				a.run_after.update(outs[k])
+				tmp=[]
+				for t in outs[k]:
+					tmp.extend(t.outputs)
+				a.dep_nodes.extend(tmp)
+				try:
+					a.dep_nodes.sort(key=lambda x:x.abspath())
+				except:
+					a.dep_nodes.sort(lambda x,y:cmp(x.abspath(),y.abspath()))
+		for tsk in lst:
+			try:
+				delattr(tsk,'cache_sig')
+			except AttributeError:
+				pass
+		return super(fc,self).runnable_status()
+class fcprogram(ccroot.link_task):
+	color='YELLOW'
+	run_str='${FC} ${LINKFLAGS} ${FCLNK_SRC_F}${SRC} ${FCLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FCSTLIB_MARKER} ${FCSTLIBPATH_ST:STLIBPATH} ${FCSTLIB_ST:STLIB} ${FCSHLIB_MARKER} ${FCLIBPATH_ST:LIBPATH} ${FCLIB_ST:LIB}'
+	inst_to='${BINDIR}'
+	chmod=Utils.O755
+class fcshlib(fcprogram):
+	inst_to='${LIBDIR}'
+class fcprogram_test(fcprogram):
+	def can_retrieve_cache(self):
+		return False
+	def runnable_status(self):
+		ret=super(fcprogram_test,self).runnable_status()
+		if ret==Task.SKIP_ME:
+			ret=Task.RUN_ME
+		return ret
+	def exec_command(self,cmd,**kw):
+		bld=self.generator.bld
+		kw['shell']=isinstance(cmd,str)
+		kw['stdout']=kw['stderr']=Utils.subprocess.PIPE
+		kw['cwd']=bld.variant_dir
+		bld.out=bld.err=''
+		bld.to_log('command: %s\n'%cmd)
+		kw['output']=0
+		try:
+			(bld.out,bld.err)=bld.cmd_and_log(cmd,**kw)
+		except Exception ,e:
+			return-1
+		if bld.out:
+			bld.to_log("out: %s\n"%bld.out)
+		if bld.err:
+			bld.to_log("err: %s\n"%bld.err)
+class fcstlib(ccroot.stlink_task):
+	pass
+
+feature('fcprogram','fcshlib','fcstlib','fcprogram_test')(dummy)
+extension('.f','.f90','.F','.F90','.for','.FOR')(fc_hook)
+conf(modfile)

data/vendor/ux-trie/ux-0.1.9/.waf-1.6.8-3e3391c5f23fbabad81e6d17c63a1b1e/waflib/Tools/fc_config.py

@@ -0,0 +1,271 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
+
+import re,shutil,os,sys,string,shlex
+from waflib.Configure import conf
+from waflib.TaskGen import feature,after_method,before_method
+from waflib import Build,Utils
+FC_FRAGMENT='        program main\n        end     program main\n'
+FC_FRAGMENT2='        PROGRAM MAIN\n        END\n'
+def fc_flags(conf):
+	v=conf.env
+	v['FC_SRC_F']=[]
+	v['FC_TGT_F']=['-c','-o']
+	v['FCINCPATH_ST']='-I%s'
+	v['FCDEFINES_ST']='-D%s'
+	if not v['LINK_FC']:v['LINK_FC']=v['FC']
+	v['FCLNK_SRC_F']=[]
+	v['FCLNK_TGT_F']=['-o']
+	v['FCFLAGS_fcshlib']=['-fpic']
+	v['LINKFLAGS_fcshlib']=['-shared']
+	v['fcshlib_PATTERN']='lib%s.so'
+	v['fcstlib_PATTERN']='lib%s.a'
+	v['FCLIB_ST']='-l%s'
+	v['FCLIBPATH_ST']='-L%s'
+	v['FCSTLIB_ST']='-l%s'
+	v['FCSTLIBPATH_ST']='-L%s'
+	v['FCSTLIB_MARKER']='-Wl,-Bstatic'
+	v['FCSHLIB_MARKER']='-Wl,-Bdynamic'
+	v['SONAME_ST']='-Wl,-h,%s'
+def check_fortran(self,*k,**kw):
+	self.check_cc(fragment=FC_FRAGMENT,compile_filename='test.f',features='fc fcprogram',msg='Compiling a simple fortran app')
+def check_fc(self,*k,**kw):
+	kw['compiler']='fc'
+	if not'compile_mode'in kw:
+		kw['compile_mode']='fc'
+	if not'type'in kw:
+		kw['type']='fcprogram'
+	if not'compile_filename'in kw:
+		kw['compile_filename']='test.f90'
+	if not'code'in kw:
+		kw['code']=FC_FRAGMENT
+	return self.check(*k,**kw)
+def fortran_modifier_darwin(conf):
+	v=conf.env
+	v['FCFLAGS_fcshlib']=['-fPIC','-compatibility_version','1','-current_version','1']
+	v['LINKFLAGS_fcshlib']=['-dynamiclib']
+	v['fcshlib_PATTERN']='lib%s.dylib'
+	v['FRAMEWORKPATH_ST']='-F%s'
+	v['FRAMEWORK_ST']='-framework %s'
+	v['LINKFLAGS_fcstlib']=[]
+	v['FCSHLIB_MARKER']=''
+	v['FCSTLIB_MARKER']=''
+	v['SONAME_ST']=''
+def fortran_modifier_win32(conf):
+	v=conf.env
+	v['fcprogram_PATTERN']=v['fcprogram_test_PATTERN']='%s.exe'
+	v['fcshlib_PATTERN']='%s.dll'
+	v['implib_PATTERN']='lib%s.dll.a'
+	v['IMPLIB_ST']='-Wl,--out-implib,%s'
+	v['FCFLAGS_fcshlib']=[]
+	v.append_value('FCFLAGS_fcshlib',['-DDLL_EXPORT'])
+	v.append_value('LINKFLAGS',['-Wl,--enable-auto-import'])
+def fortran_modifier_cygwin(conf):
+	fortran_modifier_win32(conf)
+	v=conf.env
+	v['fcshlib_PATTERN']='cyg%s.dll'
+	v.append_value('LINKFLAGS_fcshlib',['-Wl,--enable-auto-image-base'])
+	v['FCFLAGS_fcshlib']=[]
+def check_fortran_dummy_main(self,*k,**kw):
+	if not self.env.CC:
+		self.fatal('A c compiler is required for check_fortran_dummy_main')
+	lst=['MAIN__','__MAIN','_MAIN','MAIN_','MAIN']
+	lst.extend([m.lower()for m in lst])
+	lst.append('')
+	self.start_msg('Detecting whether we need a dummy main')
+	for main in lst:
+		kw['fortran_main']=main
+		try:
+			self.check_cc(fragment='int %s() { return 0; }\n'%(main or'test'),features='c fcprogram',mandatory=True)
+			if not main:
+				self.env.FC_MAIN=-1
+				self.end_msg('no')
+			else:
+				self.env.FC_MAIN=main
+				self.end_msg('yes %s'%main)
+			break
+		except self.errors.ConfigurationError:
+			pass
+	else:
+		self.end_msg('not found')
+		self.fatal('could not detect whether fortran requires a dummy main, see the config.log')
+GCC_DRIVER_LINE=re.compile('^Driving:')
+POSIX_STATIC_EXT=re.compile('\S+\.a')
+POSIX_LIB_FLAGS=re.compile('-l\S+')
+def is_link_verbose(self,txt):
+	assert isinstance(txt,str)
+	for line in txt.splitlines():
+		if not GCC_DRIVER_LINE.search(line):
+			if POSIX_STATIC_EXT.search(line)or POSIX_LIB_FLAGS.search(line):
+				return True
+	return False
+def check_fortran_verbose_flag(self,*k,**kw):
+	self.start_msg('fortran link verbose flag')
+	for x in['-v','--verbose','-verbose','-V']:
+		try:
+			self.check_cc(features='fc fcprogram_test',fragment=FC_FRAGMENT2,compile_filename='test.f',linkflags=[x],mandatory=True)
+		except self.errors.ConfigurationError:
+			pass
+		else:
+			if self.is_link_verbose(self.test_bld.err)or self.is_link_verbose(self.test_bld.out):
+				self.end_msg(x)
+				break
+	else:
+		self.end_msg('failure')
+		self.fatal('Could not obtain the fortran link verbose flag (see config.log)')
+	self.env.FC_VERBOSE_FLAG=x
+	return x
+LINKFLAGS_IGNORED=[r'-lang*',r'-lcrt[a-zA-Z0-9\.]*\.o',r'-lc$',r'-lSystem',r'-libmil',r'-LIST:*',r'-LNO:*']
+if os.name=='nt':
+	LINKFLAGS_IGNORED.extend([r'-lfrt*',r'-luser32',r'-lkernel32',r'-ladvapi32',r'-lmsvcrt',r'-lshell32',r'-lmingw',r'-lmoldname'])
+else:
+	LINKFLAGS_IGNORED.append(r'-lgcc*')
+RLINKFLAGS_IGNORED=[re.compile(f)for f in LINKFLAGS_IGNORED]
+def _match_ignore(line):
+	for i in RLINKFLAGS_IGNORED:
+		if i.match(line):
+			return True
+	return False
+def parse_fortran_link(lines):
+	final_flags=[]
+	for line in lines:
+		if not GCC_DRIVER_LINE.match(line):
+			_parse_flink_line(line,final_flags)
+	return final_flags
+SPACE_OPTS=re.compile('^-[LRuYz]$')
+NOSPACE_OPTS=re.compile('^-[RL]')
+def _parse_flink_line(line,final_flags):
+	lexer=shlex.shlex(line,posix=True)
+	lexer.whitespace_split=True
+	t=lexer.get_token()
+	tmp_flags=[]
+	while t:
+		def parse(token):
+			if _match_ignore(token):
+				pass
+			elif token.startswith('-lkernel32')and sys.platform=='cygwin':
+				tmp_flags.append(token)
+			elif SPACE_OPTS.match(token):
+				t=lexer.get_token()
+				if t.startswith('P,'):
+					t=t[2:]
+				for opt in t.split(os.pathsep):
+					tmp_flags.append('-L%s'%opt)
+			elif NOSPACE_OPTS.match(token):
+				tmp_flags.append(token)
+			elif POSIX_LIB_FLAGS.match(token):
+				tmp_flags.append(token)
+			else:
+				pass
+			t=lexer.get_token()
+			return t
+		t=parse(t)
+	final_flags.extend(tmp_flags)
+	return final_flags
+def check_fortran_clib(self,autoadd=True,*k,**kw):
+	if not self.env.FC_VERBOSE_FLAG:
+		self.fatal('env.FC_VERBOSE_FLAG is not set: execute check_fortran_verbose_flag?')
+	self.start_msg('Getting fortran runtime link flags')
+	try:
+		self.check_cc(fragment=FC_FRAGMENT2,compile_filename='test.f',features='fc fcprogram_test',linkflags=[self.env.FC_VERBOSE_FLAG])
+	except:
+		self.end_msg(False)
+		if kw.get('mandatory',True):
+			conf.fatal('Could not find the c library flags')
+	else:
+		out=self.test_bld.err
+		flags=parse_fortran_link(out.splitlines())
+		self.end_msg('ok (%s)'%' '.join(flags))
+		self.env.LINKFLAGS_CLIB=flags
+		return flags
+	return[]
+def getoutput(conf,cmd,stdin=False):
+	try:
+		if stdin:
+			stdin=Utils.subprocess.PIPE
+		else:
+			stdin=None
+		p=Utils.subprocess.Popen(cmd,stdin=stdin,stdout=Utils.subprocess.PIPE,stderr=Utils.subprocess.PIPE)
+		if stdin:
+			p.stdin.write('\n')
+		stdout,stderr=p.communicate()
+	except:
+		conf.fatal('could not determine the compiler version %r'%cmd)
+	else:
+		if not isinstance(stdout,str):
+			stdout=stdout.decode(sys.stdout.encoding)
+		if not isinstance(stderr,str):
+			stderr=stderr.decode(sys.stdout.encoding)
+		return stdout,stderr
+ROUTINES_CODE="""\
+      subroutine foobar()
+      return
+      end
+      subroutine foo_bar()
+      return
+      end
+"""
+MAIN_CODE="""
+void %(dummy_func_nounder)s(void);
+void %(dummy_func_under)s(void);
+int %(main_func_name)s() {
+  %(dummy_func_nounder)s();
+  %(dummy_func_under)s();
+  return 0;
+}
+"""
+def link_main_routines_tg_method(self):
+	def write_test_file(task):
+		task.outputs[0].write(task.generator.code)
+	bld=self.bld
+	bld(rule=write_test_file,target='main.c',code=MAIN_CODE%self.__dict__)
+	bld(rule=write_test_file,target='test.f',code=ROUTINES_CODE)
+	bld(features='fc fcstlib',source='test.f',target='test')
+	bld(features='c fcprogram',source='main.c',target='app',use='test')
+def mangling_schemes():
+	for u in['_','']:
+		for du in['','_']:
+			for c in["lower","upper"]:
+				yield(u,du,c)
+def mangle_name(u,du,c,name):
+	return getattr(name,c)()+u+(name.find('_')!=-1 and du or'')
+def check_fortran_mangling(self,*k,**kw):
+	if not self.env.CC:
+		self.fatal('A c compiler is required for link_main_routines')
+	if not self.env.FC:
+		self.fatal('A fortran compiler is required for link_main_routines')
+	if not self.env.FC_MAIN:
+		self.fatal('Checking for mangling requires self.env.FC_MAIN (execute "check_fortran_dummy_main" first?)')
+	self.start_msg('Getting fortran mangling scheme')
+	for(u,du,c)in mangling_schemes():
+		try:
+			self.check_cc(compile_filename=[],features='link_main_routines_func',msg='nomsg',errmsg='nomsg',mandatory=True,dummy_func_nounder=mangle_name(u,du,c,"foobar"),dummy_func_under=mangle_name(u,du,c,"foo_bar"),main_func_name=self.env.FC_MAIN)
+		except self.errors.ConfigurationError:
+			pass
+		else:
+			self.end_msg("ok ('%s', '%s', '%s-case')"%(u,du,c))
+			self.env.FORTRAN_MANGLING=(u,du,c)
+			break
+	else:
+		self.end_msg(False)
+		self.fatal('mangler not found')
+	return(u,du,c)
+def set_lib_pat(self):
+	self.env['fcshlib_PATTERN']=self.env['pyext_PATTERN']
+
+conf(fc_flags)
+conf(check_fortran)
+conf(check_fc)
+conf(fortran_modifier_darwin)
+conf(fortran_modifier_win32)
+conf(fortran_modifier_cygwin)
+conf(check_fortran_dummy_main)
+conf(is_link_verbose)
+conf(check_fortran_verbose_flag)
+conf(check_fortran_clib)
+feature('link_main_routines_func')(link_main_routines_tg_method)
+before_method('process_source')(link_main_routines_tg_method)
+conf(check_fortran_mangling)
+feature('pyext')(set_lib_pat)
+before_method('propagate_uselib_vars','apply_link')(set_lib_pat)