scons: use code_formatter wherever we can in the build system

src/python/m5/SimObject.py

@@ -29,7 +29,7 @@
 #          Nathan Binkert
 
 import sys
-from types import FunctionType
+from types import FunctionType, MethodType
 
 try:
     import pydot
@@ -97,6 +97,46 @@ allClasses = {}
 # 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
@@ -106,9 +146,9 @@ class MetaSimObject(type):
     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 }
@@ -127,9 +167,7 @@ class MetaSimObject(type):
         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
@@ -190,24 +228,16 @@ class MetaSimObject(type):
 
             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 'cxx_predecls' not in cls.__dict__:
+                m = MethodType(default_cxx_predecls, cls, MetaSimObject)
+                setattr(cls, 'cxx_predecls', m)
 
-            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_predecls' not in cls.__dict__:
+                setattr(cls, 'swig_predecls', getattr(cls, 'cxx_predecls'))
 
-        if 'swig_objdecls' not in cls._value_dict:
-            cls._value_dict['swig_objdecls'] = []
+        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
@@ -282,7 +312,7 @@ class MetaSimObject(type):
     # 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
 
@@ -328,9 +358,12 @@ class MetaSimObject(type):
     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
@@ -344,59 +377,57 @@ class MetaSimObject(type):
             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 = '%%module %s\n' % cls
+    def swig_decl(cls, code):
+        code('''\
+%module $cls
 
-        code += '%{\n'
-        code += '#include "params/%s.hh"\n' % cls
-        code += '%}\n\n'
+%{
+#include "params/$cls.hh"
+%}
+
+''')
 
         # The 'dict' attribute restricts us to the params declared in
         # the object itself, not including inherited params (which
@@ -405,32 +436,22 @@ class MetaSimObject(type):
         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
@@ -442,7 +463,9 @@ class SimObject(object):
     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

src/python/m5/params.py

@@ -80,8 +80,13 @@ class MetaParamValue(type):
 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
@@ -152,14 +157,14 @@ class ParamDesc(object):
             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
@@ -235,20 +240,25 @@ class VectorParamDesc(ParamDesc):
         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):
@@ -291,10 +301,14 @@ VectorParam = ParamFactory(VectorParamDesc)
 # 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
@@ -350,15 +364,6 @@ class CheckedIntType(MetaParamValue):
         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" \
@@ -393,6 +398,17 @@ class CheckedInt(NumericParamValue):
                   % 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)
 
@@ -476,8 +492,6 @@ class MetaRange(MetaParamValue):
         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
@@ -521,9 +535,17 @@ class Range(ParamValue):
     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
@@ -535,7 +557,10 @@ class AddrRange(Range):
 
 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
@@ -589,8 +614,15 @@ def NextEthernetAddr():
 
 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
@@ -661,8 +693,15 @@ def parse_time(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)
 
@@ -749,34 +788,44 @@ class MetaEnum(MetaParamValue):
     # 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
-        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
+        code('''\
+#ifndef __ENUM__${name}__
+#define __ENUM__${name}__
 
-    def cxx_def(cls):
-        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'
+namespace Enums {
+    enum $name {
+''')
+        code.indent(2)
         for val in cls.vals:
-            code += '        "%s",\n' % val
-        code += '    };\n'
-        code += '}\n'
-        return code
+            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/${name}.hh"
+namespace Enums {
+    const char *${name}Strings[Num_${name}] =
+    {
+''')
+        code.indent(2)
+        for val in cls.vals:
+            code('"$val",')
+        code.dedent(2)
+        code('''
+    };
+/* namespace Enums */ }
+''')
 
 # Base class for enum types.
 class Enum(ParamValue):
@@ -800,9 +849,15 @@ frequency_tolerance = 0.001  # 0.1%
 
 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)
@@ -878,9 +933,16 @@ class Frequency(TickParamValue):
 # 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