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

import os,re,traceback,sys
from waflib import Utils,ansiterm
if not os.environ.get('NOSYNC',False):
	if sys.stdout.isatty()and id(sys.stdout)==id(sys.__stdout__):
		sys.stdout=ansiterm.AnsiTerm(sys.stdout)
	if sys.stderr.isatty()and id(sys.stderr)==id(sys.__stderr__):
		sys.stderr=ansiterm.AnsiTerm(sys.stderr)
import logging
LOG_FORMAT=os.environ.get('WAF_LOG_FORMAT','%(asctime)s %(c1)s%(zone)s%(c2)s %(message)s')
HOUR_FORMAT=os.environ.get('WAF_HOUR_FORMAT','%H:%M:%S')
zones=[]
verbose=0
colors_lst={'USE':True,'BOLD':'\x1b[01;1m','RED':'\x1b[01;31m','GREEN':'\x1b[32m','YELLOW':'\x1b[33m','PINK':'\x1b[35m','BLUE':'\x1b[01;34m','CYAN':'\x1b[36m','GREY':'\x1b[37m','NORMAL':'\x1b[0m','cursor_on':'\x1b[?25h','cursor_off':'\x1b[?25l',}
indicator='\r\x1b[K%s%s%s'
try:
	unicode
except NameError:
	unicode=None
def enable_colors(use):
	if use==1:
		if not(sys.stderr.isatty()or sys.stdout.isatty()):
			use=0
		if Utils.is_win32 and os.name!='java':
			term=os.environ.get('TERM','')
		else:
			term=os.environ.get('TERM','dumb')
		if term in('dumb','emacs'):
			use=0
	if use>=1:
		os.environ['TERM']='vt100'
	colors_lst['USE']=use
try:
	get_term_cols=ansiterm.get_term_cols
except AttributeError:
	def get_term_cols():
		return 80
get_term_cols.__doc__="""
	Returns the console width in characters.

	:return: the number of characters per line
	:rtype: int
	"""
def get_color(cl):
	if colors_lst['USE']:
		return colors_lst.get(cl,'')
	return''
class color_dict(object):
	def __getattr__(self,a):
		return get_color(a)
	def __call__(self,a):
		return get_color(a)
colors=color_dict()
re_log=re.compile(r'(\w+): (.*)',re.M)
class log_filter(logging.Filter):
	def __init__(self,name=''):
		logging.Filter.__init__(self,name)
	def filter(self,rec):
		rec.zone=rec.module
		if rec.levelno>=logging.INFO:
			return True
		m=re_log.match(rec.msg)
		if m:
			rec.zone=m.group(1)
			rec.msg=m.group(2)
		if zones:
			return getattr(rec,'zone','')in zones or'*'in zones
		elif not verbose>2:
			return False
		return True
class log_handler(logging.StreamHandler):
	def emit(self,record):
		try:
			try:
				self.stream=record.stream
			except AttributeError:
				if record.levelno>=logging.WARNING:
					record.stream=self.stream=sys.stderr
				else:
					record.stream=self.stream=sys.stdout
			self.emit_override(record)
			self.flush()
		except(KeyboardInterrupt,SystemExit):
			raise
		except:
			self.handleError(record)
	def emit_override(self,record,**kw):
		self.terminator=getattr(record,'terminator','\n')
		stream=self.stream
		if unicode:
			msg=self.formatter.format(record)
			fs='%s'+self.terminator
			try:
				if(isinstance(msg,unicode)and getattr(stream,'encoding',None)):
					fs=fs.decode(stream.encoding)
					try:
						stream.write(fs%msg)
					except UnicodeEncodeError:
						stream.write((fs%msg).encode(stream.encoding))
				else:
					stream.write(fs%msg)
			except UnicodeError:
				stream.write((fs%msg).encode('utf-8'))
		else:
			logging.StreamHandler.emit(self,record)
class formatter(logging.Formatter):
	def __init__(self):
		logging.Formatter.__init__(self,LOG_FORMAT,HOUR_FORMAT)
	def format(self,rec):
		try:
			msg=rec.msg.decode('utf-8')
		except Exception:
			msg=rec.msg
		use=colors_lst['USE']
		if(use==1 and rec.stream.isatty())or use==2:
			c1=getattr(rec,'c1',None)
			if c1 is None:
				c1=''
				if rec.levelno>=logging.ERROR:
					c1=colors.RED
				elif rec.levelno>=logging.WARNING:
					c1=colors.YELLOW
				elif rec.levelno>=logging.INFO:
					c1=colors.GREEN
			c2=getattr(rec,'c2',colors.NORMAL)
			msg='%s%s%s'%(c1,msg,c2)
		else:
			msg=re.sub(r'\r(?!\n)|\x1B\[(K|.*?(m|h|l))','',msg)
		if rec.levelno>=logging.INFO:
			if rec.args:
				try:
					return msg%rec.args
				except UnicodeDecodeError:
					return msg.encode('utf-8')%rec.args
			return msg
		rec.msg=msg
		rec.c1=colors.PINK
		rec.c2=colors.NORMAL
		return logging.Formatter.format(self,rec)
log=None
def debug(*k,**kw):
	if verbose:
		k=list(k)
		k[0]=k[0].replace('\n',' ')
		log.debug(*k,**kw)
def error(*k,**kw):
	log.error(*k,**kw)
	if verbose>2:
		st=traceback.extract_stack()
		if st:
			st=st[:-1]
			buf=[]
			for filename,lineno,name,line in st:
				buf.append('  File %r, line %d, in %s'%(filename,lineno,name))
				if line:
					buf.append('	%s'%line.strip())
			if buf:
				log.error('\n'.join(buf))
def warn(*k,**kw):
	log.warning(*k,**kw)
def info(*k,**kw):
	log.info(*k,**kw)
def init_log():
	global log
	log=logging.getLogger('waflib')
	log.handlers=[]
	log.filters=[]
	hdlr=log_handler()
	hdlr.setFormatter(formatter())
	log.addHandler(hdlr)
	log.addFilter(log_filter())
	log.setLevel(logging.DEBUG)
def make_logger(path,name):
	logger=logging.getLogger(name)
	if sys.hexversion>0x3000000:
		encoding=sys.stdout.encoding
	else:
		encoding=None
	hdlr=logging.FileHandler(path,'w',encoding=encoding)
	formatter=logging.Formatter('%(message)s')
	hdlr.setFormatter(formatter)
	logger.addHandler(hdlr)
	logger.setLevel(logging.DEBUG)
	return logger
def make_mem_logger(name,to_log,size=8192):
	from logging.handlers import MemoryHandler
	logger=logging.getLogger(name)
	hdlr=MemoryHandler(size,target=to_log)
	formatter=logging.Formatter('%(message)s')
	hdlr.setFormatter(formatter)
	logger.addHandler(hdlr)
	logger.memhandler=hdlr
	logger.setLevel(logging.DEBUG)
	return logger
def free_logger(logger):
	try:
		for x in logger.handlers:
			x.close()
			logger.removeHandler(x)
	except Exception:
		pass
def pprint(col,msg,label='',sep='\n'):
	info('%s%s%s %s',colors(col),msg,colors.NORMAL,label,extra={'terminator':sep})