#! /usr/bin/env python
# encoding: utf-8
# WARNING! Do not edit! https://waf.io/book/index.html#_obtaining_the_waf_file

import os,re,imp,sys
from waflib import Utils,Errors,Logs
import waflib.Node
HEXVERSION=0x1090300
WAFVERSION="1.9.3"
WAFREVISION="d31398c4a3e8b8f055821d3db6cf6d2ef1b09a40"
ABI=99
DBFILE='.wafpickle-%s-%d-%d'%(sys.platform,sys.hexversion,ABI)
APPNAME='APPNAME'
VERSION='VERSION'
TOP='top'
OUT='out'
WSCRIPT_FILE='wscript'
launch_dir=''
run_dir=''
top_dir=''
out_dir=''
waf_dir=''
g_module=None
STDOUT=1
STDERR=-1
BOTH=0
classes=[]
def create_context(cmd_name,*k,**kw):
	global classes
	for x in classes:
		if x.cmd==cmd_name:
			return x(*k,**kw)
	ctx=Context(*k,**kw)
	ctx.fun=cmd_name
	return ctx
class store_context(type):
	def __init__(cls,name,bases,dict):
		super(store_context,cls).__init__(name,bases,dict)
		name=cls.__name__
		if name in('ctx','Context'):
			return
		try:
			cls.cmd
		except AttributeError:
			raise Errors.WafError('Missing command for the context class %r (cmd)'%name)
		if not getattr(cls,'fun',None):
			cls.fun=cls.cmd
		global classes
		classes.insert(0,cls)
ctx=store_context('ctx',(object,),{})
class Context(ctx):
	errors=Errors
	tools={}
	def __init__(self,**kw):
		try:
			rd=kw['run_dir']
		except KeyError:
			global run_dir
			rd=run_dir
		self.node_class=type('Nod3',(waflib.Node.Node,),{})
		self.node_class.__module__='waflib.Node'
		self.node_class.ctx=self
		self.root=self.node_class('',None)
		self.cur_script=None
		self.path=self.root.find_dir(rd)
		self.stack_path=[]
		self.exec_dict={'ctx':self,'conf':self,'bld':self,'opt':self}
		self.logger=None
	def finalize(self):
		try:
			logger=self.logger
		except AttributeError:
			pass
		else:
			Logs.free_logger(logger)
			delattr(self,'logger')
	def load(self,tool_list,*k,**kw):
		tools=Utils.to_list(tool_list)
		path=Utils.to_list(kw.get('tooldir',''))
		with_sys_path=kw.get('with_sys_path',True)
		for t in tools:
			module=load_tool(t,path,with_sys_path=with_sys_path)
			fun=getattr(module,kw.get('name',self.fun),None)
			if fun:
				fun(self)
	def execute(self):
		global g_module
		self.recurse([os.path.dirname(g_module.root_path)])
	def pre_recurse(self,node):
		self.stack_path.append(self.cur_script)
		self.cur_script=node
		self.path=node.parent
	def post_recurse(self,node):
		self.cur_script=self.stack_path.pop()
		if self.cur_script:
			self.path=self.cur_script.parent
	def recurse(self,dirs,name=None,mandatory=True,once=True,encoding=None):
		try:
			cache=self.recurse_cache
		except AttributeError:
			cache=self.recurse_cache={}
		for d in Utils.to_list(dirs):
			if not os.path.isabs(d):
				d=os.path.join(self.path.abspath(),d)
			WSCRIPT=os.path.join(d,WSCRIPT_FILE)
			WSCRIPT_FUN=WSCRIPT+'_'+(name or self.fun)
			node=self.root.find_node(WSCRIPT_FUN)
			if node and(not once or node not in cache):
				cache[node]=True
				self.pre_recurse(node)
				try:
					function_code=node.read('rU',encoding)
					exec(compile(function_code,node.abspath(),'exec'),self.exec_dict)
				finally:
					self.post_recurse(node)
			elif not node:
				node=self.root.find_node(WSCRIPT)
				tup=(node,name or self.fun)
				if node and(not once or tup not in cache):
					cache[tup]=True
					self.pre_recurse(node)
					try:
						wscript_module=load_module(node.abspath(),encoding=encoding)
						user_function=getattr(wscript_module,(name or self.fun),None)
						if not user_function:
							if not mandatory:
								continue
							raise Errors.WafError('No function %s defined in %s'%(name or self.fun,node.abspath()))
						user_function(self)
					finally:
						self.post_recurse(node)
				elif not node:
					if not mandatory:
						continue
					try:
						os.listdir(d)
					except OSError:
						raise Errors.WafError('Cannot read the folder %r'%d)
					raise Errors.WafError('No wscript file in directory %s'%d)
	def exec_command(self,cmd,**kw):
		subprocess=Utils.subprocess
		kw['shell']=isinstance(cmd,str)
		Logs.debug('runner: %r',cmd)
		Logs.debug('runner_env: kw=%s',kw)
		if self.logger:
			self.logger.info(cmd)
		if'stdout'not in kw:
			kw['stdout']=subprocess.PIPE
		if'stderr'not in kw:
			kw['stderr']=subprocess.PIPE
		if Logs.verbose and not kw['shell']and not Utils.check_exe(cmd[0]):
			raise Errors.WafError('Program %s not found!'%cmd[0])
		wargs={}
		if'timeout'in kw:
			if kw['timeout']is not None:
				wargs['timeout']=kw['timeout']
			del kw['timeout']
		if'input'in kw:
			if kw['input']:
				wargs['input']=kw['input']
				kw['stdin']=subprocess.PIPE
			del kw['input']
		if'cwd'in kw:
			if not isinstance(kw['cwd'],str):
				kw['cwd']=kw['cwd'].abspath()
		try:
			ret,out,err=Utils.run_process(cmd,kw,wargs)
		except Exception as e:
			raise Errors.WafError('Execution failure: %s'%str(e),ex=e)
		if out:
			if not isinstance(out,str):
				out=out.decode(sys.stdout.encoding or'iso8859-1')
			if self.logger:
				self.logger.debug('out: %s',out)
			else:
				Logs.info(out,extra={'stream':sys.stdout,'c1':''})
		if err:
			if not isinstance(err,str):
				err=err.decode(sys.stdout.encoding or'iso8859-1')
			if self.logger:
				self.logger.error('err: %s'%err)
			else:
				Logs.info(err,extra={'stream':sys.stderr,'c1':''})
		return ret
	def cmd_and_log(self,cmd,**kw):
		subprocess=Utils.subprocess
		kw['shell']=isinstance(cmd,str)
		Logs.debug('runner: %r',cmd)
		if'quiet'in kw:
			quiet=kw['quiet']
			del kw['quiet']
		else:
			quiet=None
		if'output'in kw:
			to_ret=kw['output']
			del kw['output']
		else:
			to_ret=STDOUT
		if Logs.verbose and not kw['shell']and not Utils.check_exe(cmd[0]):
			raise Errors.WafError('Program %r not found!'%cmd[0])
		kw['stdout']=kw['stderr']=subprocess.PIPE
		if quiet is None:
			self.to_log(cmd)
		wargs={}
		if'timeout'in kw:
			if kw['timeout']is not None:
				wargs['timeout']=kw['timeout']
			del kw['timeout']
		if'input'in kw:
			if kw['input']:
				wargs['input']=kw['input']
				kw['stdin']=subprocess.PIPE
			del kw['input']
		if'cwd'in kw:
			if not isinstance(kw['cwd'],str):
				kw['cwd']=kw['cwd'].abspath()
		try:
			ret,out,err=Utils.run_process(cmd,kw,wargs)
		except Exception as e:
			raise Errors.WafError('Execution failure: %s'%str(e),ex=e)
		if not isinstance(out,str):
			out=out.decode(sys.stdout.encoding or'iso8859-1')
		if not isinstance(err,str):
			err=err.decode(sys.stdout.encoding or'iso8859-1')
		if out and quiet!=STDOUT and quiet!=BOTH:
			self.to_log('out: %s'%out)
		if err and quiet!=STDERR and quiet!=BOTH:
			self.to_log('err: %s'%err)
		if ret:
			e=Errors.WafError('Command %r returned %r'%(cmd,ret))
			e.returncode=ret
			e.stderr=err
			e.stdout=out
			raise e
		if to_ret==BOTH:
			return(out,err)
		elif to_ret==STDERR:
			return err
		return out
	def fatal(self,msg,ex=None):
		if self.logger:
			self.logger.info('from %s: %s'%(self.path.abspath(),msg))
		try:
			msg='%s\n(complete log in %s)'%(msg,self.logger.handlers[0].baseFilename)
		except AttributeError:
			pass
		raise self.errors.ConfigurationError(msg,ex=ex)
	def to_log(self,msg):
		if not msg:
			return
		if self.logger:
			self.logger.info(msg)
		else:
			sys.stderr.write(str(msg))
			sys.stderr.flush()
	def msg(self,*k,**kw):
		try:
			msg=kw['msg']
		except KeyError:
			msg=k[0]
		self.start_msg(msg,**kw)
		try:
			result=kw['result']
		except KeyError:
			result=k[1]
		color=kw.get('color')
		if not isinstance(color,str):
			color=result and'GREEN'or'YELLOW'
		self.end_msg(result,color,**kw)
	def start_msg(self,*k,**kw):
		if kw.get('quiet'):
			return
		msg=kw.get('msg')or k[0]
		try:
			if self.in_msg:
				self.in_msg+=1
				return
		except AttributeError:
			self.in_msg=0
		self.in_msg+=1
		try:
			self.line_just=max(self.line_just,len(msg))
		except AttributeError:
			self.line_just=max(40,len(msg))
		for x in(self.line_just*'-',msg):
			self.to_log(x)
		Logs.pprint('NORMAL',"%s :"%msg.ljust(self.line_just),sep='')
	def end_msg(self,*k,**kw):
		if kw.get('quiet'):
			return
		self.in_msg-=1
		if self.in_msg:
			return
		result=kw.get('result')or k[0]
		defcolor='GREEN'
		if result==True:
			msg='ok'
		elif result==False:
			msg='not found'
			defcolor='YELLOW'
		else:
			msg=str(result)
		self.to_log(msg)
		try:
			color=kw['color']
		except KeyError:
			if len(k)>1 and k[1]in Logs.colors_lst:
				color=k[1]
			else:
				color=defcolor
		Logs.pprint(color,msg)
	def load_special_tools(self,var,ban=[]):
		global waf_dir
		if os.path.isdir(waf_dir):
			lst=self.root.find_node(waf_dir).find_node('waflib/extras').ant_glob(var)
			for x in lst:
				if not x.name in ban:
					load_tool(x.name.replace('.py',''))
		else:
			from zipfile import PyZipFile
			waflibs=PyZipFile(waf_dir)
			lst=waflibs.namelist()
			for x in lst:
				if not re.match('waflib/extras/%s'%var.replace('*','.*'),var):
					continue
				f=os.path.basename(x)
				doban=False
				for b in ban:
					r=b.replace('*','.*')
					if re.match(r,f):
						doban=True
				if not doban:
					f=f.replace('.py','')
					load_tool(f)
