X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2FSConscript;h=c0718c66b742ca2ee3ef95408894a37bd25a673e;hb=f4f5d03ed211571f07f13ea9d5df0d70f3101aa3;hp=d3323f0a09a04c3f95c653e90d477ab2ce0ef5f9;hpb=30d5d95b6a7c93ccf63ae0cfcc62d17306c31eee;p=gem5.git

diff --git a/src/SConscript b/src/SConscript
index d3323f0a0..c0718c66b 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -51,6 +51,8 @@ Export('env')
 
 build_env = [(opt, env[opt]) for opt in export_vars]
 
+from m5.util import code_formatter
+
 ########################################################################
 # Code for adding source files of various types
 #
@@ -88,7 +90,7 @@ class SourceFile(object):
 
         for base in type(self).__mro__:
             if issubclass(base, SourceFile):
-                bisect.insort_right(base.all, self)       
+                base.all.append(self)
 
     def __lt__(self, other): return self.filename < other.filename
     def __le__(self, other): return self.filename <= other.filename
@@ -132,18 +134,18 @@ class PySource(SourceFile):
         modpath = '.'.join(modpath)
 
         arcpath = path + [ self.basename ]
-        debugname = self.snode.abspath
-        if not exists(debugname):
-            debugname = self.tnode.abspath
+        abspath = self.snode.abspath
+        if not exists(abspath):
+            abspath = self.tnode.abspath
 
         self.package = package
         self.modname = modname
         self.modpath = modpath
         self.arcname = joinpath(*arcpath)
-        self.debugname = debugname
+        self.abspath = abspath
         self.compiled = File(self.filename + 'c')
-        self.assembly = File(self.filename + '.s')
-        self.symname = "PyEMB_" + PySource.invalid_sym_char.sub('_', modpath)
+        self.cpp = File(self.filename + '.cc')
+        self.symname = PySource.invalid_sym_char.sub('_', modpath)
 
         PySource.modules[modpath] = self
         PySource.tnodes[self.tnode] = self
@@ -228,9 +230,6 @@ env.Append(CPPPATH=Dir('.'))
 for extra_dir in extras_dir_list:
     env.Append(CPPPATH=Dir(extra_dir))
 
-# Add a flag defining what THE_ISA should be for all compilation
-env.Append(CPPDEFINES=[('THE_ISA','%s_ISA' % env['TARGET_ISA'].upper())])
-
 # Workaround for bug in SCons version > 0.97d20071212
 # Scons bug id: 2006 M5 Bug id: 308 
 for root, dirs, files in os.walk(base_dir, topdown=True):
@@ -249,18 +248,49 @@ for root, dirs, files in os.walk(base_dir, topdown=True):
 
     if 'SConscript' in files:
         build_dir = joinpath(env['BUILDDIR'], root[len(base_dir) + 1:])
-        SConscript(joinpath(root, 'SConscript'), build_dir=build_dir)
+        SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 
 for extra_dir in extras_dir_list:
     prefix_len = len(dirname(extra_dir)) + 1
     for root, dirs, files in os.walk(extra_dir, topdown=True):
         if 'SConscript' in files:
             build_dir = joinpath(env['BUILDDIR'], root[prefix_len:])
-            SConscript(joinpath(root, 'SConscript'), build_dir=build_dir)
+            SConscript(joinpath(root, 'SConscript'), variant_dir=build_dir)
 
 for opt in export_vars:
     env.ConfigFile(opt)
 
+def makeTheISA(source, target, env):
+    isas = [ src.get_contents() for src in source ]
+    target_isa = env['TARGET_ISA']
+    def define(isa):
+        return isa.upper() + '_ISA'
+    
+    def namespace(isa):
+        return isa[0].upper() + isa[1:].lower() + 'ISA' 
+
+
+    code = code_formatter()
+    code('''\
+#ifndef __CONFIG_THE_ISA_HH__
+#define __CONFIG_THE_ISA_HH__
+
+''')
+
+    for i,isa in enumerate(isas):
+        code('#define $0 $1', define(isa), i + 1)
+
+    code('''
+
+#define THE_ISA ${{define(target_isa)}}
+#define TheISA ${{namespace(target_isa)}}
+
+#endif // __CONFIG_THE_ISA_HH__''')
+
+    code.write(str(target[0]))
+
+env.Command('config/the_isa.hh', map(Value, all_isa_list), makeTheISA)
+
 ########################################################################
 #
 # Prevent any SimObjects from being added after this point, they
@@ -317,14 +347,15 @@ class DictImporter(object):
         source = self.modules[fullname]
         if source.modname == '__init__':
             mod.__path__ = source.modpath
-        mod.__file__ = source.snode.abspath
+        mod.__file__ = source.abspath
 
-        exec file(source.snode.abspath, 'r') in mod.__dict__
+        exec file(source.abspath, 'r') in mod.__dict__
 
         return mod
 
 import m5.SimObject
 import m5.params
+from m5.util import code_formatter
 
 m5.SimObject.clear()
 m5.params.clear()
@@ -368,7 +399,7 @@ for name,obj in sorted(sim_objects.iteritems()):
 # calculate extra dependencies
 #
 module_depends = ["m5", "m5.SimObject", "m5.params"]
-depends = [ PySource.modules[dep].tnode for dep in module_depends ]
+depends = [ PySource.modules[dep].snode for dep in module_depends ]
 
 ########################################################################
 #
@@ -380,7 +411,7 @@ depends = [ PySource.modules[dep].tnode for dep in module_depends ]
 def makeDefinesPyFile(target, source, env):
     build_env, hg_info = [ x.get_contents() for x in source ]
 
-    code = m5.util.code_formatter()
+    code = code_formatter()
     code("""
 import m5.internal
 import m5.util
@@ -389,11 +420,14 @@ buildEnv = m5.util.SmartDict($build_env)
 hgRev = '$hg_info'
 
 compileDate = m5.internal.core.compileDate
-for k,v in m5.internal.core.__dict__.iteritems():
-    if k.startswith('flag_'):
-        setattr(buildEnv, k[5:], v)
+_globals = globals()
+for key,val in m5.internal.core.__dict__.iteritems():
+    if key.startswith('flag_'):
+        flag = key[5:]
+        _globals[flag] = val
+del _globals
 """)
-    code.write(str(target[0]))
+    code.write(target[0].abspath)
 
 defines_info = [ Value(build_env), Value(env['HG_INFO']) ]
 # Generate a file with all of the compile options in it
@@ -402,11 +436,11 @@ PySource('m5', 'python/m5/defines.py')
 
 # Generate python file containing info about the M5 source code
 def makeInfoPyFile(target, source, env):
-    f = file(str(target[0]), 'w')
+    code = code_formatter()
     for src in source:
         data = ''.join(file(src.srcnode().abspath, 'r').xreadlines())
-        print >>f, "%s = %s" % (src, repr(data))
-    f.close()
+        code('$src = ${{repr(data)}}')
+    code.write(str(target[0]))
 
 # Generate a file that wraps the basic top level files
 env.Command('python/m5/info.py',
@@ -414,21 +448,6 @@ env.Command('python/m5/info.py',
             makeInfoPyFile)
 PySource('m5', 'python/m5/info.py')
 
-# Generate the __init__.py file for m5.objects
-def makeObjectsInitFile(target, source, env):
-    f = file(str(target[0]), 'w')
-    print >>f, 'from params import *'
-    print >>f, 'from m5.SimObject import *'
-    for module in source:
-        print >>f, 'from %s import *' % module.get_contents()
-    f.close()
-
-# Generate an __init__.py file for the objects package
-env.Command('python/m5/objects/__init__.py',
-            map(Value, SimObject.modnames),
-            makeObjectsInitFile)
-PySource('m5.objects', 'python/m5/objects/__init__.py')
-
 ########################################################################
 #
 # Create all of the SimObject param headers and enum headers
@@ -437,43 +456,61 @@ PySource('m5.objects', 'python/m5/objects/__init__.py')
 def createSimObjectParam(target, source, env):
     assert len(target) == 1 and len(source) == 1
 
-    hh_file = file(target[0].abspath, 'w')
     name = str(source[0].get_contents())
     obj = sim_objects[name]
 
-    print >>hh_file, obj.cxx_decl()
-    hh_file.close()
+    code = code_formatter()
+    obj.cxx_decl(code)
+    code.write(target[0].abspath)
 
 def createSwigParam(target, source, env):
     assert len(target) == 1 and len(source) == 1
 
-    i_file = file(target[0].abspath, 'w')
     name = str(source[0].get_contents())
     param = all_params[name]
 
-    for line in param.swig_decl():
-        print >>i_file, line
-    i_file.close()
+    code = code_formatter()
+    code('%module(package="m5.internal") $0_${name}', param.file_ext)
+    param.swig_decl(code)
+    code.write(target[0].abspath)
 
 def createEnumStrings(target, source, env):
     assert len(target) == 1 and len(source) == 1
 
-    cc_file = file(target[0].abspath, 'w')
     name = str(source[0].get_contents())
     obj = all_enums[name]
 
-    print >>cc_file, obj.cxx_def()
-    cc_file.close()
+    code = code_formatter()
+    obj.cxx_def(code)
+    code.write(target[0].abspath)
 
 def createEnumParam(target, source, env):
     assert len(target) == 1 and len(source) == 1
 
-    hh_file = file(target[0].abspath, 'w')
     name = str(source[0].get_contents())
     obj = all_enums[name]
 
-    print >>hh_file, obj.cxx_decl()
-    hh_file.close()
+    code = code_formatter()
+    obj.cxx_decl(code)
+    code.write(target[0].abspath)
+
+def createEnumSwig(target, source, env):
+    assert len(target) == 1 and len(source) == 1
+
+    name = str(source[0].get_contents())
+    obj = all_enums[name]
+
+    code = code_formatter()
+    code('''\
+%module(package="m5.internal") enum_$name
+
+%{
+#include "enums/$name.hh"
+%}
+
+%include "enums/$name.hh"
+''')
+    code.write(target[0].abspath)
 
 # Generate all of the SimObject param struct header files
 params_hh_files = []
@@ -489,10 +526,11 @@ for name,simobj in sorted(sim_objects.iteritems()):
 # Generate any parameter header files needed
 params_i_files = []
 for name,param in all_params.iteritems():
-    i_file = File('params/%s_%s.i' % (name, param.file_ext))
+    i_file = File('python/m5/internal/%s_%s.i' % (param.file_ext, name))
     params_i_files.append(i_file)
     env.Command(i_file, Value(name), createSwigParam)
     env.Depends(i_file, depends)
+    SwigSource('m5.internal', i_file)
 
 # Generate all enum header files
 for name,enum in sorted(all_enums.iteritems()):
@@ -508,138 +546,76 @@ for name,enum in sorted(all_enums.iteritems()):
     env.Command(hh_file, Value(name), createEnumParam)
     env.Depends(hh_file, depends + extra_deps)
 
-# Build the big monolithic swigged params module (wraps all SimObject
-# param structs and enum structs)
-def buildParams(target, source, env):
-    names = [ s.get_contents() for s in source ]
-    objs = [ sim_objects[name] for name in names ]
-    out = file(target[0].abspath, 'w')
-
-    ordered_objs = []
-    obj_seen = set()
-    def order_obj(obj):
-        name = str(obj)
-        if name in obj_seen:
-            return
-
-        obj_seen.add(name)
-        if str(obj) != 'SimObject':
-            order_obj(obj.__bases__[0])
-
-        ordered_objs.append(obj)
-
-    for obj in objs:
-        order_obj(obj)
-
-    enums = set()
-    predecls = []
-    pd_seen = set()
-
-    def add_pds(*pds):
-        for pd in pds:
-            if pd not in pd_seen:
-                predecls.append(pd)
-                pd_seen.add(pd)
-
-    for obj in ordered_objs:
-        params = obj._params.local.values()
-        for param in params:
-            ptype = param.ptype
-            if issubclass(ptype, m5.params.Enum):
-                if ptype not in enums:
-                    enums.add(ptype)
-            pds = param.swig_predecls()
-            if isinstance(pds, (list, tuple)):
-                add_pds(*pds)
-            else:
-                add_pds(pds)
-
-    print >>out, '%module params'
-
-    print >>out, '%{'
-    for obj in ordered_objs:
-        print >>out, '#include "params/%s.hh"' % obj
-    print >>out, '%}'
-
-    for pd in predecls:
-        print >>out, pd
-
-    enums = list(enums)
-    enums.sort()
-    for enum in enums:
-        print >>out, '%%include "enums/%s.hh"' % enum.__name__
-    print >>out
-
-    for obj in ordered_objs:
-        if obj.swig_objdecls:
-            for decl in obj.swig_objdecls:
-                print >>out, decl
-            continue
-
-        class_path = obj.cxx_class.split('::')
-        classname = class_path[-1]
-        namespaces = class_path[:-1]
-        namespaces.reverse()
+    i_file = File('python/m5/internal/enum_%s.i' % name)
+    env.Command(i_file, Value(name), createEnumSwig)
+    env.Depends(i_file, depends + extra_deps)
+    SwigSource('m5.internal', i_file)
 
-        code = ''
-
-        if namespaces:
-            code += '// avoid name conflicts\n'
-            sep_string = '_COLONS_'
-            flat_name = sep_string.join(class_path)
-            code += '%%rename(%s) %s;\n' % (flat_name, classname)
-
-        code += '// stop swig from creating/wrapping default ctor/dtor\n'
-        code += '%%nodefault %s;\n' % classname
-        code += 'class %s ' % classname
-        if obj._base:
-            code += ': public %s' % obj._base.cxx_class
-        code += ' {};\n'
-
-        for ns in namespaces:
-            new_code = 'namespace %s {\n' % ns
-            new_code += code
-            new_code += '}\n'
-            code = new_code
-
-        print >>out, code
-
-    print >>out, '%%include "src/sim/sim_object_params.hh"' % obj
-    for obj in ordered_objs:
-        print >>out, '%%include "params/%s.hh"' % obj
-
-params_file = File('params/params.i')
-names = sorted(sim_objects.keys())
-env.Command(params_file, map(Value, names), buildParams)
-env.Depends(params_file, params_hh_files + params_i_files + depends)
-SwigSource('m5.objects', params_file)
+def buildParam(target, source, env):
+    name = source[0].get_contents()
+    obj = sim_objects[name]
+    class_path = obj.cxx_class.split('::')
+    classname = class_path[-1]
+    namespaces = class_path[:-1]
+    params = obj._params.local.values()
+
+    code = code_formatter()
+
+    code('%module(package="m5.internal") param_$name')
+    code()
+    code('%{')
+    code('#include "params/$obj.hh"')
+    for param in params:
+        param.cxx_predecls(code)
+    code('%}')
+    code()
+
+    for param in params:
+        param.swig_predecls(code)
+
+    code()
+    if obj._base:
+        code('%import "python/m5/internal/param_${{obj._base}}.i"')
+    code()
+    obj.swig_objdecls(code)
+    code()
+
+    code('%include "params/$obj.hh"')
+
+    code.write(target[0].abspath)
+
+for name in sim_objects.iterkeys():
+    params_file = File('python/m5/internal/param_%s.i' % name)
+    env.Command(params_file, Value(name), buildParam)
+    env.Depends(params_file, depends)
+    SwigSource('m5.internal', params_file)
 
+# Generate the main swig init file
+def makeEmbeddedSwigInit(target, source, env):
+    code = code_formatter()
+    module = source[0].get_contents()
+    code('''\
+#include "sim/init.hh"
+
+extern "C" {
+    void init_${module}();
+}
+
+EmbeddedSwig embed_swig_${module}(init_${module});
+''')
+    code.write(str(target[0]))
+    
 # Build all swig modules
 for swig in SwigSource.all:
     env.Command([swig.cc_source.tnode, swig.py_source.tnode], swig.tnode,
                 '$SWIG $SWIGFLAGS -outdir ${TARGETS[1].dir} '
                 '-o ${TARGETS[0]} $SOURCES')
+    init_file = 'python/swig/init_%s.cc' % swig.module
+    env.Command(init_file, Value(swig.module), makeEmbeddedSwigInit)
+    Source(init_file)
     env.Depends(swig.py_source.tnode, swig.tnode)
     env.Depends(swig.cc_source.tnode, swig.tnode)
 
-# Generate the main swig init file
-def makeSwigInit(target, source, env):
-    f = file(str(target[0]), 'w')
-    print >>f, 'extern "C" {'
-    for module in source:
-        print >>f, '    void init_%s();' % module.get_contents()
-    print >>f, '}'
-    print >>f, 'void initSwig() {'
-    for module in source:
-        print >>f, '    init_%s();' % module.get_contents()
-    print >>f, '}'
-    f.close()
-
-env.Command('python/swig/init.cc',
-            map(Value, sorted(s.module for s in SwigSource.all)),
-            makeSwigInit)
-Source('python/swig/init.cc')
-
 def getFlags(source_flags):
     flagsMap = {}
     flagsList = []
@@ -664,55 +640,61 @@ def getFlags(source_flags):
 # Generate traceflags.py
 def traceFlagsPy(target, source, env):
     assert(len(target) == 1)
+    code = code_formatter()
 
-    f = file(str(target[0]), 'w')
-   
     allFlags = getFlags(source)
 
-    print >>f, 'basic = ['
+    code('basic = [')
+    code.indent()
     for flag, compound, desc in allFlags:
         if not compound:
-            print >>f, "    '%s'," % flag
-    print >>f, "    ]"
-    print >>f
-
-    print >>f, 'compound = ['
-    print >>f, "    'All',"
+            code("'$flag',")
+    code(']')
+    code.dedent()
+    code()
+
+    code('compound = [')
+    code.indent()
+    code("'All',")
     for flag, compound, desc in allFlags:
         if compound:
-            print >>f, "    '%s'," % flag
-    print >>f, "    ]"
-    print >>f
+            code("'$flag',")
+    code("]")
+    code.dedent()
+    code()
 
-    print >>f, "all = frozenset(basic + compound)"
-    print >>f
+    code("all = frozenset(basic + compound)")
+    code()
 
-    print >>f, 'compoundMap = {'
+    code('compoundMap = {')
+    code.indent()
     all = tuple([flag for flag,compound,desc in allFlags if not compound])
-    print >>f, "    'All' : %s," % (all, )
+    code("'All' : $all,")
     for flag, compound, desc in allFlags:
         if compound:
-            print >>f, "    '%s' : %s," % (flag, compound)
-    print >>f, "    }"
-    print >>f
-
-    print >>f, 'descriptions = {'
-    print >>f, "    'All' : 'All flags',"
+            code("'$flag' : $compound,")
+    code('}')
+    code.dedent()
+    code()
+
+    code('descriptions = {')
+    code.indent()
+    code("'All' : 'All flags',")
     for flag, compound, desc in allFlags:
-        print >>f, "    '%s' : '%s'," % (flag, desc)
-    print >>f, "    }"
+        code("'$flag' : '$desc',")
+    code("}")
+    code.dedent()
 
-    f.close()
+    code.write(str(target[0]))
 
 def traceFlagsCC(target, source, env):
     assert(len(target) == 1)
 
-    f = file(str(target[0]), 'w')
-
     allFlags = getFlags(source)
+    code = code_formatter()
 
     # file header
-    print >>f, '''
+    code('''
 /*
  * DO NOT EDIT THIS FILE! Automatically generated
  */
@@ -722,70 +704,74 @@ def traceFlagsCC(target, source, env):
 using namespace Trace;
 
 const char *Trace::flagStrings[] =
-{'''
+{''')
 
+    code.indent()
     # The string array is used by SimpleEnumParam to map the strings
     # provided by the user to enum values.
     for flag, compound, desc in allFlags:
         if not compound:
-            print >>f, '    "%s",' % flag
+            code('"$flag",')
 
-    print >>f, '    "All",'
+    code('"All",')
     for flag, compound, desc in allFlags:
         if compound:
-            print >>f, '    "%s",' % flag
+            code('"$flag",')
+    code.dedent()
+
+    code('''\
+};
 
-    print >>f, '};'
-    print >>f
-    print >>f, 'const int Trace::numFlagStrings = %d;' % (len(allFlags) + 1)
-    print >>f
+const int Trace::numFlagStrings = ${{len(allFlags) + 1}};
+
+''')
 
-    #
     # Now define the individual compound flag arrays.  There is an array
     # for each compound flag listing the component base flags.
-    #
     all = tuple([flag for flag,compound,desc in allFlags if not compound])
-    print >>f, 'static const Flags AllMap[] = {'
+    code('static const Flags AllMap[] = {')
+    code.indent()
     for flag, compound, desc in allFlags:
         if not compound:
-            print >>f, "    %s," % flag
-    print >>f, '};'
-    print >>f
+            code('$flag,')
+    code.dedent()
+    code('};')
+    code()
 
     for flag, compound, desc in allFlags:
         if not compound:
             continue
-        print >>f, 'static const Flags %sMap[] = {' % flag
+        code('static const Flags ${flag}Map[] = {')
+        code.indent()
         for flag in compound:
-            print >>f, "    %s," % flag
-        print >>f, "    (Flags)-1"
-        print >>f, '};'
-        print >>f
+            code('$flag,')
+        code('(Flags)-1')
+        code.dedent()
+        code('};')
+        code()
 
-    #
     # Finally the compoundFlags[] array maps the compound flags
     # to their individual arrays/
-    #
-    print >>f, 'const Flags *Trace::compoundFlags[] ='
-    print >>f, '{'
-    print >>f, '    AllMap,'
+    code('const Flags *Trace::compoundFlags[] = {')
+    code.indent()
+    code('AllMap,')
     for flag, compound, desc in allFlags:
         if compound:
-            print >>f, '    %sMap,' % flag
+            code('${flag}Map,')
     # file trailer
-    print >>f, '};'
+    code.dedent()
+    code('};')
 
-    f.close()
+    code.write(str(target[0]))
 
 def traceFlagsHH(target, source, env):
     assert(len(target) == 1)
 
-    f = file(str(target[0]), 'w')
-
     allFlags = getFlags(source)
+    code = code_formatter()
 
     # file header boilerplate
-    print >>f, '''
+    code('''\
 /*
  * DO NOT EDIT THIS FILE!
  *
@@ -797,36 +783,41 @@ def traceFlagsHH(target, source, env):
 
 namespace Trace {
 
-enum Flags {'''
+enum Flags {''')
 
     # Generate the enum.  Base flags come first, then compound flags.
     idx = 0
+    code.indent()
     for flag, compound, desc in allFlags:
         if not compound:
-            print >>f, '    %s = %d,' % (flag, idx)
+            code('$flag = $idx,')
             idx += 1
 
     numBaseFlags = idx
-    print >>f, '    NumFlags = %d,' % idx
+    code('NumFlags = $idx,')
+    code.dedent()
+    code()
 
     # put a comment in here to separate base from compound flags
-    print >>f, '''
+    code('''
 // The remaining enum values are *not* valid indices for Trace::flags.
 // They are "compound" flags, which correspond to sets of base
-// flags, and are used by changeFlag.'''
+// flags, and are used by changeFlag.''')
 
-    print >>f, '    All = %d,' % idx
+    code.indent()
+    code('All = $idx,')
     idx += 1
     for flag, compound, desc in allFlags:
         if compound:
-            print >>f, '    %s = %d,' % (flag, idx)
+            code('$flag = $idx,')
             idx += 1
 
     numCompoundFlags = idx - numBaseFlags
-    print >>f, '    NumCompoundFlags = %d' % numCompoundFlags
+    code('NumCompoundFlags = $numCompoundFlags')
+    code.dedent()
 
     # trailer boilerplate
-    print >>f, '''\
+    code('''\
 }; // enum Flags
 
 // Array of strings for SimpleEnumParam
@@ -840,9 +831,9 @@ extern const Flags *compoundFlags[];
 /* namespace Trace */ }
 
 #endif // __BASE_TRACE_FLAGS_HH__
