No OneTemporary
Actions

Authored By

Unknown

Size

16 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/SConscript b/SConscript
	index e0a149b5..43dee259 100644
	--- a/SConscript
	+++ b/SConscript
	@@ -1,120 +1,124 @@
	import os
	import sys

	Import('root')

	sys.path.append(Dir('.').rel_path(Dir("#%s" % root)))

	import scons_rtech1.utils
	import scons_rtech1.checks

	Import('env')
	Import('build_dir_root')

	build_type = 'release'
	if scons_rtech1.utils.useAndroid():
	build_type = 'armeabi-v7a'
	if scons_rtech1.utils.useAndroidX64():
	build_type = 'android-x64'

	config = env.Configure(custom_tests = {'CheckAllegro5': scons_rtech1.checks.checkAllegro5(scons_rtech1.checks.debug()),
	'CheckFreetype': scons_rtech1.checks.checkFreetype,
	'ConfigChecks': scons_rtech1.checks.configChecks})

	if scons_rtech1.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_rtech1.utils.useLLVM():
	+ env['CXX'] = 'clang++'
	+ env['CC'] = 'clang'
	+
	if scons_rtech1.checks.debug():
	env.Append(CXXFLAGS = ['-g3','-ggdb'])

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

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

	libname = getLibName()

	env.Append(CPPPATH = [Dir('include', Dir('.').rel_path(Dir('#' + root)))])

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

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

	if os.access(env.installPrefix, os.W_OK):
	installEnv = env.Clone(tools = ['textfile'])
	# Install target and configuration
	installEnv.Install('{0}/lib'.format(installEnv.installPrefix), rtech1)

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

	include_dir = 'include/r-tech1'
	for root, dirs, files in os.walk(include_dir):
	for file in files:
	installEnv.Install(header_prefix + root[len(include_dir):], os.path.join(root, file))

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

	# pkg-config file create
	pc_mod, pc_install = scons_rtech1.utils.pc_install(installEnv, build_dir, scons_rtech1.checks.debug())

	# Install pkg-config file
	installEnv.Alias('install', [installEnv.installPrefix, pc_install])
	installEnv.Depends([installEnv.installPrefix, pc_mod], rtech1)

	# Uninstall target
	installEnv.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'])

	include_dir = 'include/r-tech1'
	root_dir = Dir('include/r-tech1', Dir('#%s' % root)).abspath
	for myroot, dirs, files in os.walk(root_dir):
	for file in files:
	source = os.path.join(myroot, file)
	dir = myroot[len(root_dir) + 1:]
	destination = Dir(dir, Dir('headers/r-tech1', Dir(build_dir))).abspath

	env['RTECH1_HEADERS'] = [Dir('include', Dir('.').rel_path(Dir('#%s' % root))).abspath]

	# Unit tests
	env.Alias('tests', 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.AlwaysBuild(copy)
	env.Alias('tests', copy, copy[0].abspath)

	Return('rtech1')
	diff --git a/scons_rtech1/utils.py b/scons_rtech1/utils.py
	index d2cbc1d8..855494bf 100644
	--- a/scons_rtech1/utils.py
	+++ b/scons_rtech1/utils.py
	@@ -1,335 +1,337 @@
	from SCons.Script import ARGUMENTS, Command, Copy
	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 useLLVM():
	+ return makeUseEnvironment('llvm', 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():
	print "[rtech1] Allegro ", useAllegro(), " Allegro5", useAllegro5()
	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

	def pc_install(installEnv, build_dir, debug):
	# allegro 5 libs
	def libs(debug):
	libs = ['allegro',
	'allegro_ttf',
	'allegro_memfile',
	'allegro_image',
	'allegro_primitives',
	'allegro_audio',
	'allegro_acodec'
	]
	return ['{0}{1}-5'.format(lib, '-debug' if debug else '', ) for lib in libs]

	# PC script
	replacelist = {
	'%lib%': 'r-tech1' if not debug else 'r-tech1-debug',
	'%prefix%': installEnv.installPrefix,
	'%rtech1_version%': '1',
	'%libs%': ' '.join(libs(debug)) + ' freetype2 zlib',
	}

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

	return script('r-tech1') if not debug else script('r-tech1-debug')

File Metadata

Mime Type: text/x-diff
Expires: Tue, Jun 16, 1:11 AM (2 w, 20 h ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 72745
Default Alt Text: (16 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions