From 710ed8f492aa783933df6551ff98c9a6750fd9f7 Mon Sep 17 00:00:00 2001 From: Nathan Binkert Date: Thu, 9 Sep 2010 14:15:41 -0700 Subject: scons: use code_formatter wherever we can in the build system --- src/python/m5/params.py | 200 +++++++++++++++++++++++++++++++----------------- 1 file changed, 131 insertions(+), 69 deletions(-) (limited to 'src/python/m5/params.py') diff --git a/src/python/m5/params.py b/src/python/m5/params.py index 38e320b53..00bba636b 100644 --- a/src/python/m5/params.py +++ b/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 '] + self.ptype.cxx_predecls + def cxx_predecls(self, code): + code('#include ') + 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 '] - 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 ') + + @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 ' ] - swig_predecls = [ '%include "python/swig/time.i"' ] + + @classmethod + def cxx_predecls(cls, code): + code('#include ') + + @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 + 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): @@ -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 -- cgit v1.2.3