text_ux 0.0.1

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

@@ -0,0 +1,104 @@
+#! /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 os
+from waflib import Task,Options,Utils
+from waflib.TaskGen import before_method,feature,after_method,Task,extension
+from waflib.Configure import conf
+def init_rubyext(self):
+	self.install_path='${ARCHDIR_RUBY}'
+	self.uselib=self.to_list(getattr(self,'uselib',''))
+	if not'RUBY'in self.uselib:
+		self.uselib.append('RUBY')
+	if not'RUBYEXT'in self.uselib:
+		self.uselib.append('RUBYEXT')
+def apply_ruby_so_name(self):
+	self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['rubyext_PATTERN']
+def check_ruby_version(self,minver=()):
+	if Options.options.rubybinary:
+		self.env.RUBY=Options.options.rubybinary
+	else:
+		self.find_program('ruby',var='RUBY')
+	ruby=self.env.RUBY
+	try:
+		version=self.cmd_and_log([ruby,'-e','puts defined?(VERSION) ? VERSION : RUBY_VERSION']).strip()
+	except:
+		self.fatal('could not determine ruby version')
+	self.env.RUBY_VERSION=version
+	try:
+		ver=tuple(map(int,version.split(".")))
+	except:
+		self.fatal('unsupported ruby version %r'%version)
+	cver=''
+	if minver:
+		if ver<minver:
+			self.fatal('ruby is too old %r'%ver)
+		cver='.'.join([str(x)for x in minver])
+	else:
+		cver=ver
+	self.msg('Checking for ruby version %s'%str(minver or''),cver)
+def check_ruby_ext_devel(self):
+	if not self.env.RUBY:
+		self.fatal('ruby detection is required first')
+	if not self.env.CC_NAME and not self.env.CXX_NAME:
+		self.fatal('load a c/c++ compiler first')
+	version=tuple(map(int,self.env.RUBY_VERSION.split(".")))
+	def read_out(cmd):
+		return Utils.to_list(self.cmd_and_log([self.env.RUBY,'-rrbconfig','-e',cmd]))
+	def read_config(key):
+		return read_out('puts Config::CONFIG[%r]'%key)
+	ruby=self.env['RUBY']
+	archdir=read_config('archdir')
+	cpppath=archdir
+	if version>=(1,9,0):
+		ruby_hdrdir=read_config('rubyhdrdir')
+		cpppath+=ruby_hdrdir
+		cpppath+=[os.path.join(ruby_hdrdir[0],read_config('arch')[0])]
+	self.check(header_name='ruby.h',includes=cpppath,errmsg='could not find ruby header file')
+	self.env.LIBPATH_RUBYEXT=read_config('libdir')
+	self.env.LIBPATH_RUBYEXT+=archdir
+	self.env.INCLUDES_RUBYEXT=cpppath
+	self.env.CFLAGS_RUBYEXT=read_config('CCDLFLAGS')
+	self.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:]
+	self.env.LINKFLAGS_RUBYEXT=flags
+	self.env.LINKFLAGS_RUBYEXT+=read_config('LIBS')
+	self.env.LINKFLAGS_RUBYEXT+=read_config('LIBRUBYARG_SHARED')
+	if Options.options.rubyarchdir:
+		self.env.ARCHDIR_RUBY=Options.options.rubyarchdir
+	else:
+		self.env.ARCHDIR_RUBY=read_config('sitearchdir')[0]
+	if Options.options.rubylibdir:
+		self.env.LIBDIR_RUBY=Options.options.rubylibdir
+	else:
+		self.env.LIBDIR_RUBY=read_config('sitelibdir')[0]
+def check_ruby_module(self,module_name):
+	self.start_msg('Ruby module %s'%module_name)
+	try:
+		self.cmd_and_log([self.env['RUBY'],'-e','require \'%s\';puts 1'%module_name])
+	except:
+		self.end_msg(False)
+		self.fatal('Could not find the ruby module %r'%module_name)
+	self.end_msg(True)
+def process(self,node):
+	tsk=self.create_task('run_ruby',node)
+class run_ruby(Task.Task):
+	run_str='${RUBY} ${RBFLAGS} -I ${SRC[0].parent.abspath()} ${SRC}'
+def 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')
+
+feature('rubyext')(init_rubyext)
+before_method('apply_incpaths','apply_lib_vars','apply_bundle','apply_link')(init_rubyext)
+feature('rubyext')(apply_ruby_so_name)
+before_method('apply_link','propagate_uselib')(apply_ruby_so_name)
+conf(check_ruby_version)
+conf(check_ruby_ext_devel)
+conf(check_ruby_module)
+extension('.rb')(process)

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

