mirror of
https://github.com/elua/elua.git
synced 2025-01-08 20:56:17 +08:00
c1d27e76ee
- automatically searches for compatible toolchain (and checks that it at least runs) - running "scons -h" now shows descriptions of command line options and enumerates valid values - caches last specifically requested configuration More to come...
467 lines
18 KiB
Python
467 lines
18 KiB
Python
import os, sys, shutil, string
|
|
|
|
|
|
# Helper: "normalize" a name to make it a suitable C macro name
|
|
def cnorm( name ):
|
|
name = name.replace( '-', '' )
|
|
name = name.replace( ' ', '' )
|
|
return name.upper()
|
|
|
|
# List of toolchains
|
|
toolchain_list = {
|
|
'arm-gcc' : {
|
|
'compile' : 'arm-elf-gcc',
|
|
'link' : 'arm-elf-ld',
|
|
'asm' : 'arm-elf-as',
|
|
'bin' : 'arm-elf-objcopy',
|
|
'size' : 'arm-elf-size',
|
|
'cross_cpumode' : 'little',
|
|
'cross_lua' : 'float_arm 64',
|
|
'cross_lualong' : 'int 32'
|
|
},
|
|
'arm-eabi-gcc' : {
|
|
'compile' : 'arm-eabi-gcc',
|
|
'link' : 'arm-eabi-ld',
|
|
'asm' : 'arm-eabi-as',
|
|
'bin' : 'arm-eabi-objcopy',
|
|
'size' : 'arm-eabi-size',
|
|
'cross_cpumode' : 'little',
|
|
'cross_lua' : 'float 64',
|
|
'cross_lualong' : 'int 32'
|
|
},
|
|
'codesourcery' : {
|
|
'compile' : 'arm-none-eabi-gcc',
|
|
'link' : 'arm-none-eabi-ld',
|
|
'asm' : 'arm-none-eabi-as',
|
|
'bin' : 'arm-none-eabi-objcopy',
|
|
'size' : 'arm-none-eabi-size',
|
|
'cross_cpumode' : 'little',
|
|
'cross_lua' : 'float 64',
|
|
'cross_lualong' : 'int 32'
|
|
},
|
|
'avr32-gcc' : {
|
|
'compile' : 'avr32-gcc',
|
|
'link' : 'avr32-ld',
|
|
'asm' : 'avr32-as',
|
|
'bin' : 'avr32-objcopy',
|
|
'size' : 'avr32-size',
|
|
'cross_cpumode' : 'big',
|
|
'cross_lua' : 'float 64',
|
|
'cross_lualong' : 'int 32'
|
|
},
|
|
'i686-gcc' : {
|
|
'compile' : 'i686-elf-gcc',
|
|
'link' : 'i686-elf-ld',
|
|
'asm' : 'nasm',
|
|
'bin' : 'i686-elf-objcopy',
|
|
'size' : 'i686-elf-size',
|
|
'cross_cpumode' : 'little',
|
|
'cross_lua' : 'float 64',
|
|
'cross_lualong' : 'int 32'
|
|
}
|
|
}
|
|
|
|
# Toolchain Aliases
|
|
toolchain_list['devkitarm'] = toolchain_list['arm-eabi-gcc']
|
|
|
|
# List of platform/CPU/toolchains combinations
|
|
# The first toolchain in the toolchains list is the default one
|
|
# (the one that will be used if none is specified)
|
|
platform_list = {
|
|
'at91sam7x' : { 'cpus' : [ 'AT91SAM7X256', 'AT91SAM7X512' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'lm3s' : { 'cpus' : [ 'LM3S8962', 'LM3S6965', 'LM3S6918', 'LM3S9B92' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'str9' : { 'cpus' : [ 'STR912FAW44' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'i386' : { 'cpus' : [ 'I386' ], 'toolchains' : [ 'i686-gcc' ] },
|
|
'sim' : { 'cpus' : [ 'LINUX' ], 'toolchains' : [ 'i686-gcc' ] },
|
|
'lpc288x' : { 'cpus' : [ 'LPC2888' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'str7' : { 'cpus' : [ 'STR711FR2' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'stm32' : { 'cpus' : [ 'STM32F103ZE', 'STM32F103RE' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'avr32' : { 'cpus' : [ 'AT32UC3A0512' ], 'toolchains' : [ 'avr32-gcc' ] },
|
|
'lpc24xx' : { 'cpus' : [ 'LPC2468' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] },
|
|
'lpc17xx' : { 'cpus' : [ 'LPC1768' ], 'toolchains' : [ 'arm-gcc', 'codesourcery', 'devkitarm', 'arm-eabi-gcc' ] }
|
|
}
|
|
|
|
# List of board/CPU combinations
|
|
board_list = { 'SAM7-EX256' : [ 'AT91SAM7X256', 'AT91SAM7X512' ],
|
|
'EK-LM3S8962' : [ 'LM3S8962' ],
|
|
'EK-LM3S6965' : [ 'LM3S6965' ],
|
|
'EK-LM3S9B92' : [ 'LM3S9B92' ],
|
|
'STR9-COMSTICK' : [ 'STR912FAW44' ],
|
|
'STR-E912' : [ 'STR912FAW44' ],
|
|
'PC' : [ 'I386' ],
|
|
'SIM' : [ 'LINUX' ],
|
|
'LPC-H2888' : [ 'LPC2888' ],
|
|
'MOD711' : [ 'STR711FR2' ],
|
|
'STM3210E-EVAL' : [ 'STM32F103ZE' ],
|
|
'ATEVK1100' : [ 'AT32UC3A0512' ],
|
|
'ET-STM32' : [ 'STM32F103RE' ],
|
|
'EAGLE-100' : [ 'LM3S6918' ],
|
|
'ELUA-PUC' : ['LPC2468' ],
|
|
'MBED' : ['LPC1768']
|
|
}
|
|
|
|
cpu_list = sum([board_list[i] for i in board_list],[])
|
|
|
|
|
|
# ROMFS file list "groups"
|
|
# To include a file in a ROMFS build, include it in a group here (or create one
|
|
# if you need) and make sure the group is included on your platform's file_list
|
|
# definition (right after this).
|
|
romfs = { 'bisect' : [ 'bisect.lua' ],
|
|
'hangman' : [ 'hangman.lua' ],
|
|
'lhttpd' : [ 'index.pht', 'lhttpd.lua', 'test.lua' ],
|
|
'led' : [ 'led.lua' ],
|
|
'piano' : [ 'piano.lua' ],
|
|
'pwmled' : [ 'pwmled.lua' ],
|
|
'tvbgone' : [ 'tvbgone.lua', 'codes.bin' ],
|
|
'hello' : [ 'hello.lua' ],
|
|
'info' : [ 'info.lua' ],
|
|
'morse' : [ 'morse.lua' ],
|
|
'dualpwm' : [ 'dualpwm.lua' ],
|
|
'adcscope' : [ 'adcscope.lua' ],
|
|
'adcpoll' : [ 'adcpoll.lua' ],
|
|
'life' : [ 'life.lua' ],
|
|
'logo' : ['logo.lua', 'logo.bin' ],
|
|
'pong' : [ 'pong.lua' ],
|
|
'spaceship' : [ 'spaceship.lua' ],
|
|
'tetrives' : [ 'tetrives.lua' ],
|
|
'snake' : [ 'snake.lua' ]
|
|
}
|
|
|
|
# List of board/romfs data combinations
|
|
file_list = { 'SAM7-EX256' : [ 'bisect', 'hangman' , 'led', 'piano', 'hello', 'info', 'morse' ],
|
|
'EK-LM3S8962' : [ 'bisect', 'hangman', 'pong', 'led', 'piano', 'pwmled', 'hello', 'info', 'morse', 'adcscope', 'adcpoll', 'logo', 'tetrives' ],
|
|
'EK-LM3S6965' : [ 'bisect', 'hangman', 'pong', 'led', 'piano', 'pwmled', 'hello', 'info', 'morse', 'adcscope', 'adcpoll', 'logo', 'tetrives' ],
|
|
'EK-LM3S9B92' : [ 'bisect', 'hangman', 'led', 'pwmled', 'hello', 'info', 'adcscope','adcpoll', 'life' ],
|
|
'STR9-COMSTICK' : [ 'bisect', 'hangman', 'led', 'hello', 'info' ],
|
|
'STR-E912' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'piano' ],
|
|
'PC' : [ 'bisect', 'hello', 'info', 'life', 'hangman' ],
|
|
'SIM' : [ 'bisect', 'hello', 'info', 'life', 'hangman' ],
|
|
'LPC-H2888' : [ 'bisect', 'hangman', 'led', 'hello', 'info' ],
|
|
'MOD711' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'dualpwm' ],
|
|
'STM3210E-EVAL' : [ 'bisect', 'hello', 'info' ],
|
|
'ATEVK1100' : [ 'bisect', 'hangman', 'led', 'hello', 'info' ],
|
|
'ET-STM32' : [ 'hello', 'hangman', 'info', 'bisect','adcscope','adcpoll', 'dualpwm', 'pwmled' ],
|
|
'EAGLE-100' : [ 'bisect', 'hangman', 'lhttpd', 'led', 'hello', 'info' ],
|
|
'ELUA-PUC' : [ 'bisect', 'hangman', 'led', 'hello', 'info', 'pwmled' ],
|
|
'MBED' : [ 'bisect', 'hangman', 'hello', 'info', 'led', 'pwmled', 'dualpwm', 'life' ],
|
|
}
|
|
|
|
comp = Environment( OBJSUFFIX = ".o", PROGSUFFIX = ".elf", ENV = os.environ )
|
|
|
|
# Replacement for standard EnumVariable functionality to derive case from original list
|
|
class InsensitiveString(object):
|
|
def __init__(self, s):
|
|
self.s = s
|
|
def __cmp__(self, other):
|
|
return cmp(self.s.lower(), other.lower())
|
|
|
|
def _validator(key, val, env, vals):
|
|
if not val in vals:
|
|
raise SCons.Errors.UserError(
|
|
'Invalid value for option %s: %s' % (key, val))
|
|
|
|
def MatchEnumVariable(key, help, default, allowed_values, map={}):
|
|
help = '%s (%s)' % (help, string.join(allowed_values, '|'))
|
|
|
|
validator = lambda key, val, env, vals=allowed_values: \
|
|
_validator(key, InsensitiveString(val), env, vals)
|
|
|
|
converter = lambda val, map=map: \
|
|
map.get(val, allowed_values[allowed_values.index(InsensitiveString(val))])
|
|
|
|
return (key, help, default, validator, converter)
|
|
|
|
|
|
# Add Configurable Variables
|
|
vars = Variables('build-setup.conf')
|
|
|
|
vars.Add(MatchEnumVariable('target',
|
|
'build "regular" float lua or integer-only "lualong"',
|
|
'lua',
|
|
allowed_values = ['lua','lualong']))
|
|
|
|
vars.Add(MatchEnumVariable('cpu',
|
|
'build for the specified CPU (board will be inferred, if possible)',
|
|
'auto',
|
|
allowed_values = cpu_list + ['auto']))
|
|
|
|
vars.Add(MatchEnumVariable('allocator',
|
|
'select memory allocator',
|
|
'auto',
|
|
allowed_values=['newlib','multiple','simple','auto']))
|
|
|
|
vars.Add(MatchEnumVariable('board',
|
|
'selects board for target (cpu will be inferred)',
|
|
'auto',
|
|
allowed_values=board_list.keys() + ['auto']))
|
|
|
|
vars.Add(MatchEnumVariable('toolchain',
|
|
'specifies toolchain to use (if unset, will scan for working, compatible toolchain',
|
|
'auto',
|
|
allowed_values=toolchain_list.keys() + ['auto']))
|
|
|
|
vars.Add(BoolVariable('optram',
|
|
'enables Lua Tiny RAM enhancements',
|
|
True))
|
|
|
|
vars.Add(MatchEnumVariable('boot',
|
|
'boot mode, standard will boot to shell, luarpc boots to an rpc server',
|
|
'standard',
|
|
allowed_values=['standard','luarpc']))
|
|
|
|
vars.Add(MatchEnumVariable('romfs',
|
|
'ROMFS compilation mode',
|
|
'verbatim',
|
|
allowed_values=['verbatim', 'compress', 'compiled']))
|
|
|
|
|
|
vars.Update(comp)
|
|
Help(vars.GenerateHelpText(comp))
|
|
vars.Save('build-setup.conf', comp)
|
|
|
|
# target = ARGUMENTS.get( 'target', 'lua' ).lower()
|
|
# cputype = ARGUMENTS.get( 'cpu', '' ).upper()
|
|
# allocator = ARGUMENTS.get( 'allocator', '' ).lower()
|
|
# board = ARGUMENTS.get( 'board' , '').upper()
|
|
# toolchain = ARGUMENTS.get( 'toolchain', '')
|
|
# optram = int( ARGUMENTS.get( 'optram', '1' ) )
|
|
# boot = ARGUMENTS.get( 'boot', '').lower()
|
|
# romfsmode = ARGUMENTS.get( 'romfs', 'verbatim' ).lower()
|
|
|
|
if not GetOption( 'help' ):
|
|
|
|
conf = Configure(comp)
|
|
|
|
# Variants: board = <board>
|
|
# cpu = <cpuname>
|
|
# board = <board> cpu=<cpuname>
|
|
if comp['board'] == 'auto' and comp['cpu'] == 'auto':
|
|
print "Must specifiy board, cpu, or both"
|
|
Exit( -1 )
|
|
elif comp['board'] != 'auto' and comp['cpu'] != 'auto':
|
|
# board = <board> cpu=<cpuname>
|
|
# Check if the board, cpu pair is correct
|
|
if not board_list.has_key( comp['board'] ):
|
|
print "Unknown board", comp['board']
|
|
Exit( -1 )
|
|
if not comp['cpu'] in board_list[ comp['board'] ]:
|
|
print "Invalid CPU %s for board %s" % ( comp['cpu'], comp['board'] )
|
|
Exit( -1 )
|
|
elif comp['board'] != 'auto':
|
|
# board = <board>
|
|
# Find CPU
|
|
if not board_list.has_key( comp['board'] ):
|
|
print "Unknown board", comp['board']
|
|
Exit( -1 )
|
|
comp['cpu'] = board_list[ comp['board'] ][ 0 ]
|
|
else:
|
|
# cpu = <cputype>
|
|
# Find board name
|
|
for b, v in board_list.items():
|
|
if comp['cpu'] in v:
|
|
comp['board'] = b
|
|
break
|
|
else:
|
|
print "CPU %s not found" % comp['cpu']
|
|
Exit( -1 )
|
|
|
|
# Look for the given CPU in the list of platforms
|
|
platform = None
|
|
for p, v in platform_list.items():
|
|
if comp['cpu'] in v[ 'cpus' ]:
|
|
platform = p
|
|
break
|
|
else:
|
|
print "Unknown CPU %s" % comp['cpu']
|
|
print "List of accepted CPUs: "
|
|
for p, v in platform_list.items():
|
|
print " ", p, "-->",
|
|
for cpu in v[ 'cpus' ]:
|
|
print cpu,
|
|
print
|
|
sys.exit( -1 )
|
|
|
|
# Check the toolchain
|
|
if comp['toolchain'] != 'auto':
|
|
if not comp['toolchain'] in platform_list[ platform ][ 'toolchains' ]:
|
|
print "Invalid toolchain '%s' for CPU '%s'" % ( comp['toolchain'], comp['cpu'] )
|
|
Exit( -1 )
|
|
toolset = toolchain_list[ comp['toolchain'] ]
|
|
else:
|
|
for toolchain in platform_list[ platform ]['toolchains']:
|
|
comp['CC'] = toolchain_list[ toolchain ][ 'compile' ]
|
|
if conf.CheckCC():
|
|
comp['toolchain'] = toolchain
|
|
toolset = toolchain_list[ comp['toolchain'] ]
|
|
break
|
|
|
|
if comp['toolchain'] == 'auto':
|
|
print "No available, compatible toolchain found"
|
|
Exit( -1 )
|
|
|
|
|
|
# CPU/allocator mapping (if allocator not specified)
|
|
if comp['allocator'] == 'auto':
|
|
if comp['board'] in ['LPC-H2888', 'ATEVK1100', 'MBED']:
|
|
comp['allocator'] = 'multiple'
|
|
else:
|
|
comp['allocator'] = 'newlib'
|
|
elif comp['allocator'] not in [ 'newlib', 'multiple', 'simple' ]:
|
|
print "Unknown allocator", comp['allocator']
|
|
print "Allocator can be either 'newlib', 'multiple' or 'simple'"
|
|
Exit( -1 )
|
|
|
|
# Check boot mode selection
|
|
## if comp['boot'] not in ['standard', 'luarpc']:
|
|
## print "Unknown boot mode: ", comp['boot']
|
|
## print "Boot mode can be either 'standard' or 'luarpc'"
|
|
## Exit( -1 );
|
|
|
|
# Check romfs mode
|
|
if comp['romfs'] not in ['verbatim', 'compile', 'compress']:
|
|
print "Unknown romfs mode: ", comp['romfs']
|
|
print "romfs mode can be either 'verbatim', 'compile' or 'compress'"
|
|
Exit( -1 )
|
|
|
|
# Build the compilation command now
|
|
compcmd = ''
|
|
if comp['romfs'] == 'compile':
|
|
# First check for luac.cross in the current directory
|
|
if not os.path.isfile( "luac.cross" ):
|
|
print "The eLua cross compiler was not found."
|
|
print "Build it by running 'scons -f cross-lua.py'"
|
|
Exit( -1 )
|
|
compcmd = os.path.join( os.getcwd(), 'luac.cross -ccn %s -cce %s -o %%s -s %%s' % ( toolset[ 'cross_%s' % target ], toolset[ 'cross_cpumode' ] ) )
|
|
elif comp['romfs'] == 'compress':
|
|
compcmd = 'lua luasrcdiet.lua --quiet --maximum --opt-comments --opt-whitespace --opt-emptylines --opt-eols --opt-strings --opt-numbers --opt-locals -o %s %s'
|
|
|
|
# User report
|
|
if not GetOption( 'clean' ):
|
|
print
|
|
print "*********************************"
|
|
print "Compiling eLua ..."
|
|
print "CPU: ", comp['cpu']
|
|
print "Board: ", comp['board']
|
|
print "Platform: ", platform
|
|
print "Allocator: ", comp['allocator']
|
|
print "Boot Mode: ", comp['boot']
|
|
print "Target: ", comp['target']
|
|
print "Toolchain: ", comp['toolchain']
|
|
print "ROMFS mode: ", comp['romfs']
|
|
print "*********************************"
|
|
print
|
|
|
|
output = 'elua_' + comp['target'] + '_' + comp['cpu'].lower()
|
|
cdefs = '-DELUA_CPU=%s -DELUA_BOARD=%s -DELUA_PLATFORM=%s -D__BUFSIZ__=128' % ( comp['cpu'], comp['board'], platform.upper() )
|
|
# Also make the above into direct defines (to use in conditional C code)
|
|
cdefs = cdefs + " -DELUA_CPU_%s -DELUA_BOARD_%s -DELUA_PLATFORM_%s" % ( cnorm( comp['cpu'] ), cnorm( comp['board'] ), cnorm( platform ) )
|
|
if comp['allocator'] == 'multiple':
|
|
cdefs = cdefs + " -DUSE_MULTIPLE_ALLOCATOR"
|
|
elif comp['allocator'] == 'simple':
|
|
cdefs = cdefs + " -DUSE_SIMPLE_ALLOCATOR"
|
|
|
|
if comp['boot'] == 'luarpc':
|
|
cdefs += " -DELUA_BOOT_RPC"
|
|
|
|
# Special macro definitions for the SYM target
|
|
if platform == 'sim':
|
|
cdefs = cdefs + " -DELUA_SIMULATOR -DELUA_SIM_%s" % comp['cpu']
|
|
|
|
# Lua source files and include path
|
|
lua_files = """lapi.c lcode.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c lmem.c lobject.c lopcodes.c
|
|
lparser.c lstate.c lstring.c ltable.c ltm.c lundump.c lvm.c lzio.c lauxlib.c lbaselib.c
|
|
ldblib.c liolib.c lmathlib.c loslib.c ltablib.c lstrlib.c loadlib.c linit.c lua.c lrotable.c legc.c"""
|
|
if comp['target'] == 'lualong' or comp['target'] == 'lua':
|
|
lua_full_files = " " + " ".join( [ "src/lua/%s" % name for name in lua_files.split() ] )
|
|
local_include = ['inc', 'inc/newlib', 'inc/remotefs', 'src/lua']
|
|
if comp['target'] == 'lualong':
|
|
cdefs = cdefs + ' -DLUA_NUMBER_INTEGRAL'
|
|
else:
|
|
print "Invalid target", comp['target']
|
|
Exit( 1 )
|
|
|
|
local_include += ['src/modules', 'src/platform/%s' % platform]
|
|
cdefs = cdefs + " -DLUA_OPTIMIZE_MEMORY=%d" % ( comp['optram'] != 0 and 2 or 0 )
|
|
|
|
# Additional libraries
|
|
local_libs = ''
|
|
|
|
# Application files
|
|
app_files = " src/main.c src/romfs.c src/semifs.c src/xmodem.c src/shell.c src/term.c src/common.c src/buf.c src/elua_adc.c src/dlmalloc.c src/salloc.c src/luarpc_elua_uart.c "
|
|
|
|
# Newlib related files
|
|
newlib_files = " src/newlib/devman.c src/newlib/stubs.c src/newlib/genstd.c src/newlib/stdtcp.c"
|
|
|
|
# UIP files
|
|
uip_files = "uip_arp.c uip.c uiplib.c dhcpc.c psock.c resolv.c"
|
|
uip_files = " src/elua_uip.c " + " ".join( [ "src/uip/%s" % name for name in uip_files.split() ] )
|
|
local_include += ['src/uip']
|
|
|
|
# FatFs files
|
|
app_files = app_files + "src/elua_mmc.c src/mmcfs.c src/fatfs/ff.c src/fatfs/ccsbcs.c "
|
|
local_include += ['src/fatfs']
|
|
|
|
# Lua module files
|
|
module_names = "pio.c spi.c tmr.c pd.c uart.c term.c pwm.c lpack.c bit.c net.c cpu.c adc.c can.c luarpc.c bitarray.c elua.c"
|
|
module_files = " " + " ".join( [ "src/modules/%s" % name for name in module_names.split() ] )
|
|
|
|
# Remote file system files
|
|
rfs_names = "remotefs.c client.c elua_os_io.c elua_rfs.c"
|
|
rfs_files = " " + " ".join( [ "src/remotefs/%s" % name for name in rfs_names.split() ] )
|
|
|
|
# Optimizer flags (speed or size)
|
|
#opt = "-O3"
|
|
opt = "-Os -fomit-frame-pointer"
|
|
#opt += " -ffreestanding"
|
|
#opt += " -fconserve-stack" # conserve stack at potential speed cost, >=GCC4.4
|
|
|
|
# Toolset data (filled by each platform in part)
|
|
tools = {}
|
|
|
|
# We get platform-specific data by executing the platform script
|
|
execfile( "src/platform/%s/conf.py" % platform )
|
|
|
|
# Complete file list
|
|
source_files = app_files + specific_files + newlib_files + uip_files + lua_full_files + module_files + rfs_files
|
|
|
|
# Env for building the program
|
|
comp['CCCOM'] = tools[ platform ][ 'cccom' ]
|
|
comp['ASCOM'] = tools[ platform ][ 'ascom' ]
|
|
comp['LINKCOM'] = tools[ platform ][ 'linkcom' ]
|
|
comp['CPPPATH'] = local_include
|
|
|
|
comp = conf.Finish()
|
|
|
|
# Make ROM File System first
|
|
if not GetOption( 'clean' ):
|
|
print "Building ROM File System..."
|
|
romdir = "romfs"
|
|
flist = []
|
|
for sample in file_list[ comp['board'] ]:
|
|
flist += romfs[ sample ]
|
|
# Automatically includes the autorun.lua file in the ROMFS
|
|
if os.path.isfile( os.path.join( romdir, 'autorun.lua' ) ):
|
|
flist += [ 'autorun.lua' ]
|
|
# Automatically includes platform specific Lua module
|
|
if os.path.isfile( os.path.join( romdir, comp['board'] + '.lua' ) ):
|
|
flist += [comp['board'] + '.lua']
|
|
import mkfs
|
|
mkfs.mkfs( romdir, "romfiles", flist, comp['romfs'], compcmd )
|
|
print
|
|
if os.path.exists( "inc/romfiles.h" ):
|
|
os.remove( "inc/romfiles.h" )
|
|
shutil.move( "romfiles.h", "inc/" )
|
|
if os.path.exists( "src/fs.o" ):
|
|
os.remove( "src/fs.o" )
|
|
|
|
# comp.TargetSignatures( 'content' )
|
|
# comp.SourceSignatures( 'MD5' )
|
|
comp[ 'INCPREFIX' ] = "-I"
|
|
Default( comp.Program( target = output, source = Split( source_files ) ) )
|
|
Decider( 'MD5-timestamp' )
|
|
|
|
# Programming target
|
|
prog = Environment( BUILDERS = { 'program' : Builder( action = Action ( tools[ platform ][ 'progfunc' ] ) ) }, ENV = os.environ )
|
|
prog.program( "prog", output + ".elf" )
|