-'''
+''')
 
-    f.close()
+    code.write(str(target[0]))
 
 flags = map(Value, trace_flags.values())
 env.Command('base/traceflags.py', flags, traceFlagsPy)
@@ -852,90 +843,62 @@ env.Command('base/traceflags.hh', flags, traceFlagsHH)
 env.Command('base/traceflags.cc', flags, traceFlagsCC)
 Source('base/traceflags.cc')
 
-# embed python files.  All .py files that have been indicated by a
+# Embed python files.  All .py files that have been indicated by a
 # PySource() call in a SConscript need to be embedded into the M5
 # library.  To do that, we compile the file to byte code, marshal the
-# byte code, compress it, and then generate an assembly file that
-# inserts the result into the data section with symbols indicating the
-# beginning, and end (and with the size at the end)
-def objectifyPyFile(target, source, env):
+# byte code, compress it, and then generate a c++ file that
+# inserts the result into an array.
+def embedPyFile(target, source, env):
+    def c_str(string):
+        if string is None:
+            return "0"
+        return '"%s"' % string
+
     '''Action function to compile a .py into a code object, marshal
     it, compress it, and stick it into an asm file so the code appears
     as just bytes with a label in the data section'''
 
     src = file(str(source[0]), 'r').read()
-    dst = file(str(target[0]), 'w')
 
     pysource = PySource.tnodes[source[0]]
