text: #! /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,taskgen_method
  from waflib.Configure import conf
  class valac(Task.Task):
  	vars=["VALAC","VALAC_VERSION","VALAFLAGS"]
  	ext_out=['.h']
  	def run(self):
  		cmd=[self.env['VALAC']]+self.env['VALAFLAGS']
  		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.generator.dump_deps_node:
  			self.generator.dump_deps_node.write('\n'.join(self.generator.packages))
  		return ret
  valac=Task.update_outputs(valac)
  @taskgen_method
  def init_vala_task(self):
  	self.profile=getattr(self,'profile','gobject')
  	if self.profile=='gobject':
  		self.uselib=Utils.to_list(getattr(self,'uselib',[]))
  		if not'GOBJECT'in self.uselib:
  			self.uselib.append('GOBJECT')
  	def addflags(flags):
  		self.env.append_value('VALAFLAGS',flags)
  	if self.profile:
  		addflags('--profile=%s'%self.profile)
  	if hasattr(self,'threading'):
  		if self.profile=='gobject':
  			if not'GTHREAD'in self.uselib:
  				self.uselib.append('GTHREAD')
  		else:
  			Logs.warn("Profile %s means no threading support"%self.profile)
  			self.threading=False
  		if self.threading:
  			addflags('--threading')
  	valatask=self.valatask
  	self.is_lib='cprogram'not in self.features
  	if self.is_lib:
  		addflags('--library=%s'%self.target)
  		h_node=self.path.find_or_declare('%s.h'%self.target)
  		valatask.outputs.append(h_node)
  		addflags('--header=%s'%h_node.name)
  		valatask.outputs.append(self.path.find_or_declare('%s.vapi'%self.target))
  		if getattr(self,'gir',None):
  			gir_node=self.path.find_or_declare('%s.gir'%self.gir)
  			addflags('--gir=%s'%gir_node.name)
  			valatask.outputs.append(gir_node)
  	self.vala_target_glib=getattr(self,'vala_target_glib',getattr(Options.options,'vala_target_glib',None))
  	if self.vala_target_glib:
  		addflags('--target-glib=%s'%self.vala_target_glib)
  	addflags(['--define=%s'%x for x in getattr(self,'vala_defines',[])])
  	packages_private=Utils.to_list(getattr(self,'packages_private',[]))
  	addflags(['--pkg=%s'%x for x in packages_private])
  	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
  	self.includes=Utils.to_list(getattr(self,'includes',[]))
  	self.uselib=self.to_list(getattr(self,'uselib',[]))
  	valatask.install_path=getattr(self,'install_path','')
  	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.install_binding=getattr(self,'install_binding',True)
  	self.packages=packages=Utils.to_list(getattr(self,'packages',[]))
  	self.vapi_dirs=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
  	addflags(['--pkg=%s'%p for p in packages])
  	for vapi_dir in vapi_dirs:
  		v_node=self.path.find_dir(vapi_dir)
  		if not v_node:
  			Logs.warn('Unable to locate Vala API directory: %r'%vapi_dir)
  		else:
  			addflags('--vapidir=%s'%v_node.abspath())
  			addflags('--vapidir=%s'%v_node.get_bld().abspath())
  	self.dump_deps_node=None
  	if self.is_lib and self.packages:
  		self.dump_deps_node=self.path.find_or_declare('%s.deps'%self.target)
  		valatask.outputs.append(self.dump_deps_node)
  	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 self.is_lib and valatask.install_binding:
  		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(getattr(self,'gir_path','${DATAROOTDIR}/gir-1.0'),gir_list,self.env)
  @extension('.vala','.gs')
  def vala_file(self,node):
  	try:
  		valatask=self.valatask
  	except AttributeError:
  		valatask=self.valatask=self.create_task('valac')
  		self.init_vala_task()
  	valatask.inputs.append(node)
  	c_node=node.change_ext('.c')
  	valatask.outputs.append(c_node)
  	self.source.append(c_node)
  @conf
  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
  @conf
  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)
  @conf
  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()
  	self.env.VALAFLAGS=['-C','--quiet']
  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')
  