cache_modules={}
def load_module(path,encoding=None):
	try:
		return cache_modules[path]
	except KeyError:
		pass
	module=imp.new_module(WSCRIPT_FILE)
	try:
		code=Utils.readf(path,m='rU',encoding=encoding)
	except EnvironmentError:
		raise Errors.WafError('Could not read the file %r'%path)
	module_dir=os.path.dirname(path)
	sys.path.insert(0,module_dir)
	try:
		exec(compile(code,path,'exec'),module.__dict__)
	finally:
		sys.path.remove(module_dir)
	cache_modules[path]=module
	return module
def load_tool(tool,tooldir=None,ctx=None,with_sys_path=True):
	if tool=='java':
		tool='javaw'
	else:
		tool=tool.replace('++','xx')
	if not with_sys_path:
		back_path=sys.path
		sys.path=[]
	try:
		if tooldir:
			assert isinstance(tooldir,list)
			sys.path=tooldir+sys.path
			try:
				__import__(tool)
			finally:
				for d in tooldir:
					sys.path.remove(d)
			ret=sys.modules[tool]
			Context.tools[tool]=ret
			return ret
		else:
			if not with_sys_path:sys.path.insert(0,waf_dir)
			try:
				for x in('waflib.Tools.%s','waflib.extras.%s','waflib.%s','%s'):
					try:
						__import__(x%tool)
						break
					except ImportError:
						x=None
				else:
					__import__(tool)
			finally:
				if not with_sys_path:sys.path.remove(waf_dir)
			ret=sys.modules[x%tool]
			Context.tools[tool]=ret
			return ret
	finally:
		if not with_sys_path:
			sys.path+=back_path
