No OneTemporary
Actions

Authored By

Unknown

Size

22 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/SConscript b/SConscript
	index 14f783c3..66c5f4d9 100644
	--- a/SConscript
	+++ b/SConscript
	@@ -1,124 +1,132 @@
	import os
	import scons.utils
	import scons.checks
	import scons.env

	Import('env')

	build_type = 'release'
	if scons.utils.useAndroid():
	build_type = 'armeabi-v7a'
	-
	+if scons.utils.useAndroidX64():
	+ build_type = 'android-x64'
	+
	config = env.Configure(custom_tests = {'CheckAllegro5': scons.checks.checkAllegro5(scons.checks.debug()),
	'CheckFreetype': scons.checks.checkFreetype,
	'ConfigChecks': scons.checks.configChecks})
	-config.CheckAllegro5()
	-config.CheckFreetype()
	+
	+if scons.utils.useAndroidX64():
	+ env['HAVE_ALLEGRO5'] = True
	+ env.Append(CPPDEFINES = ['USE_ALLEGRO5'])
	+else:
	+ config.CheckAllegro5()
	+ config.CheckFreetype()
	+
	config.ConfigChecks()
	env = config.Finish()

	if not env['HAVE_ALLEGRO5']:
	Exit(1)

	if scons.checks.debug():
	env.Append(CXXFLAGS = ['-g3','-ggdb', '-Werror'])

	build_dir = 'build/%s' % build_type if not scons.checks.debug() else 'build/debug'
	options = {'networking': False,
	'allegro5': True
	}

	def getLibName():
	if scons.utils.useAndroid():
	return 'lib/r-tech1-arm'
	if scons.checks.debug():
	return 'lib/r-tech1-debug'
	return 'lib/r-tech1'

	libname = getLibName()

	env.VariantDir(build_dir, 'src')
	libs = env.SConscript('src/SConscript', variant_dir=build_dir, exports=['env', 'options'])
	rtech1 = env.StaticLibrary(libname, libs)
	Alias('rtech1', rtech1)

	tests_build_dir = os.path.join(build_dir, 'tests')
	unit_tests = []
	if not scons.utils.useAndroid():
	unit_tests = SConscript('tests/SConscript', variant_dir = tests_build_dir, exports = ['env', 'rtech1'], duplicate=0)
	env.Depends(unit_tests, rtech1)

	if os.access(env.installPrefix, os.W_OK):
	# Install target and configuration
	env.Install('{0}/lib'.format(env.installPrefix), rtech1)

	header_prefix = '{0}/include/r-tech1'.format(env.installPrefix)

	include_dir = 'include/r-tech1'
	for root, dirs, files in os.walk(include_dir):
	for file in files:
	# print "Install %s, %s" % (header_prefix + root[len('include/r-tech1'):], os.path.join(root, file))
	# Install to <header location>/<local subdirectory>. The root contains the full
	# include/r-tech1/subdirectory, so we chop off the leading include/r-tech1
	env.Install(header_prefix + root[len(include_dir):], os.path.join(root, file))

	env.Install(os.path.join(header_prefix, 'lz4'), 'src/libs/lz4/lz4.h')

	# Construct dependency cflags and libraries for pc script
	def createList(content, modifier):
	deps = ''
	for item in content:
	deps += '-{0}{1} '.format(modifier, item) if 'r-tech1' not in item else ''
	return deps
	pcflags = createList(env['CPPPATH'], 'I')
	pclibs = createList(env['LIBS'], 'l')
	pclibpaths = createList(env['LIBPATH'], 'L')

	# PC script
	replacelist = {
	'%lib%': 'r-tech1' if not scons.checks.debug() else 'r-tech1-debug',
	'%prefix%': env.installPrefix,
	'%rtech1_version%': '1',
	'%flags%': pcflags,
	'%libs%': pclibs,
	'%libpaths%': pclibpaths
	}

	def script(name):
	pc_install = '{0}/lib/pkgconfig/{1}.pc'.format(env.installPrefix, name)
	pc_copied = Command(build_dir + '/temp.pc.in', 'misc/r-tech1.pc.in'.format(name), Copy('$TARGET', '$SOURCE'))
	pc_script = env.Substfile(build_dir + '/temp.pc.in', SUBST_DICT = replacelist)
	env.Depends(pc_script, pc_copied)
	pc_mod = Command(build_dir + '/{0}.pc'.format(name), build_dir + '/temp.pc', Copy('$TARGET', '$SOURCE'))
	env.Depends(pc_mod, pc_script)
	env.InstallAs(pc_install, pc_mod)
	return pc_mod, pc_install

	pc_mod, pc_install = script('r-tech1') if not scons.checks.debug() else script('r-tech1-debug')

	# Install
	env.Alias('install', [env.installPrefix, pc_install])
	env.Depends([env.installPrefix, pc_mod], rtech1)

	# Uninstall target
	env.Command("uninstall", None, Delete(FindInstalledFiles()))
	else:
	def needsudo(target, source, env):
	print 'No write priveleges to {0}, run target [{1}] as sudo'.format(env.installPrefix, target[0])
	env.Command('install', None, needsudo)
	env.Depends('install', ['rtech1', 'tests'])
	env.Command('uninstall', None, needsudo)
	env.Depends('uninstall', ['rtech1', 'tests'])

	env.Default(rtech1)
	env.Default(unit_tests)

	for test in unit_tests:
	orig = str(test).translate(None,'[]\'')
	to = orig.replace('{0}/tests/'.format(build_dir), '')
	#print orig, to
	copy = Command('bin/{0}'.format(to), orig, Copy('$TARGET', '$SOURCE'))
	env.Depends(copy, test)
	env.Default(copy)

	Return('rtech1')
	diff --git a/SConstruct b/SConstruct
	index 3259a2dc..e2803630 100644
	--- a/SConstruct
	+++ b/SConstruct
	@@ -1,18 +1,20 @@
	import os
	import scons.utils
	import scons.checks
	import scons.env

	SetOption('num_jobs', scons.utils.detectCPUs())

	includedir = '{0}/include'.format(os.getcwd())

	env = Environment(ENV = os.environ, CPPPATH=includedir, tools=['textfile', 'default'])

	if scons.utils.useAndroid():
	env = scons.env.android(env)
	+if scons.utils.useAndroidX64():
	+ env = scons.env.androidx64(env)

	if not scons.utils.isVerbose():
	env = scons.utils.less_verbose(env)

	SConscript('SConscript', exports = ['env'])
	diff --git a/scons/env.py b/scons/env.py
	index 790e2996..6c4b3192 100644
	--- a/scons/env.py
	+++ b/scons/env.py
	@@ -1,61 +1,121 @@
	from SCons.Script import Split

	def android(env):
	# Sets up the environment for Google Android
	def setup(pre, x):
	return '%s%s' % (pre, x)

	platform = 'android-9'
	arch = 'armeabi-v7a'
	path = '/opt/android/android-toolchain'
	# bin_path = setup(path, '/arm-linux-androideabi-4.4.3/bin')
	bin_path = setup(path, '/bin')
	prefix = 'arm-linux-androideabi-'
	def set_prefix(x):
	return '%s%s' % (prefix, x)
	env['CC'] = set_prefix('gcc')
	env['LD'] = set_prefix('ld')
	env['CXX'] = set_prefix('g++')
	env['AS'] = set_prefix('as')
	env['AR'] = set_prefix('ar')
	env['OBJCOPY'] = set_prefix('objcopy')

	base = setup(path, '/user/%(arch)s' % {'arch': arch})

	env.PrependENVPath('PKG_CONFIG_PATH', base + '/lib/pkgconfig')

	env.Append(CPPPATH = ['%s/include' % base,
	# '%s/include/allegro5' % base
	])

	#env.Append(CPPPATH = [setup(path, '/arm-linux-androideabi-4.4.3/include'),
	# setup(path, '/platforms/%s/arch-arm/usr/include' % platform),
	# setup(path, '/platforms/%s/arch-arm/usr/include/SDL' % platform),
	# setup(path, '/platforms/%s/arch-arm/usr/include/freetype' % platform),
	# setup(path, '/sources/cxx-stl/gnu-libstdc++/include')
	# ])
	env.Append(CPPDEFINES = Split("""ANDROID __ARM_ARCH_5__ __ARM_ARCH_5T__ __ARM_ARCH_5E__ __ARM_ARCH_5TE__"""))
	# flags = ['-fpic', '-fexceptions', '-ffunction-sections', '-funwind-tables', '-fstack-protector', '-Wno-psabi', '-march=armv5te', '-mtune=xscale', '-msoft-float', '-mthumb', '-Os', '-fomit-frame-pointer', '-fno-strict-aliasing', '-finline-limit=64',]
	flags = ['-shared', '-fpic', '-fexceptions', '-ffunction-sections', '-funwind-tables', '-Wno-psabi', '-march=armv5te', '-mtune=xscale', '-msoft-float', '-mthumb', '-Os', '-fomit-frame-pointer', '-fno-strict-aliasing', '-finline-limit=64']
	# linkflags = flags + ['-Wl,--allow-shlib-undefined']
	linkflags = flags + ['-Wl,--no-undefined']
	# libs = ['freetype', 'png', 'SDL', 'm', 'log', 'jnigraphics', 'c', 'm', 'supc++',]
	# Copy the static stdc++ from gnu-libstdc++
	# gnustdlib = env.InstallAs('misc/libgnustdc++.a', '/opt/android/sources/cxx-stl/gnu-libstdc++/libs/armeabi/libstdc++.a')
	# libs = Split("""freetype2-static png SDL m log c jnigraphics supc++ EGL GLESv2 GLESv1_CM z gnustdc++""")
	libs = Split("""freetype2-static png m log c jnigraphics EGL GLESv2 GLESv1_CM z gnustl_static""")
	env.Append(CCFLAGS = flags)
	env.Append(CXXFLAGS = flags)
	env.Append(LINKFLAGS = linkflags)
	env.Append(CPPPATH = ['#src/android'])
	env['LINKCOM'] = '$CXX $LINKFLAGS -Wl,--start-group $SOURCES $ARCHIVES $_LIBDIRFLAGS $_LIBFLAGS -Wl,--end-group -o $TARGET'
	# Hack to put libstdc++ at the end
	# env['LINKCOM'] = '$CXX $LINKFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS /opt/android/sources/cxx-stl/gnu-libstdc++/libs/armeabi/libstdc++.a -o $TARGET'
	# env['LINKCOM'] = '$CXX $LINKFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS -o $TARGET'
	env.Append(LIBS = libs)
	env.Append(LIBPATH = ['%s/lib' % base,
	#setup(path, '/platforms/%s/arch-arm/usr/lib' % platform),
	])

	env.PrependENVPath('PATH', bin_path)
	return env
	+
	+def androidx64(env):
	+ # Sets up the environment for Google Android
	+ def setup(pre, x):
	+ return '%s%s' % (pre, x)
	+
	+ platform = 'android-9'
	+ arch = 'x86_64'
	+ path = '/opt/android/android-x64-toolchain'
	+ # bin_path = setup(path, '/arm-linux-androideabi-4.4.3/bin')
	+ bin_path = setup(path, '/bin')
	+ prefix = 'x86_64-linux-android-'
	+ def set_prefix(x):
	+ return '%s%s' % (prefix, x)
	+ env['CC'] = set_prefix('gcc')
	+ env['LD'] = set_prefix('ld')
	+ env['CXX'] = set_prefix('g++')
	+ env['AS'] = set_prefix('as')
	+ env['AR'] = set_prefix('ar')
	+ env['OBJCOPY'] = set_prefix('objcopy')
	+
	+ base = setup(path, '/user/%(arch)s' % {'arch': arch})
	+
	+ env.PrependENVPath('PKG_CONFIG_PATH', base + '/lib/pkgconfig')
	+
	+ env.Append(CPPPATH = ['%s/include' % base,
	+ # '%s/include/allegro5' % base
	+ ])
	+
	+ #env.Append(CPPPATH = [setup(path, '/arm-linux-androideabi-4.4.3/include'),
	+ # setup(path, '/platforms/%s/arch-arm/usr/include' % platform),
	+ # setup(path, '/platforms/%s/arch-arm/usr/include/SDL' % platform),
	+ # setup(path, '/platforms/%s/arch-arm/usr/include/freetype' % platform),
	+ # setup(path, '/sources/cxx-stl/gnu-libstdc++/include')
	+ # ])
	+ env.Append(CPPDEFINES = Split("""ANDROID"""))
	+ # flags = ['-fpic', '-fexceptions', '-ffunction-sections', '-funwind-tables', '-fstack-protector', '-Wno-psabi', '-march=armv5te', '-mtune=xscale', '-msoft-float', '-mthumb', '-Os', '-fomit-frame-pointer', '-fno-strict-aliasing', '-finline-limit=64',]
	+ flags = ['-shared', '-fpic', '-fexceptions', '-ffunction-sections', '-funwind-tables', '-Wno-psabi', '-O2', '-fno-strict-aliasing']
	+ # linkflags = flags + ['-Wl,--allow-shlib-undefined']
	+ linkflags = flags + ['-Wl,--no-undefined']
	+ # libs = ['freetype', 'png', 'SDL', 'm', 'log', 'jnigraphics', 'c', 'm', 'supc++',]
	+ # Copy the static stdc++ from gnu-libstdc++
	+ # gnustdlib = env.InstallAs('misc/libgnustdc++.a', '/opt/android/sources/cxx-stl/gnu-libstdc++/libs/armeabi/libstdc++.a')
	+ # libs = Split("""freetype2-static png SDL m log c jnigraphics supc++ EGL GLESv2 GLESv1_CM z gnustdc++""")
	+ libs = Split("""freetype2-static png m log c jnigraphics EGL GLESv2 GLESv1_CM z gnustl_static""")
	+ env.Append(CCFLAGS = flags)
	+ env.Append(CXXFLAGS = flags)
	+ env.Append(LINKFLAGS = linkflags)
	+ env.Append(CPPPATH = ['#src/android'])
	+ env['LINKCOM'] = '$CXX $LINKFLAGS -Wl,--start-group $SOURCES $ARCHIVES $_LIBDIRFLAGS $_LIBFLAGS -Wl,--end-group -o $TARGET'
	+ # Hack to put libstdc++ at the end
	+ # env['LINKCOM'] = '$CXX $LINKFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS /opt/android/sources/cxx-stl/gnu-libstdc++/libs/armeabi/libstdc++.a -o $TARGET'
	+ # env['LINKCOM'] = '$CXX $LINKFLAGS $SOURCES $_LIBDIRFLAGS $_LIBFLAGS -o $TARGET'
	+ env.Append(LIBS = libs)
	+ env.Append(LIBPATH = ['%s/lib' % base,
	+ #setup(path, '/platforms/%s/arch-arm/usr/lib' % platform),
	+ ])
	+
	+ env.PrependENVPath('PATH', bin_path)
	+ return env
	diff --git a/scons/utils.py b/scons/utils.py
	index 4b09f7ac..7bc48d8a 100644
	--- a/scons/utils.py
	+++ b/scons/utils.py
	@@ -1,299 +1,300 @@
	from SCons.Script import ARGUMENTS
	import os

	def noColors():
	try:
	return int(ARGUMENTS['colors']) == 0
	except KeyError:
	return False

	def xterm_color(string, color):
	colors = {'none': "0",
	'black': "0;30",
	'red': "0;31",
	'green': "0;32",
	'brown': "0;33",
	'blue': "0;34",
	'purple': "0;35",
	'cyan': "0;36",
	'light-gray': "0;37",
	'dark-gray': "1:30",
	'light-red': "1;31",
	'light-green': "1;32",
	'yellow': "1;33",
	'light-blue': "1;34",
	'light-purple': "1;35",
	'light-cyan': "1;36",
	'white': "1;37"}
	return "\033[%sm%s\033[0m" % (colors[color], string)

	def isPlatform(platform):
	import sys
	return platform in sys.platform

	def isWindows():
	return isPlatform("win32")

	def isLinux():
	return isPlatform("linux")

	def isOSX104():
	import platform
	return isPlatform("darwin") and platform.processor() == 'powerpc'

	# Assume 10.6 and up
	def isOSX():
	return isPlatform("darwin") and not isOSX104()

	# todo: figure out when we are on an xterm
	def isXterm():
	# assume linux and osx are ok
	return not isWindows()

	def colorize(string, color):
	if noColors():
	return string
	if isXterm():
	return xterm_color(string, color)
	return string

	def colorResult(what):
	if what != 0:
	return colorize('yes', 'light-green')
	else:
	return colorize('no', 'light-red')

	def peg_to_cpp(target, source, env):
	import sys
	sys.path.append("src/mugen/parser")
	sys.path.append(".")
	import peg, re, cpp_generator
	name = source[0].name
	parser = peg.make_peg_parser(re.sub('\..*', '', name))
	fout = open(target[0].path, 'w')
	fout.write(cpp_generator.generate(parser(source[0].path)))
	fout.write('\n')
	fout.close()

	# Build a cpp file from a peg definition
	def pegBuilder(environment):
	from SCons.Builder import Builder
	from SCons.Action import Action
	return Builder(action = Action(peg_to_cpp, environment['PEG_MAKE']),
	suffix = '.cpp',
	src_suffix = '.peg')

	def readExec(program):
	import os
	try:
	return os.popen(program).readline().replace("\n",'')
	except OSError:
	return ""

	# Try to execute a script that will produce some compiler flags but fail
	# gracefully if the script dies or can't be found
	def safeParseConfig(environment, config):
	# redirects stderr, not super safe
	def version1():
	import sys
	out = open('fail.log', 'w')
	old_stderr = sys.stderr
	try:
	sys.stderr = out
	environment.ParseConfig(config)
	out.close()
	sys.stderr = old_stderr
	except Exception, e:
	out.close()
	sys.stderr = old_stderr
	raise e
	# use the subprocess module to pass the output of stdout directly
	# to mergeflags and trash stderr
	# Not done yet!! This requires python 2.4
	def version2():
	import subprocess
	process = subprocess.Popen(config.split(' '), stdout = subprocess.PIPE)
	# p = subprocess.Popen(["ruby", "-e", code], stdout = subprocess.PIPE, stderr = subprocess.PIPE)
	out = p.stdout.readline().strip()
	environment.MergeFlags(out)

	version1()

	# Create a function that pulls out some key from the shell environment
	def makeUseEnvironment(key, default):
	def use():
	import os
	try:
	return int(os.environ[key]) == 1
	except KeyError:
	return default
	return use

	def makeUseArgument(key, default):
	def use():
	try:
	return int(ARGUMENTS[key]) == 1
	except KeyError:
	return default
	return use

	useGch = makeUseArgument('gch', True)
	usePrx = makeUseEnvironment('prx', False)
	isVerbose = makeUseArgument('verbose', False)
	useIntel = makeUseEnvironment('intel', False)
	useMinpspw = makeUseEnvironment('minpspw', False)
	useAndroid = makeUseEnvironment('android', False)
	useAndroidX86 = makeUseEnvironment('androidx86', False)
	+useAndroidX64 = makeUseEnvironment('androidx64', False)
	useIos = makeUseEnvironment('ios', False)
	usePs3 = makeUseEnvironment('ps3', False)
	useNDS = makeUseEnvironment('nds', False)
	useDingoo = makeUseEnvironment('dingoo', False)
	useXenon = makeUseEnvironment('xenon', False)
	usePandora = makeUseEnvironment('pandora', False)
	useWii = makeUseEnvironment('wii', False)
	useLLVM = makeUseEnvironment('llvm', False)
	useNacl = makeUseEnvironment('nacl', False)
	useMpg123 = makeUseEnvironment('mpg123', False)
	useMad = makeUseEnvironment('mad', False)
	useGCW = makeUseEnvironment('gcw', False)
	nativeCompile = makeUseEnvironment('native', False)
	enableProfiled = makeUseEnvironment('PROFILE', False)
	showTiming = makeUseEnvironment('timing', False)
	useAllegro4 = makeUseEnvironment('allegro4', False)
	useWii = makeUseEnvironment('wii', False)

	def useAllegro():
	def byEnv():
	try:
	return os.environ['ALLEGRO'] == '1'
	except KeyError:
	return False

	def byArgument():
	try:
	return int(ARGUMENTS['allegro']) == 1
	except KeyError:
	return False

	return byEnv() or byArgument()

	def useAllegro5():
	def byEnv():
	try:
	return os.environ['ALLEGRO5'] == '1'
	except KeyError:
	return False

	def byArgument():
	try:
	return int(ARGUMENTS['allegro5']) == 1
	except KeyError:
	return False

	# FIXME: hack to specify android here
	return byEnv() or byArgument() or useAndroid() or useAndroidX86()

	def useSDL():
	return not useAllegro() and not useAllegro5()

	# Replace standard tool invocations with nice colored text
	def lessVerbose(env):
	link_color = 'light-red'
	ar_color = 'yellow'
	ranlib_color = 'light-purple'
	peg_color = 'light-cyan'
	env['CCCOMSTR'] = "%s %s" % (colorize('Compiling c file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['SHCCCOMSTR'] = "%s %s" % (colorize('Compiling c file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['CXXCOMSTR'] = "%s %s" % (colorize('Compiling c++ file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['SHCXXCOMSTR'] = "%s %s" % (colorize('Compiling c++ file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['LINKCOMSTR'] = "%s %s" % (colorize('Linking', link_color), colorize('$TARGET', 'light-blue'))
	env['SHLINKCOMSTR'] = "%s %s" % (colorize('Linking', link_color), colorize('$TARGET', 'light-blue'))
	env['ARCOMSTR'] = "%s %s" % (colorize('Building library', ar_color), colorize('$TARGET', 'light-blue'))
	env['RANLIBCOMSTR'] = "%s %s" % (colorize('Indexing library', ranlib_color), colorize('$TARGET', 'light-blue'))
	env['PEG_MAKE'] = "%s %s" % (colorize('Creating peg parser', peg_color), colorize('$TARGET', 'light-blue'))
	return env

	def configure_backend(environment, backends, custom_tests):
	config = environment.Configure(custom_tests = custom_tests)

	if not config.CheckCompiler():
	config.Finish()
	raise Exception("No c++ compiler found. Install gcc or clang")

	class OkBackend(Exception):
	pass

	class NoBackend(Exception):
	pass

	try:
	for backend in backends:
	if backend == 'SDL' and config.CheckSDL():
	environment.Append(CPPDEFINES = ['USE_SDL'])
	environment['PAINTOWN_BACKEND'] = 'sdl'
	environment.Append(PAINTOWN_PLATFORM = ['sdl'])
	raise OkBackend()
	if backend == 'Allegro4' and config.CheckAllegro4():
	environment.Append(CPPDEFINES = ['USE_ALLEGRO'])
	environment['PAINTOWN_BACKEND'] = 'allegro4'
	environment.Append(PAINTOWN_PLATFORM = ['allegro4'])
	raise OkBackend()
	if backend == 'Allegro5' and config.CheckAllegro5():
	environment.Append(CPPDEFINES = ['USE_ALLEGRO5'])
	environment['PAINTOWN_BACKEND'] = 'allegro5'
	environment.Append(PAINTOWN_PLATFORM = ['allegro5'])
	raise OkBackend()
	config.Finish()
	raise NoBackend()
	except OkBackend:
	pass

	return config.Finish()

	def checkCompiler(context):
	context.Message("Checking for a compiler (%s) ... " % context.env['CXX'])
	ok = context.TryCompile("""
	int main(int argc, char ** argv){
	return 0;
	}
	""", ".cpp")
	context.Result(colorResult(ok))
	return ok

	def detectCPUs():
	import os
	"""
	Detects the number of CPUs on a system. Cribbed from pp.
	"""

	# Linux, Unix and MacOS:
	if hasattr(os, "sysconf"):
	if "SC_NPROCESSORS_ONLN" in os.sysconf_names:
	# Linux & Unix:
	ncpus = os.sysconf("SC_NPROCESSORS_ONLN")
	if isinstance(ncpus, int) and ncpus > 0:
	return ncpus
	else: # OSX:
	return int(os.popen2("sysctl -n hw.ncpu")[1].read())
	# Windows:
	if "NUMBER_OF_PROCESSORS" in os.environ:
	ncpus = int(os.environ["NUMBER_OF_PROCESSORS"]);
	if ncpus > 0:
	return ncpus
	return 1 # Default

	def less_verbose(env):
	link_color = 'light-red'
	ar_color = 'yellow'
	ranlib_color = 'light-purple'
	peg_color = 'light-cyan'
	env['CCCOMSTR'] = "%s %s" % (colorize('Compiling c file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['SHCCCOMSTR'] = "%s %s" % (colorize('Compiling c file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['CXXCOMSTR'] = "%s %s" % (colorize('Compiling c++ file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['SHCXXCOMSTR'] = "%s %s" % (colorize('Compiling c++ file', 'light-green'), colorize('$SOURCE', 'light-blue'))
	env['LINKCOMSTR'] = "%s %s" % (colorize('Linking', link_color), colorize('$TARGET', 'light-blue'))
	env['SHLINKCOMSTR'] = "%s %s" % (colorize('Linking', link_color), colorize('$TARGET', 'light-blue'))
	env['ARCOMSTR'] = "%s %s" % (colorize('Building library', ar_color), colorize('$TARGET', 'light-blue'))
	env['RANLIBCOMSTR'] = "%s %s" % (colorize('Indexing library', ranlib_color), colorize('$TARGET', 'light-blue'))
	env['PEG_MAKE'] = "%s %s" % (colorize('Creating peg parser', peg_color), colorize('$TARGET', 'light-blue'))
	return env

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 12:18 AM (2 w, 2 d ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 70733
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions