env.ConfigFile(opt)
def makeTheISA(source, target, env):
- f = file(str(target[0]), 'w')
-
isas = [ src.get_contents() for src in source ]
- target = env['TARGET_ISA']
+ target_isa = env['TARGET_ISA']
def define(isa):
return isa.upper() + '_ISA'
return isa[0].upper() + isa[1:].lower() + 'ISA'
- print >>f, '#ifndef __CONFIG_THE_ISA_HH__'
- print >>f, '#define __CONFIG_THE_ISA_HH__'
- print >>f
+ code = code_formatter()
+ code('''\
+#ifndef __CONFIG_THE_ISA_HH__
+#define __CONFIG_THE_ISA_HH__
+
+''')
+
for i,isa in enumerate(isas):
- print >>f, '#define %s %d' % (define(isa), i + 1)
- print >>f
- print >>f, '#define THE_ISA %s' % (define(target))
- print >>f, '#define TheISA %s' % (namespace(target))
- print >>f
- print >>f, '#endif // __CONFIG_THE_ISA_HH__'
+ 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)
import m5.SimObject
import m5.params
+from m5.util import code_formatter
m5.SimObject.clear()
m5.params.clear()
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
_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
# 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',
# 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 *'
+ code = code_formatter()
+ code('''\
+from params import *
+from m5.SimObject import *
+''')
+
for module in source:
- print >>f, 'from %s import *' % module.get_contents()
- f.close()
+ code('from $0 import *', module.get_contents())
+ code.write(str(target[0]))
# Generate an __init__.py file for the objects package
env.Command('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()
+ 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)
# Generate all of the SimObject param struct header files
params_hh_files = []
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()
for obj in objs:
order_obj(obj)
- enums = set()
- predecls = []
- pd_seen = set()
+ code = code_formatter()
+ code('%module params')
- def add_pds(*pds):
- for pd in pds:
- if pd not in pd_seen:
- predecls.append(pd)
- pd_seen.add(pd)
+ code('%{')
+ for obj in ordered_objs:
+ code('#include "params/$obj.hh"')
+ code('%}')
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'
+ param.swig_predecls(code)
- print >>out, '%{'
+ enums = set()
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
+ params = obj._params.local.values()
+ for param in params:
+ ptype = param.ptype
+ if issubclass(ptype, m5.params.Enum) and ptype not in enums:
+ enums.add(ptype)
+ code('%include "enums/$0.hh"', ptype.__name__)
+
+ for obj in ordered_objs:
+ obj.swig_objdecls(code)
+ code()
for obj in ordered_objs:
+ continue
if obj.swig_objdecls:
- for decl in obj.swig_objdecls:
- print >>out, decl
+ obj.swig_objdecls(code)
continue
class_path = obj.cxx_class.split('::')
classname = class_path[-1]
namespaces = class_path[:-1]
- namespaces.reverse()
- code = ''
+ for ns in namespaces:
+ code('namespace $ns {')
if namespaces:
- code += '// avoid name conflicts\n'
+ code('// avoid name conflicts')
sep_string = '_COLONS_'
flat_name = sep_string.join(class_path)
- code += '%%rename(%s) %s;\n' % (flat_name, classname)
+ code('%rename($flat_name) $classname;')
- code += '// stop swig from creating/wrapping default ctor/dtor\n'
- code += '%%nodefault %s;\n' % classname
- code += 'class %s ' % classname
+ code('// stop swig from creating/wrapping default ctor/dtor')
+ code('%nodefault $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
+ code('class $classname : public ${{obj._base.cxx_class}} {};')
+ else:
+ code('class $classname {};')
- print >>out, code
+ for ns in reversed(namespaces):
+ code('/* namespace $ns */ }')
+ code()
- print >>out, '%%include "src/sim/sim_object_params.hh"' % obj
+ code('%include "src/sim/sim_object_params.hh"')
for obj in ordered_objs:
- print >>out, '%%include "params/%s.hh"' % obj
+ code('%include "params/$obj.hh"')
+
+ code.write(target[0].abspath)
params_file = File('params/params.i')
names = sorted(sim_objects.keys())
# Generate the main swig init file
def makeSwigInit(target, source, env):
- f = file(str(target[0]), 'w')
- print >>f, 'extern "C" {'
+ code = code_formatter()
+
+ code('extern "C" {')
+ code.indent()
for module in source:
- print >>f, ' void init_%s();' % module.get_contents()
- print >>f, '}'
- print >>f, 'void initSwig() {'
+ code('void init_$0();', module.get_contents())
+ code.dedent()
+ code('}')
+
+ code('void initSwig() {')
+ code.indent()
for module in source:
- print >>f, ' init_%s();' % module.get_contents()
- print >>f, '}'
- f.close()
+ code('init_$0();', module.get_contents())
+ code.dedent()
+ code('}')
+
+ code.write(str(target[0]))
env.Command('python/swig/init.cc',
map(Value, sorted(s.module for s in SwigSource.all)),
# 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
*/
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()
- print >>f, '};'
- print >>f
- print >>f, 'const int Trace::numFlagStrings = %d;' % (len(allFlags) + 1)
- print >>f
+ code('''\
+};
+
+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!
*
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
/* 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)
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.abspath, 'exec')
sym = pysource.symname
step = 16
- print >>dst, ".data"
- print >>dst, ".globl %s_beg" % sym
- print >>dst, ".globl %s_end" % sym
- print >>dst, "%s_beg:" % sym
+ code = code_formatter()
+ code('''\
+.data
+.globl ${sym}_beg
+.globl ${sym}_end
+${sym}_beg:''')
+
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)
+ bytes = ','.join([str(d) for d in x])
+ code('.byte $bytes')
+ code('${sym}_end:')
+ code('.long $0', len(marshalled))
+
+ code.write(str(target[0]))
for source in PySource.all:
env.Command(source.assembly, source.tnode, objectifyPyFile)
# 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')
+ code = code_formatter()
def dump_mod(sym, endchar=','):
def c_str(string):
if string is None:
return "0"
return '"%s"' % string
- pysource = PySource.symnames[sym]
- print >>dst, ' { %s,' % c_str(pysource.arcname)
- print >>dst, ' %s,' % c_str(pysource.abspath)
- print >>dst, ' %s,' % c_str(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)
-
- print >>dst, '#include "sim/init.hh"'
+ pysource = PySource.symnames[sym]
+ arcname = c_str(pysource.arcname)
+ abspath = c_str(pysource.abspath)
+ modpath = c_str(pysource.modpath)
+ code.indent()
+ code('''\
+{ $arcname,
+ $abspath,
+ $modpath,
+ ${sym}_beg, ${sym}_end,
+ ${sym}_end - ${sym}_beg,
+ *(int *)${sym}_end }$endchar
+''')
+ code.dedent()
+
+ code('#include "sim/init.hh"')
for sym in source:
sym = sym.get_contents()
- print >>dst, "extern const char %s_beg[], %s_end[];" % (sym, sym)
+ code('extern const char ${sym}_beg[], ${sym}_end[];')
- print >>dst, "const EmbeddedPyModule embeddedPyImporter = "
- dump_mod("PyEMB_importer", endchar=';');
- print >>dst
+ code('const EmbeddedPyModule embeddedPyImporter = ')
+ dump_mod("PyEMB_importer", endchar=';')
+ code()
- print >>dst, "const EmbeddedPyModule embeddedPyModules[] = {"
+ code('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, 0 }"
- print >>dst, "};"
+ code(' { 0, 0, 0, 0, 0, 0, 0 }')
+ code('};')
+ code.write(str(target[0]))
env.Command('sim/init_python.cc',
map(Value, (s.symname for s in PySource.all)),
# Nathan Binkert
import sys
-from types import FunctionType
+from types import FunctionType, MethodType
try:
import pydot
# dict to look up SimObjects based on path
instanceDict = {}
+def default_cxx_predecls(cls, code):
+ '''A forward class declaration is sufficient since we are
+ just declaring a pointer.'''
+
+ class_path = cls._value_dict['cxx_class'].split('::')
+ for ns in class_path[:-1]:
+ code('namespace $ns {')
+ code('class $0;', class_path[-1])
+ for ns in reversed(class_path[:-1]):
+ code('/* namespace $ns */ }')
+
+def default_swig_objdecls(cls, code):
+ class_path = cls.cxx_class.split('::')
+ classname = class_path[-1]
+ namespaces = class_path[:-1]
+
+ for ns in namespaces:
+ code('namespace $ns {')
+
+ if namespaces:
+ code('// avoid name conflicts')
+ sep_string = '_COLONS_'
+ flat_name = sep_string.join(class_path)
+ code('%rename($flat_name) $classname;')
+
+ code()
+ code('// stop swig from creating/wrapping default ctor/dtor')
+ code('%nodefault $classname;')
+ code('class $classname')
+ if cls._base:
+ code(' : public ${{cls._base.cxx_class}}')
+ code('{};')
+
+ for ns in reversed(namespaces):
+ code('/* namespace $ns */ }')
+
+def public_value(key, value):
+ return key.startswith('_') or \
+ isinstance(value, (FunctionType, MethodType, classmethod, type))
+
# The metaclass for SimObject. This class controls how new classes
# that derive from SimObject are instantiated, and provides inherited
# class behavior (just like a class controls how instances of that
init_keywords = { 'abstract' : bool,
'cxx_class' : str,
'cxx_type' : str,
- 'cxx_predecls' : list,
- 'swig_objdecls' : list,
- 'swig_predecls' : list,
+ 'cxx_predecls' : MethodType,
+ 'swig_objdecls' : MethodType,
+ 'swig_predecls' : MethodType,
'type' : str }
# Attributes that can be set any time
keywords = { 'check' : FunctionType }
cls_dict = {}
value_dict = {}
for key,val in dict.items():
- if key.startswith('_') or isinstance(val, (FunctionType,
- classmethod,
- type)):
+ if public_value(key, val):
cls_dict[key] = val
else:
# must be a param/port setting
cls._value_dict['cxx_type'] = '%s *' % cls._value_dict['cxx_class']
- if 'cxx_predecls' not in cls._value_dict:
- # A forward class declaration is sufficient since we are
- # just declaring a pointer.
- class_path = cls._value_dict['cxx_class'].split('::')
- class_path.reverse()
- decl = 'class %s;' % class_path[0]
- for ns in class_path[1:]:
- decl = 'namespace %s { %s }' % (ns, decl)
- cls._value_dict['cxx_predecls'] = [decl]
-
- if 'swig_predecls' not in cls._value_dict:
- # A forward class declaration is sufficient since we are
- # just declaring a pointer.
- cls._value_dict['swig_predecls'] = \
- cls._value_dict['cxx_predecls']
-
- if 'swig_objdecls' not in cls._value_dict:
- cls._value_dict['swig_objdecls'] = []
+ if 'cxx_predecls' not in cls.__dict__:
+ m = MethodType(default_cxx_predecls, cls, MetaSimObject)
+ setattr(cls, 'cxx_predecls', m)
+
+ if 'swig_predecls' not in cls.__dict__:
+ setattr(cls, 'swig_predecls', getattr(cls, 'cxx_predecls'))
+
+ if 'swig_objdecls' not in cls.__dict__:
+ m = MethodType(default_swig_objdecls, cls, MetaSimObject)
+ setattr(cls, 'swig_objdecls', m)
# Now process the _value_dict items. They could be defining
# new (or overriding existing) parameters or ports, setting
# instance of class cls).
def __setattr__(cls, attr, value):
# normal processing for private attributes
- if attr.startswith('_'):
+ if public_value(attr, value):
type.__setattr__(cls, attr, value)
return
def __str__(cls):
return cls.__name__
- def cxx_decl(cls):
- code = "#ifndef __PARAMS__%s\n" % cls
- code += "#define __PARAMS__%s\n\n" % cls
+ def cxx_decl(cls, code):
+ code('''\
+#ifndef __PARAMS__${cls}__
+#define __PARAMS__${cls}__
+
+''')
# The 'dict' attribute restricts us to the params declared in
# the object itself, not including inherited params (which
print params
raise
- # get a list of lists of predeclaration lines
- predecls = []
- predecls.extend(cls.cxx_predecls)
- for p in params:
- predecls.extend(p.cxx_predecls())
- # remove redundant lines
- predecls2 = []
- for pd in predecls:
- if pd not in predecls2:
- predecls2.append(pd)
- predecls2.sort()
- code += "\n".join(predecls2)
- code += "\n\n";
+ # get all predeclarations
+ cls.cxx_predecls(code)
+ for param in params:
+ param.cxx_predecls(code)
+ code()
if cls._base:
- code += '#include "params/%s.hh"\n\n' % cls._base.type
+ code('#include "params/${{cls._base.type}}.hh"')
+ code()
for ptype in ptypes:
if issubclass(ptype, Enum):
- code += '#include "enums/%s.hh"\n' % ptype.__name__
- code += "\n\n"
+ code('#include "enums/${{ptype.__name__}}.hh"')
+ code()
- code += cls.cxx_struct(cls._base, params)
+ cls.cxx_struct(code, cls._base, params)
# close #ifndef __PARAMS__* guard
- code += "\n#endif\n"
+ code()
+ code('#endif // __PARAMS__${cls}__')
return code
- def cxx_struct(cls, base, params):
+ def cxx_struct(cls, code, base, params):
if cls == SimObject:
- return '#include "sim/sim_object_params.hh"\n'
+ code('#include "sim/sim_object_params.hh"')
+ return
# now generate the actual param struct
- code = "struct %sParams" % cls
+ code("struct ${cls}Params")
if base:
- code += " : public %sParams" % base.type
- code += "\n{\n"
+ code(" : public ${{base.type}}Params")
+ code("{")
if not hasattr(cls, 'abstract') or not cls.abstract:
if 'type' in cls.__dict__:
- code += " %s create();\n" % cls.cxx_type
- decls = [p.cxx_decl() for p in params]
- decls.sort()
- code += "".join([" %s\n" % d for d in decls])
- code += "};\n"
+ code(" ${{cls.cxx_type}} create();")
- return code
+ code.indent()
+ for param in params:
+ param.cxx_decl(code)
+ code.dedent()
+ code('};')
+
+ def swig_decl(cls, code):
+ code('''\
+%module $cls
- def swig_decl(cls):
- code = '%%module %s\n' % cls
+%{
+#include "params/$cls.hh"
+%}
- code += '%{\n'
- code += '#include "params/%s.hh"\n' % cls
- code += '%}\n\n'
+''')
# The 'dict' attribute restricts us to the params declared in
# the object itself, not including inherited params (which
params = cls._params.local.values()
ptypes = [p.ptype for p in params]
- # get a list of lists of predeclaration lines
- predecls = []
- predecls.extend([ p.swig_predecls() for p in params ])
- # flatten
- predecls = reduce(lambda x,y:x+y, predecls, [])
- # remove redundant lines
- predecls2 = []
- for pd in predecls:
- if pd not in predecls2:
- predecls2.append(pd)
- predecls2.sort()
- code += "\n".join(predecls2)
- code += "\n\n";
+ # get all predeclarations
+ for param in params:
+ param.swig_predecls(code)
+ code()
if cls._base:
- code += '%%import "params/%s.i"\n\n' % cls._base.type
+ code('%import "params/${{cls._base.type}}.i"')
+ code()
for ptype in ptypes:
if issubclass(ptype, Enum):
- code += '%%import "enums/%s.hh"\n' % ptype.__name__
- code += "\n\n"
+ code('%import "enums/${{ptype.__name__}}.hh"')
+ code()
- code += '%%import "params/%s_type.hh"\n\n' % cls
- code += '%%include "params/%s.hh"\n\n' % cls
-
- return code
+ code('%import "params/${cls}_type.hh"')
+ code('%include "params/${cls}.hh"')
# The SimObject class is the root of the special hierarchy. Most of
# the code in this class deals with the configuration hierarchy itself
type = 'SimObject'
abstract = True
- swig_objdecls = [ '%include "python/swig/sim_object.i"' ]
+ @classmethod
+ def swig_objdecls(cls, code):
+ code('%include "python/swig/sim_object.i"')
# Initialize new instance. For objects with SimObject-valued
# children, we need to recursively clone the classes represented
class ParamValue(object):
__metaclass__ = MetaParamValue
- cxx_predecls = []
- swig_predecls = []
+ @classmethod
+ def cxx_predecls(cls, code):
+ pass
+
+ @classmethod
+ def swig_predecls(cls, code):
+ pass
# default for printing to .ini file is regular string conversion.
# will be overridden in some cases
return value
return self.ptype(value)
- def cxx_predecls(self):
- return self.ptype.cxx_predecls
+ def cxx_predecls(self, code):
+ self.ptype.cxx_predecls(code)
- def swig_predecls(self):
- return self.ptype.swig_predecls
+ def swig_predecls(self, code):
+ self.ptype.swig_predecls(code)
- def cxx_decl(self):
- return '%s %s;' % (self.ptype.cxx_type, self.name)
+ def cxx_decl(self, code):
+ code('${{self.ptype.cxx_type}} ${{self.name}};')
# Vector-valued parameter description. Just like ParamDesc, except
# that the value is a vector (list) of the specified type instead of a
else:
return VectorParamValue(tmp_list)
- def swig_predecls(self):
- return ['%%include "%s_vptype.i"' % self.ptype_str]
+ def swig_predecls(self, code):
+ code('%include "${{self.ptype_str}}_vptype.i"')
- def swig_decl(self):
+ def swig_decl(self, code):
cxx_type = re.sub('std::', '', self.ptype.cxx_type)
- vdecl = 'namespace std { %%template(vector_%s) vector< %s >; }' % \
- (self.ptype_str, cxx_type)
- return ['%include "std_vector.i"'] + self.ptype.swig_predecls + [vdecl]
+ code('%include "std_vector.i"')
+ self.ptype.swig_predecls(code)
+ code('''\
+namespace std {
+%template(vector_${{self.ptype_str}}) vector< $cxx_type >;
+}
+''')
- def cxx_predecls(self):
- return ['#include <vector>'] + self.ptype.cxx_predecls
+ def cxx_predecls(self, code):
+ code('#include <vector>')
+ self.ptype.cxx_predecls(code)
- def cxx_decl(self):
- return 'std::vector< %s > %s;' % (self.ptype.cxx_type, self.name)
+ def cxx_decl(self, code):
+ code('std::vector< ${{self.ptype.cxx_type}} > ${{self.name}};')
class ParamFactory(object):
def __init__(self, param_desc_class, ptype_str = None):
# built-in str class.
class String(ParamValue,str):
cxx_type = 'std::string'
- cxx_predecls = ['#include <string>']
- swig_predecls = ['%include "std_string.i"\n' +
- '%apply const std::string& {std::string *};']
- swig_predecls = ['%include "std_string.i"' ]
+
+ @classmethod
+ def cxx_predecls(self, code):
+ code('#include <string>')
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%include "std_string.i"')
def getValue(self):
return self
if name == 'CheckedInt':
return
- if not cls.cxx_predecls:
- # most derived types require this, so we just do it here once
- cls.cxx_predecls = ['#include "base/types.hh"']
-
- if not cls.swig_predecls:
- # most derived types require this, so we just do it here once
- cls.swig_predecls = ['%import "stdint.i"\n' +
- '%import "base/types.hh"']
-
if not (hasattr(cls, 'min') and hasattr(cls, 'max')):
if not (hasattr(cls, 'size') and hasattr(cls, 'unsigned')):
panic("CheckedInt subclass %s must define either\n" \
% type(value).__name__
self._check()
+ @classmethod
+ def cxx_predecls(cls, code):
+ # most derived types require this, so we just do it here once
+ code('#include "base/types.hh"')
+
+ @classmethod
+ def swig_predecls(cls, code):
+ # most derived types require this, so we just do it here once
+ code('%import "stdint.i"')
+ code('%import "base/types.hh"')
+
def getValue(self):
return long(self.value)
if name == 'Range':
return
cls.cxx_type = 'Range< %s >' % cls.type.cxx_type
- cls.cxx_predecls = \
- ['#include "base/range.hh"'] + cls.type.cxx_predecls
class Range(ParamValue):
__metaclass__ = MetaRange
def __str__(self):
return '%s:%s' % (self.first, self.second)
+ @classmethod
+ def cxx_predecls(cls, code):
+ code('#include "base/range.hh"')
+ cls.type.cxx_predecls(code)
+
class AddrRange(Range):
type = Addr
- swig_predecls = ['%include "python/swig/range.i"']
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%include "python/swig/range.i"')
def getValue(self):
from m5.objects.params import AddrRange
class TickRange(Range):
type = Tick
- swig_predecls = ['%include "python/swig/range.i"']
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%include "python/swig/range.i"')
def getValue(self):
from m5.objects.params import TickRange
class EthernetAddr(ParamValue):
cxx_type = 'Net::EthAddr'
- cxx_predecls = ['#include "base/inet.hh"']
- swig_predecls = ['%include "python/swig/inet.i"']
+
+ @classmethod
+ def cxx_predecls(cls, code):
+ code('#include "base/inet.hh"')
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%include "python/swig/inet.i"')
+
def __init__(self, value):
if value == NextEthernetAddr:
self.value = value
class Time(ParamValue):
cxx_type = 'tm'
- cxx_predecls = [ '#include <time.h>' ]
- swig_predecls = [ '%include "python/swig/time.i"' ]
+
+ @classmethod
+ def cxx_predecls(cls, code):
+ code('#include <time.h>')
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%include "python/swig/time.i"')
+
def __init__(self, value):
self.value = parse_time(value)
# Generate C++ class declaration for this enum type.
# Note that we wrap the enum in a class/struct to act as a namespace,
# so that the enum strings can be brief w/o worrying about collisions.
- def cxx_decl(cls):
+ def cxx_decl(cls, code):
name = cls.__name__
- code = "#ifndef __ENUM__%s\n" % name
- code += '#define __ENUM__%s\n' % name
- code += '\n'
- code += 'namespace Enums {\n'
- code += ' enum %s {\n' % name
+ code('''\
+#ifndef __ENUM__${name}__
+#define __ENUM__${name}__
+
+namespace Enums {
+ enum $name {
+''')
+ code.indent(2)
for val in cls.vals:
- code += ' %s = %d,\n' % (val, cls.map[val])
- code += ' Num_%s = %d,\n' % (name, len(cls.vals))
- code += ' };\n'
- code += ' extern const char *%sStrings[Num_%s];\n' % (name, name)
- code += '}\n'
- code += '\n'
- code += '#endif\n'
- return code
-
- def cxx_def(cls):
+ code('$val = ${{cls.map[val]}},')
+ code('Num_$name = ${{len(cls.vals)}},')
+ code.dedent(2)
+ code('''\
+ };
+extern const char *${name}Strings[Num_${name}];
+}
+
+#endif // __ENUM__${name}__
+''')
+
+ def cxx_def(cls, code):
name = cls.__name__
- code = '#include "enums/%s.hh"\n' % name
- code += 'namespace Enums {\n'
- code += ' const char *%sStrings[Num_%s] =\n' % (name, name)
- code += ' {\n'
+ code('''\
+#include "enums/${name}.hh"
+namespace Enums {
+ const char *${name}Strings[Num_${name}] =
+ {
+''')
+ code.indent(2)
for val in cls.vals:
- code += ' "%s",\n' % val
- code += ' };\n'
- code += '}\n'
- return code
+ code('"$val",')
+ code.dedent(2)
+ code('''
+ };
+/* namespace Enums */ }
+''')
# Base class for enum types.
class Enum(ParamValue):
class TickParamValue(NumericParamValue):
cxx_type = 'Tick'
- cxx_predecls = ['#include "base/types.hh"']
- swig_predecls = ['%import "stdint.i"\n' +
- '%import "base/types.hh"']
+
+ @classmethod
+ def cxx_predecls(cls, code):
+ code('#include "base/types.hh"')
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%import "stdint.i"')
+ code('%import "base/types.hh"')
def getValue(self):
return long(self.value)
# An explicit conversion to a Latency or Frequency must be made first.
class Clock(ParamValue):
cxx_type = 'Tick'
- cxx_predecls = ['#include "base/types.hh"']
- swig_predecls = ['%import "stdint.i"\n' +
- '%import "base/types.hh"']
+
+ @classmethod
+ def cxx_predecls(cls, code):
+ code('#include "base/types.hh"')
+
+ @classmethod
+ def swig_predecls(cls, code):
+ code('%import "stdint.i"')
+ code('%import "base/types.hh"')
+
def __init__(self, value):
if isinstance(value, (Latency, Clock)):
self.ticks = value.ticks
projects / gem5.git / commitdiff