@@ -0,0 +1,54 @@
+#! /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 os
+from waflib import Utils
+from waflib.Tools import ccroot,ar
+from waflib.Configure import conf
+def find_scc(conf):
+	v=conf.env
+	cc=None
+	if v['CC']:cc=v['CC']
+	elif'CC'in conf.environ:cc=conf.environ['CC']
+	if not cc:cc=conf.find_program('cc',var='CC')
+	if not cc:conf.fatal('Could not find a Sun C compiler')
+	cc=conf.cmd_to_list(cc)
+	try:
+		conf.cmd_and_log(cc+['-flags'])
+	except:
+		conf.fatal('%r is not a Sun compiler'%cc)
+	v['CC']=cc
+	v['CC_NAME']='sun'
+def scc_common_flags(conf):
+	v=conf.env
+	v['CC_SRC_F']=[]
+	v['CC_TGT_F']=['-c','-o']
+	if not v['LINK_CC']:v['LINK_CC']=v['CC']
+	v['CCLNK_SRC_F']=''
+	v['CCLNK_TGT_F']=['-o']
+	v['CPPPATH_ST']='-I%s'
+	v['DEFINES_ST']='-D%s'
+	v['LIB_ST']='-l%s'
+	v['LIBPATH_ST']='-L%s'
+	v['STLIB_ST']='-l%s'
+	v['STLIBPATH_ST']='-L%s'
+	v['SONAME_ST']='-Wl,-h,%s'
+	v['SHLIB_MARKER']='-Bdynamic'
+	v['STLIB_MARKER']='-Bstatic'
+	v['cprogram_PATTERN']='%s'
+	v['CFLAGS_cshlib']=['-Kpic','-DPIC']
+	v['LINKFLAGS_cshlib']=['-G']
+	v['cshlib_PATTERN']='lib%s.so'
+	v['LINKFLAGS_cstlib']=['-Bstatic']
+	v['cstlib_PATTERN']='lib%s.a'
+def configure(conf):
+	conf.find_scc()
+	conf.find_ar()
+	conf.scc_common_flags()
+	conf.cc_load_tools()
+	conf.cc_add_flags()
+	conf.link_add_flags()
+
+conf(find_scc)
+conf(scc_common_flags)

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

@@ -0,0 +1,55 @@
+#! /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 os
+from waflib import Utils
+from waflib.Tools import ccroot,ar
+from waflib.Configure import conf
+def find_sxx(conf):
+	v=conf.env
+	cc=None
+	if v['CXX']:cc=v['CXX']
+	elif'CXX'in conf.environ:cc=conf.environ['CXX']
+	if not cc:cc=conf.find_program('CC',var='CXX')
+	if not cc:cc=conf.find_program('c++',var='CXX')
+	if not cc:conf.fatal('Could not find a Sun C++ compiler')
+	cc=conf.cmd_to_list(cc)
+	try:
+		conf.cmd_and_log(cc+['-flags'])
+	except:
+		conf.fatal('%r is not a Sun compiler'%cc)
+	v['CXX']=cc
+	v['CXX_NAME']='sun'
+def sxx_common_flags(conf):
+	v=conf.env
+	v['CXX_SRC_F']=[]
+	v['CXX_TGT_F']=['-c','-o']
+	if not v['LINK_CXX']:v['LINK_CXX']=v['CXX']
+	v['CXXLNK_SRC_F']=[]
+	v['CXXLNK_TGT_F']=['-o']
+	v['CPPPATH_ST']='-I%s'
+	v['DEFINES_ST']='-D%s'
+	v['LIB_ST']='-l%s'
+	v['LIBPATH_ST']='-L%s'
+	v['STLIB_ST']='-l%s'
+	v['STLIBPATH_ST']='-L%s'
+	v['SONAME_ST']='-Wl,-h,%s'
+	v['SHLIB_MARKER']='-Bdynamic'
+	v['STLIB_MARKER']='-Bstatic'
+	v['cxxprogram_PATTERN']='%s'
+	v['CXXFLAGS_cxxshlib']=['-Kpic','-DPIC']
+	v['LINKFLAGS_cxxshlib']=['-G']
+	v['cxxshlib_PATTERN']='lib%s.so'
+	v['LINKFLAGS_cxxstlib']=['-Bstatic']
+	v['cxxstlib_PATTERN']='lib%s.a'
+def configure(conf):
+	conf.find_sxx()
+	conf.find_ar()
+	conf.sxx_common_flags()
+	conf.cxx_load_tools()
+	conf.cxx_add_flags()
+	conf.link_add_flags()
+
+conf(find_sxx)
+conf(sxx_common_flags)

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

@@ -0,0 +1,222 @@
+#! /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 os,re
+from waflib import Utils,Task,Runner,Build,Errors
+from waflib.TaskGen import feature,before_method
+from waflib.Logs import error,warn,debug
+re_bibunit=re.compile(r'\\(?P<type>putbib)\[(?P<file>[^\[\]]*)\]',re.M)
+def bibunitscan(self):
+	node=self.inputs[0]
+	env=self.env
+	nodes=[]
+	if not node:return nodes
+	code=Utils.readf(node.abspath())
+	for match in re_bibunit.finditer(code):
+		path=match.group('file')
+		if path:
+			for k in['','.bib']:
+				debug('tex: trying %s%s'%(path,k))
+				fi=node.parent.find_resource(path+k)
+				if fi:
+					nodes.append(fi)
+			else:
+				debug('tex: could not find %s'%path)
+	debug("tex: found the following bibunit files: %s"%nodes)
+	return nodes
+exts_deps_tex=['','.ltx','.tex','.bib','.pdf','.png','.eps','.ps']
+re_tex=re.compile(r'\\(?P<type>include|bibliography|putbib|includegraphics|input|import|bringin|lstinputlisting)(\[[^\[\]]*\])?{(?P<file>[^{}]*)}',re.M)
+g_bibtex_re=re.compile('bibdata',re.M)
+class tex(Task.Task):
+	bibtex_fun,_=Task.compile_fun('${BIBTEX} ${BIBTEXFLAGS} ${SRCFILE}',shell=False)
+	bibtex_fun.__doc__="""
+	Execute the program **bibtex**
+	"""
+	makeindex_fun,_=Task.compile_fun('${MAKEINDEX} ${MAKEINDEXFLAGS} ${SRCFILE}',shell=False)
+	makeindex_fun.__doc__="""
+	Execute the program **makeindex**
+	"""
+	def scan(self):
+		node=self.inputs[0]
+		env=self.env
+		nodes=[]
+		names=[]
+		seen=[]
+		if not node:return(nodes,names)
+		def parse_node(node):
+			if node in seen:
+				return
+			seen.append(node)
+			code=node.read()
+			global re_tex
+			for match in re_tex.finditer(code):
+				for path in match.group('file').split(','):
+					if path:
+						add_name=True
+						found=None
+						for k in exts_deps_tex:
+							debug('tex: trying %s%s'%(path,k))
+							found=node.parent.find_resource(path+k)
+							if found and not found in self.outputs:
+								nodes.append(found)
+								add_name=False
+								if found.name.endswith('.tex')or found.name.endswith('.ltx'):
+									parse_node(found)
+						if add_name:
+							names.append(path)
+		parse_node(node)
+		for x in nodes:
+			x.parent.get_bld().mkdir()
+		debug("tex: found the following : %s and names %s"%(nodes,names))
+		return(nodes,names)
+	def check_status(self,msg,retcode):
+		if retcode!=0:
+			raise Errors.WafError("%r command exit status %r"%(msg,retcode))
+	def bibfile(self):
+		try:
+			ct=self.aux_node.read()
+		except(OSError,IOError):
+			error('error bibtex scan')
+		else:
+			fo=g_bibtex_re.findall(ct)
+			if fo:
+				warn('calling bibtex')
+				self.env.env={}
+				self.env.env.update(os.environ)
+				self.env.env.update({'BIBINPUTS':self.TEXINPUTS,'BSTINPUTS':self.TEXINPUTS})
+				self.env.SRCFILE=self.aux_node.name[:-4]
+				self.check_status('error when calling bibtex',self.bibtex_fun())
+	def bibunits(self):
+		try:
+			bibunits=bibunitscan(self)
+		except FSError:
+			error('error bibunitscan')
+		else:
+			if bibunits:
+				fn=['bu'+str(i)for i in xrange(1,len(bibunits)+1)]
+				if fn:
+					warn('calling bibtex on bibunits')
+				for f in fn:
+					self.env.env={'BIBINPUTS':self.TEXINPUTS,'BSTINPUTS':self.TEXINPUTS}
+					self.env.SRCFILE=f
+					self.check_status('error when calling bibtex',self.bibtex_fun())
+	def makeindex(self):
+		try:
+			idx_path=self.idx_node.abspath()
+			os.stat(idx_path)
+		except OSError:
+			warn('index file %s absent, not calling makeindex'%idx_path)
+		else:
+			warn('calling makeindex')
+			self.env.SRCFILE=self.idx_node.name
+			self.env.env={}
+			self.check_status('error when calling makeindex %s'%idx_path,self.makeindex_fun())
+	def run(self):
+		env=self.env
+		bld=self.generator.bld
+		if not env['PROMPT_LATEX']:
+			env.append_value('LATEXFLAGS','-interaction=batchmode')
+			env.append_value('PDFLATEXFLAGS','-interaction=batchmode')
+			env.append_value('XELATEXFLAGS','-interaction=batchmode')
+		fun=self.texfun
+		node=self.inputs[0]
+		srcfile=node.abspath()
+		texinputs=self.env.TEXINPUTS or''
+		self.TEXINPUTS=node.parent.get_bld().abspath()+os.pathsep+node.parent.get_src().abspath()+os.pathsep+texinputs+os.pathsep
+		self.aux_node=node.change_ext('.aux')
+		self.idx_node=node.change_ext('.idx')
+		self.cwd=self.inputs[0].parent.get_bld().abspath()
+		warn('first pass on %s'%self.__class__.__name__)
+		self.env.env={}
+		self.env.env.update(os.environ)
+		self.env.env.update({'TEXINPUTS':self.TEXINPUTS})
+		self.env.SRCFILE=srcfile
+		self.check_status('error when calling latex',fun())
+		self.bibfile()
+		self.bibunits()
+		self.makeindex()
+		hash=''
+		for i in range(10):
+			prev_hash=hash
+			try:
+				hash=Utils.h_file(self.aux_node.abspath())
+			except(OSError,IOError):
+				error('could not read aux.h -> %s'%self.aux_node.abspath())
+				pass
+			if hash and hash==prev_hash:
+				break
+			warn('calling %s'%self.__class__.__name__)
+			self.env.env={}
+			self.env.env.update(os.environ)
+			self.env.env.update({'TEXINPUTS':self.TEXINPUTS})
+			self.env.SRCFILE=srcfile
+			self.check_status('error when calling %s'%self.__class__.__name__,fun())
+class latex(tex):
+	texfun,vars=Task.compile_fun('${LATEX} ${LATEXFLAGS} ${SRCFILE}',shell=False)
+class pdflatex(tex):
+	texfun,vars=Task.compile_fun('${PDFLATEX} ${PDFLATEXFLAGS} ${SRCFILE}',shell=False)
+class xelatex(tex):
+	texfun,vars=Task.compile_fun('${XELATEX} ${XELATEXFLAGS} ${SRCFILE}',shell=False)
+class dvips(Task.Task):
+	run_str='${DVIPS} ${DVIPSFLAGS} ${SRC} -o ${TGT}'
+	color='BLUE'
+	after=['latex','pdflatex','xelatex']
+class dvipdf(Task.Task):
+	run_str='${DVIPDF} ${DVIPDFFLAGS} ${SRC} ${TGT}'
+	color='BLUE'
+	after=['latex','pdflatex','xelatex']
+class pdf2ps(Task.Task):
+	run_str='${PDF2PS} ${PDF2PSFLAGS} ${SRC} ${TGT}'
+	color='BLUE'
+	after=['latex','pdflatex','xelatex']
+def apply_tex(self):
+	if not getattr(self,'type',None)in['latex','pdflatex','xelatex']:
+		self.type='pdflatex'
+	tree=self.bld
+	outs=Utils.to_list(getattr(self,'outs',[]))
+	self.env['PROMPT_LATEX']=getattr(self,'prompt',1)
+	deps_lst=[]
+	if getattr(self,'deps',None):
+		deps=self.to_list(self.deps)
+		for filename in deps:
+			n=self.path.find_resource(filename)
+			if not n in deps_lst:deps_lst.append(n)
+	for node in self.to_nodes(self.source):
+		if self.type=='latex':
+			task=self.create_task('latex',node,node.change_ext('.dvi'))
+		elif self.type=='pdflatex':
+			task=self.create_task('pdflatex',node,node.change_ext('.pdf'))
+		elif self.type=='xelatex':
+			task=self.create_task('xelatex',node,node.change_ext('.pdf'))
+		task.env=self.env
+		if deps_lst:
+			try:
+				lst=tree.node_deps[task.uid()]
+				for n in deps_lst:
+					if not n in lst:
+						lst.append(n)
+			except KeyError:
+				tree.node_deps[task.uid()]=deps_lst
+		if self.type=='latex':
+			if'ps'in outs:
+				tsk=self.create_task('dvips',task.outputs,node.change_ext('.ps'))
+				tsk.env.env={'TEXINPUTS':node.parent.abspath()+os.pathsep+self.path.abspath()+os.pathsep+self.path.get_bld().abspath()}
+			if'pdf'in outs:
+				tsk=self.create_task('dvipdf',task.outputs,node.change_ext('.pdf'))
+				tsk.env.env={'TEXINPUTS':node.parent.abspath()+os.pathsep+self.path.abspath()+os.pathsep+self.path.get_bld().abspath()}
+		elif self.type=='pdflatex':
+			if'ps'in outs:
+				self.create_task('pdf2ps',task.outputs,node.change_ext('.ps'))
+	self.source=[]
+def configure(self):
+	v=self.env
+	for p in'tex latex pdflatex xelatex bibtex dvips dvipdf ps2pdf makeindex pdf2ps'.split():
+		try:
+			self.find_program(p,var=p.upper())
+		except self.errors.ConfigurationError:
+			pass
+	v['DVIPSFLAGS']='-Ppdf'
+
+feature('tex')(apply_tex)
+before_method('process_source')(apply_tex)

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

