1 files changed, 726 insertions, 0 deletions
diff --git a/buildtools/wafadmin/Utils.py b/buildtools/wafadmin/Utils.py
new file mode 100644
index 0000000000..41dad570eb
--- /dev/null
+++ b/buildtools/wafadmin/Utils.py
@@ -0,0 +1,726 @@
+#!/usr/bin/env python
+# encoding: utf-8
+# Thomas Nagy, 2005 (ita)
+
+"""
+Utilities, the stable ones are the following:
+
+* h_file: compute a unique value for a file (hash), it uses
+  the module fnv if it is installed (see waf/utils/fnv & http://code.google.com/p/waf/wiki/FAQ)
+  else, md5 (see the python docs)
+
+  For large projects (projects with more than 15000 files) or slow hard disks and filesystems (HFS)
+  it is possible to use a hashing based on the path and the size (may give broken cache results)
+  The method h_file MUST raise an OSError if the file is a folder
+
+	import stat
+	def h_file(filename):
+		st = os.stat(filename)
+		if stat.S_ISDIR(st[stat.ST_MODE]): raise IOError('not a file')
+		m = Utils.md5()
+		m.update(str(st.st_mtime))
+		m.update(str(st.st_size))
+		m.update(filename)
+		return m.digest()
+
+	To replace the function in your project, use something like this:
+	import Utils
+	Utils.h_file = h_file
+
+* h_list
+* h_fun
+* get_term_cols
+* ordered_dict
+
+"""
+
+import os, sys, imp, string, errno, traceback, inspect, re, shutil, datetime, gc
+
+# In python 3.0 we can get rid of all this
+try: from UserDict import UserDict
+except ImportError: from collections import UserDict
+if sys.hexversion >= 0x2060000 or os.name == 'java':
+	import subprocess as pproc
+else:
+	import pproc
+import Logs
+from Constants import *
+
+try:
+	from collections import deque
+except ImportError:
+	class deque(list):
+		def popleft(self):
+			return self.pop(0)
+
+is_win32 = sys.platform == 'win32'
+
+try:
+	# defaultdict in python 2.5
+	from collections import defaultdict as DefaultDict
+except ImportError:
+	class DefaultDict(dict):
+		def __init__(self, default_factory):
+			super(DefaultDict, self).__init__()
+			self.default_factory = default_factory
+		def __getitem__(self, key):
+			try:
+				return super(DefaultDict, self).__getitem__(key)
+			except KeyError:
+				value = self.default_factory()
+				self[key] = value
+				return value
+
+class WafError(Exception):
+	def __init__(self, *args):
+		self.args = args
+		try:
+			self.stack = traceback.extract_stack()
+		except:
+			pass
+		Exception.__init__(self, *args)
+	def __str__(self):
+		return str(len(self.args) == 1 and self.args[0] or self.args)
+
+class WscriptError(WafError):
+	def __init__(self, message, wscript_file=None):
+		if wscript_file:
+			self.wscript_file = wscript_file
+			self.wscript_line = None
+		else:
+			try:
+				(self.wscript_file, self.wscript_line) = self.locate_error()
+			except:
+				(self.wscript_file, self.wscript_line) = (None, None)
+
+		msg_file_line = ''
+		if self.wscript_file:
+			msg_file_line = "%s:" % self.wscript_file
+			if self.wscript_line:
+				msg_file_line += "%s:" % self.wscript_line
+		err_message = "%s error: %s" % (msg_file_line, message)
+		WafError.__init__(self, err_message)
+
+	def locate_error(self):
+		stack = traceback.extract_stack()
+		stack.reverse()
+		for frame in stack:
+			file_name = os.path.basename(frame[0])
+			is_wscript = (file_name == WSCRIPT_FILE or file_name == WSCRIPT_BUILD_FILE)
+			if is_wscript:
+				return (frame[0], frame[1])
+		return (None, None)
+
+indicator = is_win32 and '\x1b[A\x1b[K%s%s%s\r' or '\x1b[K%s%s%s\r'
+
+try:
+	from fnv import new as md5
+	import Constants
+	Constants.SIG_NIL = 'signofnv'
+
+	def h_file(filename):
+		m = md5()
+		try:
+			m.hfile(filename)
+			x = m.digest()
+			if x is None: raise OSError("not a file")
+			return x
+		except SystemError:
+			raise OSError("not a file" + filename)
+
+except ImportError:
+	try:
+		try:
+			from hashlib import md5
+		except ImportError:
+			from md5 import md5
+
+		def h_file(filename):
+			f = open(filename, 'rb')
+			m = md5()
+			while (filename):
+				filename = f.read(100000)
+				m.update(filename)
+			f.close()
+			return m.digest()
+	except ImportError:
+		# portability fixes may be added elsewhere (although, md5 should be everywhere by now)
+		md5 = None
+
+class ordered_dict(UserDict):
+	def __init__(self, dict = None):
+		self.allkeys = []
+		UserDict.__init__(self, dict)
+
+	def __delitem__(self, key):
+		self.allkeys.remove(key)
+		UserDict.__delitem__(self, key)
+
+	def __setitem__(self, key, item):
+		if key not in self.allkeys: self.allkeys.append(key)
+		UserDict.__setitem__(self, key, item)
+
+def exec_command(s, **kw):
+	if 'log' in kw:
+		kw['stdout'] = kw['stderr'] = kw['log']
+		del(kw['log'])
+	kw['shell'] = isinstance(s, str)
+
+	try:
+		proc = pproc.Popen(s, **kw)
+		return proc.wait()
+	except OSError:
+		return -1
+
+if is_win32:
+	def exec_command(s, **kw):
+		if 'log' in kw:
+			kw['stdout'] = kw['stderr'] = kw['log']
+			del(kw['log'])
+		kw['shell'] = isinstance(s, str)
+
+		if len(s) > 2000:
+			startupinfo = pproc.STARTUPINFO()
+			startupinfo.dwFlags |= pproc.STARTF_USESHOWWINDOW
+			kw['startupinfo'] = startupinfo
+
+		try:
+			if 'stdout' not in kw:
+				kw['stdout'] = pproc.PIPE
+				kw['stderr'] = pproc.PIPE
+				kw['universal_newlines'] = True
+				proc = pproc.Popen(s,**kw)
+				(stdout, stderr) = proc.communicate()
+				Logs.info(stdout)
+				if stderr:
+					Logs.error(stderr)
+				return proc.returncode
+			else:
+				proc = pproc.Popen(s,**kw)
+				return proc.wait()
+		except OSError:
+			return -1
+
+listdir = os.listdir
+if is_win32:
+	def listdir_win32(s):
+		if re.match('^[A-Za-z]:$', s):
+			# os.path.isdir fails if s contains only the drive name... (x:)
+			s += os.sep
+		if not os.path.isdir(s):
+			e = OSError()
+			e.errno = errno.ENOENT
+			raise e
+		return os.listdir(s)
+	listdir = listdir_win32
+
+def waf_version(mini = 0x010000, maxi = 0x100000):
+	"Halts if the waf version is wrong"
+	ver = HEXVERSION
+	try: min_val = mini + 0
+	except TypeError: min_val = int(mini.replace('.', '0'), 16)
+
+	if min_val > ver:
+		Logs.error("waf version should be at least %s (%s found)" % (mini, ver))
+		sys.exit(1)
+
+	try: max_val = maxi + 0
+	except TypeError: max_val = int(maxi.replace('.', '0'), 16)
+
+	if max_val < ver:
+		Logs.error("waf version should be at most %s (%s found)" % (maxi, ver))
+		sys.exit(1)
+
+def python_24_guard():
+	if sys.hexversion < 0x20400f0 or sys.hexversion >= 0x3000000:
+		raise ImportError("Waf requires Python >= 2.3 but the raw source requires Python 2.4, 2.5 or 2.6")
+
+def ex_stack():
+	exc_type, exc_value, tb = sys.exc_info()
+	if Logs.verbose > 1:
+		exc_lines = traceback.format_exception(exc_type, exc_value, tb)
+		return ''.join(exc_lines)
+	return str(exc_value)
+
+def to_list(sth):
+	if isinstance(sth, str):
+		return sth.split()
+	else:
+		return sth
+
+g_loaded_modules = {}
+"index modules by absolute path"
+
+g_module=None
+"the main module is special"
+
+def load_module(file_path, name=WSCRIPT_FILE):
+	"this function requires an absolute path"
+	try:
+		return g_loaded_modules[file_path]
+	except KeyError:
+		pass
+
+	module = imp.new_module(name)
+
+	try:
+		code = readf(file_path, m='rU')
+	except (IOError, OSError):
+		raise WscriptError('Could not read the file %r' % file_path)
+
+	module.waf_hash_val = code
+
+	dt = os.path.dirname(file_path)
+	sys.path.insert(0, dt)
+	try:
+		exec(compile(code, file_path, 'exec'), module.__dict__)
+	except Exception:
+		exc_type, exc_value, tb = sys.exc_info()
+		raise WscriptError("".join(traceback.format_exception(exc_type, exc_value, tb)), file_path)
+	sys.path.remove(dt)
+
+	g_loaded_modules[file_path] = module
+
+	return module
+
+def set_main_module(file_path):
+	"Load custom options, if defined"
+	global g_module
+	g_module = load_module(file_path, 'wscript_main')
+	g_module.root_path = file_path
+
+	try:
+		g_module.APPNAME
+	except:
+		g_module.APPNAME = 'noname'
+	try:
+		g_module.VERSION
+	except:
+		g_module.VERSION = '1.0'
+
+	# note: to register the module globally, use the following:
+	# sys.modules['wscript_main'] = g_module
+
+def to_hashtable(s):
+	"used for importing env files"
+	tbl = {}
+	lst = s.split('\n')
+	for line in lst:
+		if not line: continue
+		mems = line.split('=')
+		tbl[mems[0]] = mems[1]
+	return tbl
+
+def get_term_cols():
+	"console width"
+	return 80
+try:
+	import struct, fcntl, termios
+except ImportError:
+	pass
+else:
+	if Logs.got_tty:
+		def myfun():
+			dummy_lines, cols = struct.unpack("HHHH", \
+			fcntl.ioctl(sys.stderr.fileno(),termios.TIOCGWINSZ , \
+			struct.pack("HHHH", 0, 0, 0, 0)))[:2]
+			return cols
+		# we actually try the function once to see if it is suitable
+		try:
+			myfun()
+		except:
+			pass
+		else:
+			get_term_cols = myfun
+
+rot_idx = 0
+rot_chr = ['\\', '|', '/', '-']
+"the rotation character in the progress bar"
+
+
+def split_path(path):
+	return path.split('/')
+
+def split_path_cygwin(path):
+	if path.startswith('//'):
+		ret = path.split('/')[2:]
+		ret[0] = '/' + ret[0]
+		return ret
+	return path.split('/')
+
+re_sp = re.compile('[/\\\\]')
+def split_path_win32(path):
+	if path.startswith('\\\\'):
+		ret = re.split(re_sp, path)[2:]
+		ret[0] = '\\' + ret[0]
+		return ret
+	return re.split(re_sp, path)
+
+if sys.platform == 'cygwin':
+	split_path = split_path_cygwin
+elif is_win32:
+	split_path = split_path_win32
+
+def copy_attrs(orig, dest, names, only_if_set=False):
+	for a in to_list(names):
+		u = getattr(orig, a, ())
+		if u or not only_if_set:
+			setattr(dest, a, u)
+
+def def_attrs(cls, **kw):
+	'''
+	set attributes for class.
+	@param cls [any class]: the class to update the given attributes in.
+	@param kw [dictionary]: dictionary of attributes names and values.
+
+	if the given class hasn't one (or more) of these attributes, add the attribute with its value to the class.
+	'''
+	for k, v in kw.iteritems():
+		if not hasattr(cls, k):
+			setattr(cls, k, v)
+
+def quote_define_name(path):
+	fu = re.compile("[^a-zA-Z0-9]").sub("_", path)
+	fu = fu.upper()
+	return fu
+
+def quote_whitespace(path):
+	return (path.strip().find(' ') > 0 and '"%s"' % path or path).replace('""', '"')
+
+def trimquotes(s):
+	if not s: return ''
+	s = s.rstrip()
+	if s[0] == "'" and s[-1] == "'": return s[1:-1]
+	return s
+
+def h_list(lst):
+	m = md5()
+	m.update(str(lst))
+	return m.digest()
+
+def h_fun(fun):
+	try:
+		return fun.code
+	except AttributeError:
+		try:
+			h = inspect.getsource(fun)
+		except IOError:
+			h = "nocode"
+		try:
+			fun.code = h
+		except AttributeError:
+			pass
+		return h
+
+def pprint(col, str, label='', sep='\n'):
+	"print messages in color"
+	sys.stderr.write("%s%s%s %s%s" % (Logs.colors(col), str, Logs.colors.NORMAL, label, sep))
+
+def check_dir(dir):
+	"""If a folder doesn't exists, create it."""
+	try:
+		os.stat(dir)
+	except OSError:
+		try:
+			os.makedirs(dir)
+		except OSError, e:
+			raise WafError("Cannot create folder '%s' (original error: %s)" % (dir, e))
+
+def cmd_output(cmd, **kw):
+
+	silent = False
+	if 'silent' in kw:
+		silent = kw['silent']
+		del(kw['silent'])
+
+	if 'e' in kw:
+		tmp = kw['e']
+		del(kw['e'])
+		kw['env'] = tmp
+
+	kw['shell'] = isinstance(cmd, str)
+	kw['stdout'] = pproc.PIPE
+	if silent:
+		kw['stderr'] = pproc.PIPE
+
+	try:
+		p = pproc.Popen(cmd, **kw)
+		output = p.communicate()[0]
+	except OSError, e:
+		raise ValueError(str(e))
+
+	if p.returncode:
+		if not silent:
+			msg = "command execution failed: %s -> %r" % (cmd, str(output))
+			raise ValueError(msg)
+		output = ''
+	return output
+
+reg_subst = re.compile(r"(\\\\)|(\$\$)|\$\{([^}]+)\}")
+def subst_vars(expr, params):
+	"substitute ${PREFIX}/bin in /usr/local/bin"
+	def repl_var(m):
+		if m.group(1):
+			return '\\'
+		if m.group(2):
+			return '$'
+		try:
+			# environments may contain lists
+			return params.get_flat(m.group(3))
+		except AttributeError:
+			return params[m.group(3)]
+	return reg_subst.sub(repl_var, expr)
+
+def unversioned_sys_platform_to_binary_format(unversioned_sys_platform):
+	"infers the binary format from the unversioned_sys_platform name."
+
+	if unversioned_sys_platform in ('linux', 'freebsd', 'netbsd', 'openbsd', 'sunos', 'gnu'):
+		return 'elf'
+	elif unversioned_sys_platform == 'darwin':
+		return 'mac-o'
+	elif unversioned_sys_platform in ('win32', 'cygwin', 'uwin', 'msys'):
+		return 'pe'
+	# TODO we assume all other operating systems are elf, which is not true.
+	# we may set this to 'unknown' and have ccroot and other tools handle the case "gracefully" (whatever that means).
+	return 'elf'
+
+def unversioned_sys_platform():
+	"""returns an unversioned name from sys.platform.
+	sys.plaform is not very well defined and depends directly on the python source tree.
+	The version appended to the names is unreliable as it's taken from the build environment at the time python was built,
+	i.e., it's possible to get freebsd7 on a freebsd8 system.
+	So we remove the version from the name, except for special cases where the os has a stupid name like os2 or win32.
+	Some possible values of sys.platform are, amongst others:
+		aix3 aix4 atheos beos5 darwin freebsd2 freebsd3 freebsd4 freebsd5 freebsd6 freebsd7
+		generic gnu0 irix5 irix6 linux2 mac netbsd1 next3 os2emx riscos sunos5 unixware7
+	Investigating the python source tree may reveal more values.
+	"""
+	s = sys.platform
+	if s == 'java':
+		# The real OS is hidden under the JVM.
+		from java.lang import System
+		s = System.getProperty('os.name')
+		# see http://lopica.sourceforge.net/os.html for a list of possible values
+		if s == 'Mac OS X':
+			return 'darwin'
+		elif s.startswith('Windows '):
+			return 'win32'
+		elif s == 'OS/2':
+			return 'os2'
+		elif s == 'HP-UX':
+			return 'hpux'
+		elif s in ('SunOS', 'Solaris'):
+			return 'sunos'
+		else: s = s.lower()
+	if s == 'win32' or s.endswith('os2') and s != 'sunos2': return s
+	return re.split('\d+$', s)[0]
+
+#@deprecated('use unversioned_sys_platform instead')
+def detect_platform():
+	"""this function has been in the Utils module for some time.
+	It's hard to guess what people have used it for.
+	It seems its goal is to return an unversionned sys.platform, but it's not handling all platforms.
+	For example, the version is not removed on freebsd and netbsd, amongst others.
+	"""
+	s = sys.platform
+
+	# known POSIX
+	for x in 'cygwin linux irix sunos hpux aix darwin gnu'.split():
+		# sys.platform may be linux2
+		if s.find(x) >= 0:
+			return x
+
+	# unknown POSIX
+	if os.name in 'posix java os2'.split():
+		return os.name
+
+	return s
+
+def load_tool(tool, tooldir=None):
+	'''
+	load_tool: import a Python module, optionally using several directories.
+	@param tool [string]: name of tool to import.
+	@param tooldir [list]: directories to look for the tool.
+	@return: the loaded module.
+
+	Warning: this function is not thread-safe: plays with sys.path,
+					 so must run in sequence.
+	'''
+	if tooldir:
+		assert isinstance(tooldir, list)
+		sys.path = tooldir + sys.path
+	else:
+		tooldir = []
+	try:
+		return __import__(tool)
+	finally:
+		for dt in tooldir:
+			sys.path.remove(dt)
+
+def readf(fname, m='r'):
+	"get the contents of a file, it is not used anywhere for the moment"
+	f = open(fname, m)
+	try:
+		txt = f.read()
+	finally:
+		f.close()
+	return txt
+
+def nada(*k, **kw):
+	"""A function that does nothing"""
+	pass
+
+def diff_path(top, subdir):
+	"""difference between two absolute paths"""
+	top = os.path.normpath(top).replace('\\', '/').split('/')
+	subdir = os.path.normpath(subdir).replace('\\', '/').split('/')
+	if len(top) == len(subdir): return ''
+	diff = subdir[len(top) - len(subdir):]
+	return os.path.join(*diff)
+
+class Context(object):
+	"""A base class for commands to be executed from Waf scripts"""
+
+	def set_curdir(self, dir):
+		self.curdir_ = dir
+
+	def get_curdir(self):
+		try:
+			return self.curdir_
+		except AttributeError:
+			self.curdir_ = os.getcwd()
+			return self.get_curdir()
+
+	curdir = property(get_curdir, set_curdir)
+
+	def recurse(self, dirs, name=''):
+		"""The function for calling scripts from folders, it tries to call wscript + function_name
+		and if that file does not exist, it will call the method 'function_name' from a file named wscript
+		the dirs can be a list of folders or a string containing space-separated folder paths
+		"""
+		if not name:
+			name = inspect.stack()[1][3]
+
+		if isinstance(dirs, str):
+			dirs = to_list(dirs)
+
+		for x in dirs:
+			if os.path.isabs(x):
+				nexdir = x
+			else:
+				nexdir = os.path.join(self.curdir, x)
+
+			base = os.path.join(nexdir, WSCRIPT_FILE)
+			file_path = base + '_' + name
+
+			try:
+				txt = readf(file_path, m='rU')
+			except (OSError, IOError):
+				try:
+					module = load_module(base)
+				except OSError:
+					raise WscriptError('No such script %s' % base)
+
+				try:
+					f = module.__dict__[name]
+				except KeyError:
+					raise WscriptError('No function %s defined in %s' % (name, base))
+
+				if getattr(self.__class__, 'pre_recurse', None):
+					self.pre_recurse(f, base, nexdir)
+				old = self.curdir
+				self.curdir = nexdir
+				try:
+					f(self)
+				finally:
+					self.curdir = old
+				if getattr(self.__class__, 'post_recurse', None):
+					self.post_recurse(module, base, nexdir)
+			else:
+				dc = {'ctx': self}
+				if getattr(self.__class__, 'pre_recurse', None):
+					dc = self.pre_recurse(txt, file_path, nexdir)
+				old = self.curdir
+				self.curdir = nexdir
+				try:
+					try:
+						exec(compile(txt, file_path, 'exec'), dc)
+					except Exception:
+						exc_type, exc_value, tb = sys.exc_info()
+						raise WscriptError("".join(traceback.format_exception(exc_type, exc_value, tb)), base)
+				finally:
+					self.curdir = old
+				if getattr(self.__class__, 'post_recurse', None):
+					self.post_recurse(txt, file_path, nexdir)
+
+if is_win32:
+	old = shutil.copy2
+	def copy2(src, dst):
+		old(src, dst)
+		shutil.copystat(src, src)
+	setattr(shutil, 'copy2', copy2)
+
+def zip_folder(dir, zip_file_name, prefix):
+	"""
+	prefix represents the app to add in the archive
+	"""
+	import zipfile
+	zip = zipfile.ZipFile(zip_file_name, 'w', compression=zipfile.ZIP_DEFLATED)
+	base = os.path.abspath(dir)
+
+	if prefix:
+		if prefix[-1] != os.sep:
+			prefix += os.sep
+
+	n = len(base)
+	for root, dirs, files in os.walk(base):
+		for f in files:
+			archive_name = prefix + root[n:] + os.sep + f
+			zip.write(root + os.sep + f, archive_name, zipfile.ZIP_DEFLATED)
+	zip.close()
+
+def get_elapsed_time(start):
+	"Format a time delta (datetime.timedelta) using the format DdHhMmS.MSs"
+	delta = datetime.datetime.now() - start
+	# cast to int necessary for python 3.0
+	days = int(delta.days)
+	hours = int(delta.seconds / 3600)
+	minutes = int((delta.seconds - hours * 3600) / 60)
+	seconds = delta.seconds - hours * 3600 - minutes * 60 \
+		+ float(delta.microseconds) / 1000 / 1000
+	result = ''
+	if days:
+		result += '%dd' % days
+	if days or hours:
+		result += '%dh' % hours
+	if days or hours or minutes:
+		result += '%dm' % minutes
+	return '%s%.3fs' % (result, seconds)
+
+if os.name == 'java':
+	# For Jython (they should really fix the inconsistency)
+	try:
+		gc.disable()
+		gc.enable()
+	except NotImplementedError:
+		gc.disable = gc.enable
+
+def run_once(fun):
+	"""
+	decorator, make a function cache its results, use like this:
+
+	@run_once
+	def foo(k):
+		return 345*2343
+	"""
+	cache = {}
+	def wrap(k):
+		try:
+			return cache[k]
+		except KeyError:
+			ret = fun(k)
+			cache[k] = ret
+			return ret
+	wrap.__cache__ = cache
+	return wrap
+