-    compiled = compile(src, pysource.debugname, 'exec')
+    compiled = compile(src, pysource.abspath, 'exec')
     marshalled = marshal.dumps(compiled)
     compressed = zlib.compress(marshalled)
     data = compressed
+    sym = pysource.symname
 
-    # Some C/C++ compilers prepend an underscore to global symbol
-    # names, so if they're going to do that, we need to prepend that
-    # leading underscore to globals in the assembly file.
-    if env['LEADING_UNDERSCORE']:
-        sym = '_' + pysource.symname
-    else:
-        sym = pysource.symname
+    code = code_formatter()
+    code('''\
+#include "sim/init.hh"
 
+namespace {
+
+const char data_${sym}[] = {
+''')
+    code.indent()
     step = 16
-    print >>dst, ".data"
-    print >>dst, ".globl %s_beg" % sym
-    print >>dst, ".globl %s_end" % sym
-    print >>dst, "%s_beg:" % sym
     for i in xrange(0, len(data), step):
         x = array.array('B', data[i:i+step])
-        print >>dst, ".byte", ','.join([str(d) for d in x])
-    print >>dst, "%s_end:" % sym
-    print >>dst, ".long %d" % len(marshalled)
-
-for source in PySource.all:
-    env.Command(source.assembly, source.tnode, objectifyPyFile)
-    Source(source.assembly)
-
-# Generate init_python.cc which creates a bunch of EmbeddedPyModule
-# structs that describe the embedded python code.  One such struct
-# contains information about the importer that python uses to get at
-# the embedded files, and then there's a list of all of the rest that
-# the importer uses to load the rest on demand.
-def pythonInit(target, source, env):
-    dst = file(str(target[0]), 'w')
-
-    def dump_mod(sym, endchar=','):
-        pysource = PySource.symnames[sym]
-        print >>dst, '    { "%s",' % pysource.arcname
-        print >>dst, '      "%s",' % pysource.modpath
-        print >>dst, '       %s_beg, %s_end,' % (sym, sym)
-        print >>dst, '       %s_end - %s_beg,' % (sym, sym)
-        print >>dst, '       *(int *)%s_end }%s'  % (sym, endchar)
+        code(''.join('%d,' % d for d in x))
+    code.dedent()
     
-    print >>dst, '#include "sim/init.hh"'
-
-    for sym in source:
-        sym = sym.get_contents()
-        print >>dst, "extern const char %s_beg[], %s_end[];" % (sym, sym)
-
-    print >>dst, "const EmbeddedPyModule embeddedPyImporter = "
-    dump_mod("PyEMB_importer", endchar=';');
-    print >>dst
-
-    print >>dst, "const EmbeddedPyModule embeddedPyModules[] = {"
-    for i,sym in enumerate(source):
-        sym = sym.get_contents()
-        if sym == "PyEMB_importer":
-            # Skip the importer since we've already exported it
-            continue
-        dump_mod(sym)
-    print >>dst, "    { 0, 0, 0, 0, 0, 0 }"
-    print >>dst, "};"
-
+    code('''};
+
+EmbeddedPython embedded_${sym}(
+    ${{c_str(pysource.arcname)}},
+    ${{c_str(pysource.abspath)}},
+    ${{c_str(pysource.modpath)}},
+    data_${sym},
+    ${{len(data)}},
+    ${{len(marshalled)}});
+
+/* namespace */ }
+''')
+    code.write(str(target[0]))
 
-env.Command('sim/init_python.cc',
-            map(Value, (s.symname for s in PySource.all)),
-            pythonInit)
-Source('sim/init_python.cc')
+for source in PySource.all:
+    env.Command(source.cpp, source.tnode, embedPyFile)
+    Source(source.cpp)
 
 ########################################################################
 #