@@ -0,0 +1,215 @@
+#! /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 os.path,shutil,re
+from waflib import Context,Task,Utils,Logs,Options,Errors
+from waflib.TaskGen import extension
+from waflib.Configure import conf
+class valac(Task.Task):
+	vars=["VALAC","VALAC_VERSION","VALAFLAGS"]
+	ext_out=['.h']
+	def run(self):
+		env=self.env
+		cmd=[env['VALAC'],'-C','--quiet']
+		cmd.extend(Utils.to_list(env['VALAFLAGS']))
+		if self.threading:
+			cmd.append('--thread')
+		if self.profile:
+			cmd.append('--profile=%s'%self.profile)
+		if self.target_glib:
+			cmd.append('--target-glib=%s'%self.target_glib)
+		if self.is_lib:
+			cmd.append('--library='+self.target)
+			for x in self.outputs:
+				if x.name.endswith('.h'):
+					cmd.append('--header='+x.name)
+			if self.gir:
+				cmd.append('--gir=%s.gir'%self.gir)
+		for vapi_dir in self.vapi_dirs:
+			cmd.append('--vapidir=%s'%vapi_dir)
+		for package in self.packages:
+			cmd.append('--pkg=%s'%package)
+		for package in self.packages_private:
+			cmd.append('--pkg=%s'%package)
+		for define in self.vala_defines:
+			cmd.append('--define=%s'%define)
+		cmd.extend([a.abspath()for a in self.inputs])
+		ret=self.exec_command(cmd,cwd=self.outputs[0].parent.abspath())
+		if ret:
+			return ret
+		for x in self.outputs:
+			if id(x.parent)!=id(self.outputs[0].parent):
+				shutil.move(self.outputs[0].parent.abspath()+os.sep+x.name,x.abspath())
+		if self.packages and getattr(self,'deps_node',None):
+			self.deps_node.write('\n'.join(self.packages))
+		return ret
+def vala_file(self,node):
+	valatask=getattr(self,"valatask",None)
+	if not valatask:
+		def _get_api_version():
+			api_version='1.0'
+			if hasattr(Context.g_module,'API_VERSION'):
+				version=Context.g_module.API_VERSION.split(".")
+				if version[0]=="0":
+					api_version="0."+version[1]
+				else:
+					api_version=version[0]+".0"
+			return api_version
+		valatask=self.create_task('valac')
+		self.valatask=valatask
+		self.includes=Utils.to_list(getattr(self,'includes',[]))
+		self.uselib=self.to_list(getattr(self,'uselib',[]))
+		valatask.packages=[]
+		valatask.packages_private=Utils.to_list(getattr(self,'packages_private',[]))
+		valatask.vapi_dirs=[]
+		valatask.target=self.target
+		valatask.threading=False
+		valatask.install_path=getattr(self,'install_path','')
+		valatask.profile=getattr(self,'profile','gobject')
+		valatask.vala_defines=getattr(self,'vala_defines',[])
+		valatask.target_glib=None
+		valatask.gir=getattr(self,'gir',None)
+		valatask.gir_path=getattr(self,'gir_path','${DATAROOTDIR}/gir-1.0')
+		valatask.vapi_path=getattr(self,'vapi_path','${DATAROOTDIR}/vala/vapi')
+		valatask.pkg_name=getattr(self,'pkg_name',self.env['PACKAGE'])
+		valatask.header_path=getattr(self,'header_path','${INCLUDEDIR}/%s-%s'%(valatask.pkg_name,_get_api_version()))
+		valatask.is_lib=False
+		if not'cprogram'in self.features:
+			valatask.is_lib=True
+		packages=Utils.to_list(getattr(self,'packages',[]))
+		vapi_dirs=Utils.to_list(getattr(self,'vapi_dirs',[]))
+		includes=[]
+		if hasattr(self,'use'):
+			local_packages=Utils.to_list(self.use)[:]
+			seen=[]
+			while len(local_packages)>0:
+				package=local_packages.pop()
+				if package in seen:
+					continue
+				seen.append(package)
+				try:
+					package_obj=self.bld.get_tgen_by_name(package)
+				except Errors.WafError:
+					continue
+				package_name=package_obj.target
+				package_node=package_obj.path
+				package_dir=package_node.path_from(self.path)
+				for task in package_obj.tasks:
+					for output in task.outputs:
+						if output.name==package_name+".vapi":
+							valatask.set_run_after(task)
+							if package_name not in packages:
+								packages.append(package_name)
+							if package_dir not in vapi_dirs:
+								vapi_dirs.append(package_dir)
+							if package_dir not in includes:
+								includes.append(package_dir)
+				if hasattr(package_obj,'use'):
+					lst=self.to_list(package_obj.use)
+					lst.reverse()
+					local_packages=[pkg for pkg in lst if pkg not in seen]+local_packages
+		valatask.packages=packages
+		for vapi_dir in vapi_dirs:
+			try:
+				valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).abspath())
+				valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).get_bld().abspath())
+			except AttributeError:
+				Logs.warn("Unable to locate Vala API directory: '%s'"%vapi_dir)
+		self.includes.append(self.bld.srcnode.abspath())
+		self.includes.append(self.bld.bldnode.abspath())
+		for include in includes:
+			try:
+				self.includes.append(self.path.find_dir(include).abspath())
+				self.includes.append(self.path.find_dir(include).get_bld().abspath())
+			except AttributeError:
+				Logs.warn("Unable to locate include directory: '%s'"%include)
+		if valatask.profile=='gobject':
+			if hasattr(self,'target_glib'):
+				Logs.warn('target_glib on vala tasks is not supported --vala-target-glib=MAJOR.MINOR from the vala tool options')
+			if getattr(Options.options,'vala_target_glib',None):
+				valatask.target_glib=Options.options.vala_target_glib
+			if not'GOBJECT'in self.uselib:
+				self.uselib.append('GOBJECT')
+		if hasattr(self,'threading'):
+			if valatask.profile=='gobject':
+				valatask.threading=self.threading
+				if not'GTHREAD'in self.uselib:
+					self.uselib.append('GTHREAD')
+			else:
+				Logs.warn("Profile %s does not have threading support"%valatask.profile)
+		if valatask.is_lib:
+			valatask.outputs.append(self.path.find_or_declare('%s.h'%self.target))
+			valatask.outputs.append(self.path.find_or_declare('%s.vapi'%self.target))
+			if valatask.gir:
+				valatask.outputs.append(self.path.find_or_declare('%s.gir'%self.gir))
+			if valatask.packages:
+				d=self.path.find_or_declare('%s.deps'%self.target)
+				valatask.outputs.append(d)
+				valatask.deps_node=d
+	valatask.inputs.append(node)
+	c_node=node.change_ext('.c')
+	valatask.outputs.append(c_node)
+	self.source.append(c_node)
+	if valatask.is_lib:
+		headers_list=[o for o in valatask.outputs if o.suffix()==".h"]
+		try:
+			self.install_vheader.source=headers_list
+		except AttributeError:
+			self.install_vheader=self.bld.install_files(valatask.header_path,headers_list,self.env)
+		vapi_list=[o for o in valatask.outputs if(o.suffix()in(".vapi",".deps"))]
+		try:
+			self.install_vapi.source=vapi_list
+		except AttributeError:
+			self.install_vapi=self.bld.install_files(valatask.vapi_path,vapi_list,self.env)
+		gir_list=[o for o in valatask.outputs if o.suffix()==".gir"]
+		try:
+			self.install_gir.source=gir_list
+		except AttributeError:
+			self.install_gir=self.bld.install_files(valatask.gir_path,gir_list,self.env)
+valac=Task.update_outputs(valac)
+def find_valac(self,valac_name,min_version):
+	valac=self.find_program(valac_name,var='VALAC')
+	try:
+		output=self.cmd_and_log(valac+' --version')
+	except Exception:
+		valac_version=None
+	else:
+		ver=re.search(r'\d+.\d+.\d+',output).group(0).split('.')
+		valac_version=tuple([int(x)for x in ver])
+	self.msg('Checking for %s version >= %r'%(valac_name,min_version),valac_version,valac_version and valac_version>=min_version)
+	if valac and valac_version<min_version:
+		self.fatal("%s version %r is too old, need >= %r"%(valac_name,valac_version,min_version))
+	self.env['VALAC_VERSION']=valac_version
+	return valac
+def check_vala(self,min_version=(0,8,0),branch=None):
+	if not branch:
+		branch=min_version[:2]
+	try:
+		find_valac(self,'valac-%d.%d'%(branch[0],branch[1]),min_version)
+	except self.errors.ConfigurationError:
+		find_valac(self,'valac',min_version)
+def check_vala_deps(self):
+	if not self.env['HAVE_GOBJECT']:
+		pkg_args={'package':'gobject-2.0','uselib_store':'GOBJECT','args':'--cflags --libs'}
+		if getattr(Options.options,'vala_target_glib',None):
+			pkg_args['atleast_version']=Options.options.vala_target_glib
+		self.check_cfg(**pkg_args)
+	if not self.env['HAVE_GTHREAD']:
+		pkg_args={'package':'gthread-2.0','uselib_store':'GTHREAD','args':'--cflags --libs'}
+		if getattr(Options.options,'vala_target_glib',None):
+			pkg_args['atleast_version']=Options.options.vala_target_glib
+		self.check_cfg(**pkg_args)
+def configure(self):
+	self.load('gnu_dirs')
+	self.check_vala_deps()
+	self.check_vala()
+def options(opt):
+	opt.load('gnu_dirs')
+	valaopts=opt.add_option_group('Vala Compiler Options')
+	valaopts.add_option('--vala-target-glib',default=None,dest='vala_target_glib',metavar='MAJOR.MINOR',help='Target version of glib for Vala GObject code generation')
+
+extension('.vala','.gs')(vala_file)
+conf(find_valac)
+conf(check_vala)
+conf(check_vala_deps)