slicc/symbols/Type.py

35     def __init__(self, symtab, ident, location, type, code, pairs,
37         super(DataMember, self).__init__(symtab, ident, location, type,
39         self.init_code = init_code
42     def __init__(self, ident, pairs):
43         super(Enumeration, self).__init__(pairs)
44         self.ident = ident
45         self.primary = False
48     def __init__(self, table, ident, location, pairs, machine=None):
49         super(Type, self).__init__(table, ident, location, pairs)
50         self.c_ident = ident
51         self.abstract_ident = ""
53             if self.isExternal or self.isPrimitive:
54                 if "external_name" in self:
55                     self.c_ident = self["external_name"]
58                 self.c_ident = "%s_%s" % (machine, ident)
60         self.pairs.setdefault("desc", "No description avaliable")
63         if "interface" in self:
64             interface = self["interface"]
66                 self["message"] = "yes"
69         if self.ident in ("CacheMemory"):
70             self["cache"] = "yes"
72         if self.ident in ("TBETable"):
73             self["tbe"] = "yes"
75         if self.ident == "TimerTable":
76             self["timer"] = "yes"
78         if self.ident == "DirectoryMemory":
79             self["dir"] = "yes"
81         if self.ident == "PersistentTable":
82             self["persistent"] = "yes"
84         if self.ident == "Prefetcher":
85             self["prefetcher"] = "yes"
87         self.isMachineType = (ident == "MachineType")
89         self.isStateDecl = ("state_decl" in self)
90         self.statePermPairs = []
92         self.data_members = OrderedDict()
93         self.methods = {}
94         self.enums = OrderedDict()
97     def isPrimitive(self):
98         return "primitive" in self
101     def isMessage(self):
102         return "message" in self
104     def isBuffer(self):
105         return "buffer" in self
107     def isInPort(self):
108         return "inport" in self
110     def isOutPort(self):
111         return "outport" in self
113     def isEnumeration(self):
114         return "enumeration" in self
116     def isExternal(self):
117         return "external" in self
119     def isGlobal(self):
120         return "global" in self
122     def isInterface(self):
123         return "interface" in self
126     def addDataMember(self, ident, type, pairs, init_code):
127         if ident in self.data_members:
130         member = DataMember(self.symtab, ident, self.location, type,
133         self.data_members[ident] = member
134         self.symtab.registerSym(ident, member)
137     def dataMemberType(self, ident):
138         return self.data_members[ident].type
140     def methodId(self, name, param_type_vec):
143     def methodIdAbstract(self, name, param_type_vec):
146     def statePermPairAdd(self, state_name, perm_name):
147         self.statePermPairs.append([state_name, perm_name])
149     def addFunc(self, func):
150         ident = self.methodId(func.ident, func.param_types)
151         if ident in self.methods:
154         self.methods[ident] = func
157     def addEnum(self, ident, pairs):
158         if ident in self.enums:
161         self.enums[ident] = Enumeration(ident, pairs)
164         if "default" not in self:
165             self["default"] = "%s_NUM" % self.c_ident
171     def checkEnum(self, ident):
172         if ident in self.enums and not self.enums[ident].primary:
173             self.enums[ident].primary = True
177     def writeCodeFiles(self, path, includes):
178         if self.isExternal:
181         elif self.isEnumeration:
182             self.printEnumHH(path)
183             self.printEnumCC(path)
186             self.printTypeHH(path)
187             self.printTypeCC(path)
189     def printTypeHH(self, path):
190         code = self.symtab.codeFormatter()
192 /** \\file ${{self.c_ident}}.hh
198 #ifndef __${{self.c_ident}}_HH__
199 #define __${{self.c_ident}}_HH__
207         for dm in self.data_members.values():
212         if "interface" in self:
213             code('#include "mem/ruby/protocol/$0.hh"', self["interface"])
214             parent = " :  public %s" % self["interface"]
217 $klass ${{self.c_ident}}$parent
220     ${{self.c_ident}}
223         if self.isMessage:
224             code('(Tick curTime) : %s(curTime) {' % self["interface"])
229         if not self.isGlobal:
231             for dm in self.data_members.values():
246         if not self.isGlobal:
247             code('${{self.c_ident}}(const ${{self.c_ident}}&other)')
250             if "interface" in self:
251                 code('    : ${{self["interface"]}}(other)')
256             for dm in self.data_members.values():
263         if not self.isGlobal:
265                        for dm in self.data_members.itervalues() ]
268             if self.isMessage:
271             code('${{self.c_ident}}($params)')
274             if "interface" in self:
275                 if self.isMessage:
276                     code('    : ${{self["interface"]}}(curTime)')
278                     code('    : ${{self["interface"]}}()')
282             for dm in self.data_members.values():
289         if self.isMessage:
294      return std::shared_ptr<Message>(new ${{self.c_ident}}(*this));
299 ${{self.c_ident}}*
302      return new ${{self.c_ident}}(*this);
306         if not self.isGlobal:
309             for dm in self.data_members.values():
323             for dm in self.data_members.values():
337             for dm in self.data_members.values():
353         for dm in self.data_members.values():
359                 if self.isGlobal:
365                     assert self.isGlobal
374         for item in self.methods:
375             proto = self.methods[item].prototype
384 operator<<(std::ostream& out, const ${{self.c_ident}}& obj)
391 #endif // __${{self.c_ident}}_HH__
394         code.write(path, "%s.hh" % self.c_ident)
396     def printTypeCC(self, path):
397         code = self.symtab.codeFormatter()
400 /** \\file ${{self.c_ident}}.cc
408 #include "mem/ruby/protocol/${{self.c_ident}}.hh"
417 ${{self.c_ident}}::print(ostream& out) const
419     out << "[${{self.c_ident}}: ";
424         for dm in self.data_members.values():
439         for item in self.methods:
440             code(self.methods[item].generateCode())
442         code.write(path, "%s.cc" % self.c_ident)
444     def printEnumHH(self, path):
445         code = self.symtab.codeFormatter()
447 /** \\file ${{self.c_ident}}.hh
452 #ifndef __${{self.c_ident}}_HH__
453 #define __${{self.c_ident}}_HH__
459         if self.isStateDecl:
462         if self.isMachineType:
472 /** \\enum ${{self.c_ident}}
473  *  \\brief ${{self.desc}}
475 enum ${{self.c_ident}} {
476     ${{self.c_ident}}_FIRST,
481         for i,(ident,enum) in enumerate(self.enums.iteritems()):
484                 init = ' = %s_FIRST' % self.c_ident
487             code('${{self.c_ident}}_${{enum.ident}}$init, /**< $desc */')
490     ${{self.c_ident}}_NUM
494 ${{self.c_ident}} string_to_${{self.c_ident}}(const std::string& str);
497 std::string ${{self.c_ident}}_to_string(const ${{self.c_ident}}& obj);
500 ${{self.c_ident}} &operator++(${{self.c_ident}} &e);
503         if self.isMachineType:
518         if self.isMachineType:
520 int ${{self.c_ident}}_base_level(const ${{self.c_ident}}& obj);
521 MachineType ${{self.c_ident}}_from_base_level(int);
522 int ${{self.c_ident}}_base_number(const ${{self.c_ident}}& obj);
523 int ${{self.c_ident}}_base_count(const ${{self.c_ident}}& obj);
526             for enum in self.enums.itervalues():
532         if self.isStateDecl:
536 AccessPermission ${{self.c_ident}}_to_permission(const ${{self.c_ident}}& obj);
542 std::ostream& operator<<(std::ostream& out, const ${{self.c_ident}}& obj);
544 #endif // __${{self.c_ident}}_HH__
547         code.write(path, "%s.hh" % self.c_ident)
549     def printEnumCC(self, path):
550         code = self.symtab.codeFormatter()
552 /** \\file ${{self.c_ident}}.hh
562 #include "mem/ruby/protocol/${{self.c_ident}}.hh"
568         if self.isStateDecl:
571 AccessPermission ${{self.c_ident}}_to_permission(const ${{self.c_ident}}& obj)
577             for statePerm in self.statePermPairs:
578                 code('  case ${{self.c_ident}}_${{statePerm[0]}}:')
583         panic("Unknown state access permission converstion for ${{self.c_ident}}");
589         if self.isMachineType:
590             for enum in self.enums.itervalues():
599 operator<<(ostream& out, const ${{self.c_ident}}& obj)
601     out << ${{self.c_ident}}_to_string(obj);
608 ${{self.c_ident}}_to_string(const ${{self.c_ident}}& obj)
615         for enum in self.enums.itervalues():
616             code('  case ${{self.c_ident}}_${{enum.ident}}:')
623         panic("Invalid range for type ${{self.c_ident}}");
628 ${{self.c_ident}}
629 string_to_${{self.c_ident}}(const string& str)
636         for enum in self.enums.itervalues():
638             code('    return ${{self.c_ident}}_${{enum.ident}};')
644         panic("Invalid string conversion for %s, type ${{self.c_ident}}", str);
649 ${{self.c_ident}}&
650 operator++(${{self.c_ident}}& e)
652     assert(e < ${{self.c_ident}}_NUM);
653     return e = ${{self.c_ident}}(e+1);
659         if self.isMachineType:
668 ${{self.c_ident}}_base_level(const ${{self.c_ident}}& obj)
675             for i,enum in enumerate(self.enums.itervalues()):
676                 code('  case ${{self.c_ident}}_${{enum.ident}}:')
682       case ${{self.c_ident}}_NUM:
683         return ${{len(self.enums)}};
686         panic("Invalid range for type ${{self.c_ident}}");
695 ${{self.c_ident}}_from_base_level(int type)
702             for i,enum in enumerate(self.enums.itervalues()):
704                 code('    return ${{self.c_ident}}_${{enum.ident}};')
710         panic("Invalid range for type ${{self.c_ident}}");
720 ${{self.c_ident}}_base_number(const ${{self.c_ident}}& obj)
728             code('  case ${{self.c_ident}}_NUM:')
729             for enum in reversed(list(self.enums.values())):
736                 code('  case ${{self.c_ident}}_${{enum.ident}}:')
742         panic("Invalid range for type ${{self.c_ident}}");
752 ${{self.c_ident}}_base_count(const ${{self.c_ident}}& obj)
758             for enum in self.enums.itervalues():
759                 code('case ${{self.c_ident}}_${{enum.ident}}:')
767       case ${{self.c_ident}}_NUM:
769         panic("Invalid range for type ${{self.c_ident}}");
774             for enum in self.enums.itervalues():
786         code.write(path, "%s.cc" % self.c_ident)