text_ux 0.0.1

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

@@ -0,0 +1,298 @@
+#! /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,imp,sys
+from waflib import Utils,Errors,Logs
+import waflib.Node
+HEXVERSION=0x1060800
+WAFVERSION="1.6.8"
+WAFREVISION="516a253cbdbb4eef3165c4d47c2074a0fb5dce95"
+ABI=98
+DBFILE='.wafpickle-%d'%ABI
+APPNAME='APPNAME'
+VERSION='VERSION'
+TOP='top'
+OUT='out'
+WSCRIPT_FILE='wscript'
+launch_dir=''
+run_dir=''
+top_dir=''
+out_dir=''
+waf_dir=''
+local_repo=''
+remote_repo='http://waf.googlecode.com/git/'
+remote_locs=['branches/waf-%s/waflib/extras'%WAFVERSION,'trunk/waflib/extras','trunk/waflib/Tools']
+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=='ctx'or name=='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
+		class node_class(waflib.Node.Node):
+			pass
+		self.node_class=node_class
+		self.node_class.__module__="waflib.Node"
+		self.node_class.__name__="Nod3"
+		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 __hash__(self):
+		return id(self)
+	def load(self,tool_list,*k,**kw):
+		tools=Utils.to_list(tool_list)
+		path=Utils.to_list(kw.get('tooldir',''))
+		for t in tools:
+			module=load_tool(t,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):
+		try:
+			cache=self.recurse_cache
+		except:
+			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')
+					exec(compile(function_code,node.abspath(),'exec'),self.exec_dict)
+				finally:
+					self.post_recurse(node)
+			elif not node:
+				node=self.root.find_node(WSCRIPT)
+				if node and(not once or node not in cache):
+					cache[node]=True
+					self.pre_recurse(node)
+					try:
+						wscript_module=load_module(node.abspath())
+						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
+					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)
+		try:
+			if self.logger:
+				self.logger.info(cmd)
+				kw['stdout']=kw['stderr']=subprocess.PIPE
+				p=subprocess.Popen(cmd,**kw)
+				(out,err)=p.communicate()
+				if out:
+					self.logger.debug('out: %s'%out.decode(sys.stdout.encoding or'iso8859-1'))
+				if err:
+					self.logger.error('err: %s'%err.decode(sys.stdout.encoding or'iso8859-1'))
+				return p.returncode
+			else:
+				p=subprocess.Popen(cmd,**kw)
+				return p.wait()
+		except OSError:
+			return-1
+	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
+		kw['stdout']=kw['stderr']=subprocess.PIPE
+		if quiet is None:
+			self.to_log(cmd)
+		try:
+			p=subprocess.Popen(cmd,**kw)
+			(out,err)=p.communicate()
+		except Exception ,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 p.returncode:
+			e=Errors.WafError('Command %r returned %r'%(cmd,p.returncode))
+			e.returncode=p.returncode
+			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:
+			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,msg,result,color=None):
+		self.start_msg(msg)
+		if not isinstance(color,str):
+			color=result and'GREEN'or'YELLOW'
+		self.end_msg(result,color)
+	def start_msg(self,msg):
+		try:
+			if self.in_msg:
+				self.in_msg+=1
+				return
+		except:
+			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,result,color=None):
+		self.in_msg-=1
+		if self.in_msg:
+			return
+		defcolor='GREEN'
+		if result==True:
+			msg='ok'
+		elif result==False:
+			msg='not found'
+			defcolor='YELLOW'
+		else:
+			msg=str(result)
+		self.to_log(msg)
+		Logs.pprint(color or defcolor,msg)
+	def load_special_tools(self,var,ban=[]):
+		global 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',''))
+cache_modules={}
+def load_module(path):
+	try:
+		return cache_modules[path]
+	except KeyError:
+		pass
+	module=imp.new_module(WSCRIPT_FILE)
+	try:
+		code=Utils.readf(path,m='rU')
+	except(IOError,OSError):
+		raise Errors.WafError('Could not read the file %r'%path)
+	module_dir=os.path.dirname(path)
+	sys.path.insert(0,module_dir)
+	exec(compile(code,path,'exec'),module.__dict__)
+	sys.path.remove(module_dir)
+	cache_modules[path]=module
+	return module
+def load_tool(tool,tooldir=None):
+	tool=tool.replace('++','xx')
+	tool=tool.replace('java','javaw')
+	tool=tool.replace('compiler_cc','compiler_c')
+	if tooldir:
+		assert isinstance(tooldir,list)
+		sys.path=tooldir+sys.path
+		try:
+			__import__(tool)
+			ret=sys.modules[tool]
+			Context.tools[tool]=ret
+			return ret
+		finally:
+			for d in tooldir:
+				sys.path.remove(d)
+	else:
+		global waf_dir
+		try:
+			os.stat(os.path.join(waf_dir,'waflib','extras',tool+'.py'))
+			d='waflib.extras.%s'%tool
+		except:
+			try:
+				os.stat(os.path.join(waf_dir,'waflib','Tools',tool+'.py'))
+				d='waflib.Tools.%s'%tool
+			except:
+				d=tool
+		__import__(d)
+		ret=sys.modules[d]
+		Context.tools[tool]=ret
+		return ret

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

@@ -0,0 +1,37 @@
+#! /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 traceback,sys
+class WafError(Exception):
+	def __init__(self,msg='',ex=None):
+		self.msg=msg
+		assert not isinstance(msg,Exception)
+		self.stack=[]
+		if ex:
+			if not msg:
+				self.msg=str(ex)
+			if isinstance(ex,WafError):
+				self.stack=ex.stack
+			else:
+				self.stack=traceback.extract_tb(sys.exc_info()[2])
+		self.stack+=traceback.extract_stack()[:-1]
+		self.verbose_msg=''.join(traceback.format_list(self.stack))
+	def __str__(self):
+		return str(self.msg)
+class BuildError(WafError):
+	def __init__(self,error_tasks=[]):
+		self.tasks=error_tasks
+		WafError.__init__(self,self.format_error())
+	def format_error(self):
+		lst=['Build failed']
+		for tsk in self.tasks:
+			txt=tsk.format_error()
+			if txt:lst.append(txt)
+		return'\n'.join(lst)
+class ConfigurationError(WafError):
+	pass
+class TaskRescan(WafError):
+	pass
+class TaskNotReady(WafError):
+	pass

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

@@ -0,0 +1,149 @@
+#! /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,traceback,sys
+_nocolor=os.environ.get('NOCOLOR','no')not in('no','0','false')
+try:
+	if not _nocolor:
+		import waflib.ansiterm
+except:
+	pass
+import logging
+LOG_FORMAT="%(asctime)s %(c1)s%(zone)s%(c2)s %(message)s"
+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','NORMAL':'\x1b[0m','cursor_on':'\x1b[?25h','cursor_off':'\x1b[?25l',}
+got_tty=not os.environ.get('TERM','dumb')in['dumb','emacs']
+if got_tty:
+	try:
+		got_tty=sys.stderr.isatty()
+	except AttributeError:
+		got_tty=False
+if(not got_tty and os.environ.get('TERM','dumb')!='msys')or _nocolor:
+	colors_lst['USE']=False
+def get_term_cols():
+	return 80
+try:
+	import struct,fcntl,termios
+except ImportError:
+	pass
+else:
+	if got_tty:
+		def get_term_cols_real():
+			dummy_lines,cols=struct.unpack("HHHH",fcntl.ioctl(sys.stderr.fileno(),termios.TIOCGWINSZ,struct.pack("HHHH",0,0,0,0)))[:2]
+			return cols
+		try:
+			get_term_cols_real()
+		except:
+			pass
+		else:
+			get_term_cols=get_term_cols_real
+get_term_cols.__doc__="""
+	Get the console width in characters.
+
+	:return: the number of characters per line
+	:rtype: int
+	"""
+def get_color(cl):
+	if not colors_lst['USE']:return''
+	return colors_lst.get(cl,'')
+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=None):
+		pass
+	def filter(self,rec):
+		rec.c1=colors.PINK
+		rec.c2=colors.NORMAL
+		rec.zone=rec.module
+		if rec.levelno>=logging.INFO:
+			if rec.levelno>=logging.ERROR:
+				rec.c1=colors.RED
+			elif rec.levelno>=logging.WARNING:
+				rec.c1=colors.YELLOW
+			else:
+				rec.c1=colors.GREEN
+			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 formatter(logging.Formatter):
+	def __init__(self):
+		logging.Formatter.__init__(self,LOG_FORMAT,HOUR_FORMAT)
+	def format(self,rec):
+		if rec.levelno>=logging.WARNING or rec.levelno==logging.INFO:
+			try:
+				msg=rec.msg.decode('utf-8')
+			except:
+				msg=rec.msg
+			return'%s%s%s'%(rec.c1,msg,rec.c2)
+		return logging.Formatter.format(self,rec)
+log=None
+def debug(*k,**kw):
+	if verbose:
+		k=list(k)
+		k[0]=k[0].replace('\n',' ')
+		global log
+		log.debug(*k,**kw)
+def error(*k,**kw):
+	global log
+	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 "%s", 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):
+	global log
+	log.warn(*k,**kw)
+def info(*k,**kw):
+	global log
+	log.info(*k,**kw)
+def init_log():
+	global log
+	log=logging.getLogger('waflib')
+	log.handlers=[]
+	log.filters=[]
+	hdlr=logging.StreamHandler()
+	hdlr.setFormatter(formatter())
+	log.addHandler(hdlr)
+	log.addFilter(log_filter())
+	log.setLevel(logging.DEBUG)
+def make_logger(path,name):
+	logger=logging.getLogger(name)
+	hdlr=logging.FileHandler(path,'w')
+	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=10000):
+	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 pprint(col,str,label='',sep='\n'):
+	sys.stderr.write("%s%s%s %s%s"%(colors(col),str,colors.NORMAL,label,sep))