No OneTemporary
Actions

Authored By

Unknown

Size

22 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/CMakeLists.txt b/CMakeLists.txt
	index 3ec87adf..b28f00dc 100644
	--- a/CMakeLists.txt
	+++ b/CMakeLists.txt
	@@ -1,233 +1,256 @@
	# -------------------------------------------------------
	# r-tech1 cmake build script. Creates makefiles for unix
	# based systems, cygwin(sp?) or mingw
	#
	# Written by: juvinious
	# -------------------------------------------------------

	# -------------------------------------------------------
	# Ensure that we are doing an out of source build
	# Prevents any mishaps
	# Also remove the makefile to regenerate the filelist
	# -------------------------------------------------------
	cmake_minimum_required(VERSION 2.6)
	if(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt)
	file(REMOVE ${CMAKE_SOURCE_DIR}/CMakeCache.txt)
	file(REMOVE_RECURSE ${CMAKE_SOURCE_DIR}/CMakeFiles)
	endif(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt)
	if(EXISTS ${CMAKE_BINARY_DIR}/Makefile)
	file(REMOVE ${CMAKE_BINARY_DIR}/Makefile)
	endif(EXISTS ${CMAKE_BINARY_DIR}/Makefile)
	if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
	if(UNIX AND NOT CYGWIN)
	message(FATAL_ERROR "Oops. Don't do an in-source build. Create an extra directory change into it and run cmake pointing to the base directory. IE: \nmkdir mybuild && cd mybuild && cmake ../ && make\nYou may need to remove CMakeCache.txt and the CMakeFiles directory in ${CMAKE_SOURCE_DIR} if you can't get rid of this error.")
	else(UNIX AND NOT CYGWIN)
	message(FATAL_ERROR "Oops. Don't do an in-source build. Create an extra directory change into it and run cmake pointing to the base directory. IE: \nmkdir mybuild; cd mybuild; cmakesetup ../\nYou may need to remove CMakeCache.txt and the CMakeFiles directory in ${CMAKE_SOURCE_DIR} if you can't get rid of this error.")
	endif(UNIX AND NOT CYGWIN)
	endif(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})

	# -------------------------------------------------------
	-# Directory in which extra macros can be found
	+# Output directories
	# -------------------------------------------------------
	set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib)
	set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)

	+
	# -------------------------------------------------------
	# Directory in which extra macros can be found
	# -------------------------------------------------------
	list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake)

	# -------------------------------------------------------
	# Add in uninstall target
	# -------------------------------------------------------
	configure_file(
	"${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"
	"${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"
	IMMEDIATE @ONLY)

	add_custom_target(uninstall
	"${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")

	# -------------------------------------------------------
	# project name
	# -------------------------------------------------------
	project (r-tech1 C CXX)

	# -------------------------------------------------------
	# Including needed macros
	# -------------------------------------------------------
	include(CheckCSourceCompiles)
	include(CheckCXXSourceCompiles)
	find_package(ZLIB)
	find_package(PNG)
	find_package(FREETYPE)
	find_package(Threads)
	#find_package(GNUREGEX)
	find_package(VORBIS)
	find_package(OGG)
	find_package(MPG123)

	# -------------------------------------------------------
	# Include Source
	# -------------------------------------------------------
	mark_as_advanced(CLEAR ZLIB_INCLUDE_DIR)
	mark_as_advanced(CLEAR ZLIB_LIBRARY)

	mark_as_advanced(CLEAR PNG_PNG_INCLUDE_DIR)
	mark_as_advanced(CLEAR PNG_LIBRARY)

	# -------------------------------------------------------
	# User setable options
	# -------------------------------------------------------
	option(DEBUG "Compile r-tech1 with debug information?" OFF)

	if($ENV{DEBUG})
	set(DEBUG ON)
	elseif(NOT $ENV{DEBUG})
	set(DEBUG OFF)
	endif($ENV{DEBUG})

	if(DEBUG)
	add_definitions(-DDEBUG)
	set(CMAKE_CXX_FLAGS "-Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations -Woverloaded-virtual -g3 -ggdb")
	set(CMAKE_C_FLAGS "-Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations -g3 -ggdb")
	else(DEBUG)
	set(CMAKE_CXX_FLAGS "-O2 -Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations -Woverloaded-virtual")
	set(CMAKE_C_FLAGS "-O2 -Wall -Wno-unused-variable -Wno-unused-function -funroll-loops -fexpensive-optimizations")
	endif(DEBUG)

	# FIXME: not sure if this is in the right place
	add_definitions(-DHAVE_NETWORKING)

	option(USE_ALLEGRO5 "Compile r-tech1 with ALLEGRO 5 instead of SDL or Allegro 4.x?" ON)

	if($ENV{ALLEGRO5})
	set(USE_ALLEGRO5 ON)
	elseif(NOT $ENV{ALLEGRO5})
	set(USE_ALLEGRO5 OFF)
	endif($ENV{ALLEGRO5})

	if(OGG_FOUND)
	add_definitions(-DHAVE_OGG)
	set(OGG_LIBS ${OGG_LIBRARY} ${VORBIS_LIBRARIES})
	set(OGG_INCLUDES ${OGG_INCLUDE_DIR} ${VORBIS_INCLUDE_DIR})
	else(OGG_FOUND)
	set(OGG_LIBS "")
	set(OGG_INCLUDES "")
	endif(OGG_FOUND)

	# Allegro5
	find_package(ALLEGRO5)
	if(NOT ALLEGRO_FOUND)
	message(FATAL_ERROR "Couldn't find Allegro 5 and/or a required Allegro 5 module")
	endif(NOT ALLEGRO_FOUND)
	set(GRAPHICS_LIBRARIES ${ALLEGRO_LIBRARIES})
	set(GRAPHICS_INCLUDES ${ALLEGRO_INCLUDE_DIR})

	if(MPG123_FOUND)
	add_definitions(-DHAVE_MP3_MPG123)
	set(MP3_LIBS ${MPG123_LIBRARY})
	set(MP3_INCLUDES ${MPG123_INCLUDE_DIR})
	else(MPG123_FOUND)
	if (SDL_FOUND)
	# Try looking for libmad instead only if SDL is available
	find_package(MAD)
	if (MAD_FOUND)
	add_definitions(-DHAVE_MP3_MAD)
	set(MP3_LIBS ${MAD_LIBRARY})
	set(MP3_INCLUDES ${MAD_INCLUDE_DIR})
	else(MAD_FOUND)
	set(MP3_LIBS "")
	set(MP3_INCLUDES "")
	endif(MAD_FOUND)
	endif (SDL_FOUND)
	endif(MPG123_FOUND)

	# freetype
	if(NOT FREETYPE_FOUND)
	message(FATAL_ERROR "Couldn't find freetype")
	endif(NOT FREETYPE_FOUND)

	# -------------------------------------------------------
	# Paths and system setup
	# -------------------------------------------------------

	# -------------------------------------------------------
	# MINGW
	# -------------------------------------------------------

	if(MINGW OR CYGWIN)
	# -------------------------------------------------------
	# Take those user options and set the necessary compile time preprocessors
	# -------------------------------------------------------
	add_definitions(-DWINDOWS)
	set(WIN_LIB -lgdi32 -luser32 -lwsock32)
	set(CMAKE_THREAD_LIBS_INIT -lpthreadGC2)
	else(MINGW OR CYGWIN)
	set(CMAKE_THREAD_LIBS_INIT -lpthread)
	endif(MINGW OR CYGWIN)

	# -------------------------------------------------------
	# Apple OSX
	# -------------------------------------------------------

	if(APPLE)
	# -------------------------------------------------------
	# Added stuff for osx
	# -------------------------------------------------------
	set(WIN_LIB "-framework Carbon")
	add_definitions(-DMACOSX)

	# Groups
	set(GROUP_START "-Wl,-all_load")
	set(GROUP_END "")
	else(APPLE)
	# Groups
	set(GROUP_START "-Wl,--start-group")
	set(GROUP_END "-Wl,--end-group")
	endif(APPLE)

	# -------------------------------------------------------
	# Include directory
	# -------------------------------------------------------
	include_directories(src src/libs/hawknl src/libs/dumb/include include ${GRAPHICS_INCLUDES} ${FREETYPE_INCLUDE_DIR} ${OGG_INCLUDES} ${MP3_INCLUDES})

	# -------------------------------------------------------
	# Put the linked libraries together
	# -------------------------------------------------------
	set(REQUIRED_LIBS ${GRAPHICS_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${FREETYPE_LIBRARIES} ${PNG_LIBRARY} ${ZLIB_LIBRARY} ${OGG_LIBS} ${MP3_LIBS} ${WIN_LIB} ${WINSOCK})

	# -------------------------------------------------------
	# Source files
	# -------------------------------------------------------

	#Base Source
	add_subdirectory(${CMAKE_SOURCE_DIR}/src)

	# 7z
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/7z)

	#Dumb
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/dumb)

	#Hawknl
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/hawknl)

	#Minizip
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/zip)

	# SFL
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/sfl)

	# GME Library
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/gme)

	# PCRE
	add_subdirectory(${CMAKE_SOURCE_DIR}/src/libs/pcre)

	# Create r-tech1 library
	add_library(r-tech1 ${SFL_SRC} ${UTIL_SRC} ${PCRE_SRC} ${x7Z_SRC} ${DUMB_SRC} ${MINIZIP_SRC} ${HAWKNL_SRC} ${GME_SRC})

	# Init test
	add_executable(init-test tests/init/main.cpp)
	target_link_libraries(init-test r-tech1 ${REQUIRED_LIBS})
	+
	+# Install
	+install (TARGETS r-tech1 DESTINATION lib)
	+install (DIRECTORY ${CMAKE_SOURCE_DIR}/include/r-tech1 DESTINATION include)
	+
	+# Pkgconfig
	+if(UNIX OR LINUX OR CYGWIN OR MINGW)
	+ if(DEBUG)
	+ set(lib "r-tech1-debug")
	+ set(libs
	+ "allegro-debug-5 allegro_ttf-debug-5 allegro_memfile-debug-5 allegro_image-debug-5 allegro_primitives-debug-5 allegro_audio-debug-5 allegro_acodec-debug-5 freetype2 zlib")
	+ else(DEBUG)
	+ set(lib "r-tech1")
	+ set(libs
	+ "allegro-5 allegro_ttf-5 allegro_memfile-5 allegro_image-5 allegro_primitives-5 allegro_audio-5 allegro_acodec-5 freetype2 zlib")
	+ endif(DEBUG)
	+ set(prefix ${CMAKE_INSTALL_PREFIX})
	+ set(rtech1_version "1")
	+ configure_file(${CMAKE_SOURCE_DIR}/misc/r-tech1.pc.in ${LIBRARY_OUTPUT_PATH}/pkgconfig/${lib}.pc @ONLY)
	+ install(FILES ${LIBRARY_OUTPUT_PATH}/pkgconfig/${lib}.pc DESTINATION lib/pkgconfig)
	+endif(UNIX OR LINUX OR CYGWIN OR MINGW)
	+
	diff --git a/misc/r-tech1.pc.in b/misc/r-tech1.pc.in
	index 107ac165..0c1371ae 100644
	--- a/misc/r-tech1.pc.in
	+++ b/misc/r-tech1.pc.in
	@@ -1,14 +1,14 @@
	-prefix=%prefix%
	+prefix=@prefix@
	exec_prefix=${prefix}
	libdir=${prefix}/lib
	includedir=${prefix}/include
	-version=%rtech1_version%
	-lib=%lib%
	-libs=%libs%
	+version=@rtech1_version@
	+lib=@lib@
	+libs=@libs@

	Name: ${lib}
	Description: R-Tech1 Library Wrapper Utility
	Version: ${version}
	Libs: -L${libdir} -l${lib}
	Cflags: -I${includedir} -I${includedir}/r-tech1
	Requires: ${libs}
	diff --git a/scons_rtech1/utils.py b/scons_rtech1/utils.py
	index b6b66e8c..46604596 100644
	--- a/scons_rtech1/utils.py
	+++ b/scons_rtech1/utils.py
	@@ -1,335 +1,335 @@
	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)
	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)
	useLLVM = 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',
	+ '@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: Fri, May 15, 8:48 AM (13 h, 48 m ago)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 63893
Default Alt Text: (22 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions