src/xlat-i/xi-Template.C

   1 #include "xi-AstNode.h"
   2 #include "xi-Chare.h"
   3 #include "xi-Template.h"
   4
   5 namespace xi {
   6
   7 TParamList::TParamList(TParam* t, TParamList* n) : tparam(t), next(n) {}
   8
   9 TParamType::TParamType(Type* t) : type(t) {}
  10 void TParamType::print(XStr& str) { type->print(str); }
  11 void TParamType::genSpec(XStr& str) { type->print(str); }
  12
  13 TParamVal::TParamVal(const char* v) : val(v) {}
  14 void TParamVal::print(XStr& str) { str << val; }
  15 void TParamVal::genSpec(XStr& str) { str << val; }
  16
  17 Scope::Scope(const char* name, ConstructList* contents)
  18     : name_(name), ConstructList(-1, NULL, contents) {}
  19
  20 void Scope::genDecls(XStr& str) {
  21   str << "namespace " << name_ << " {\n";
  22   AstChildren<Construct>::genDecls(str);
  23   str << "} // namespace " << name_ << "\n";
  24 }
  25
  26 void Scope::genDefs(XStr& str) {
  27   str << "namespace " << name_ << " {\n";
  28   AstChildren<Construct>::genDefs(str);
  29   str << "} // namespace " << name_ << "\n";
  30 }
  31
  32 void Scope::genReg(XStr& str) {
  33   str << "using namespace " << name_ << ";\n";
  34   AstChildren<Construct>::genReg(str);
  35 }
  36
  37 void Scope::genGlobalCode(XStr scope, XStr& decls, XStr& defs) {
  38   scope << name_ << "::";
  39   AstChildren<Construct>::genGlobalCode(scope, decls, defs);
  40 }
  41
  42 void Scope::print(XStr& str) {
  43   str << "namespace " << name_ << "{\n";
  44   AstChildren<Construct>::print(str);
  45   str << "} // namespace " << name_ << "\n";
  46 }
  47
  48 void Scope::outputClosuresDecl(XStr& str) {
  49   str << "namespace " << name_ << " {\n";
  50   AstChildren<Construct>::outputClosuresDecl(str);
  51   str << "} // namespace " << name_ << "\n";
  52 }
  53
  54 void Scope::outputClosuresDef(XStr& str) {
  55   str << "namespace " << name_ << " {\n";
  56   AstChildren<Construct>::outputClosuresDef(str);
  57   str << "} // namespace " << name_ << "\n";
  58 }
  59
  60 UsingScope::UsingScope(const char* name, bool symbol) : name_(name), symbol_(symbol) {}
  61 void UsingScope::genDecls(XStr& str) {
  62   str << "using ";
  63   if (!symbol_) str << "namespace ";
  64   str << name_ << ";\n";
  65 }
  66 void UsingScope::print(XStr& str) {
  67   str << "using ";
  68   if (!symbol_) str << "namespace ";
  69   str << name_ << ";\n";
  70 }
  71
  72 void TEntity::setTemplate(Template* t) { templat = t; }
  73 XStr TEntity::tspec(bool printDefault) const {
  74   XStr str;
  75   if (templat) templat->genSpec(str, printDefault);
  76   return str;
  77 }
  78 XStr TEntity::tvars(void) const {
  79   XStr str;
  80   if (templat) templat->genVars(str);
  81   return str;
  82 }
  83
  84 TType::TType(Type* t, Type* i) : type(t), init(i) {}
  85
  86 TTypeEllipsis::TTypeEllipsis(NamedEllipsisType* t, Type* i) : type(t), init(i) {}
  87
  88 TFunc::TFunc(FuncType* t, const char* v) : type(t), init(v) {}
  89 void TFunc::print(XStr& str) {
  90   type->print(str);
  91   if (init) str << "=" << init;
  92 }
  93 void TFunc::genLong(XStr& str, bool printDefault) {
  94   type->print(str);
  95   if (init && printDefault) str << "=" << init;
  96 }
  97 void TFunc::genShort(XStr& str) { str << type->getBaseName(); }
  98
  99 TName::TName(Type* t, const char* n, const char* v) : type(t), name(n), val(v) {}
 100
 101 TVarList::TVarList(TVar* v, TVarList* n) : tvar(v), next(n) {}
 102
 103 void Template::outputClosuresDecl(XStr& str) {
 104   Chare* c = dynamic_cast<Chare*>(entity);
 105   if (c) str << c->closuresDecl;
 106 }
 107
 108 void Template::outputClosuresDef(XStr& str) {
 109   Chare* c = dynamic_cast<Chare*>(entity);
 110   if (c) str << c->closuresDef;
 111 }
 112
 113 void Template::setExtern(int e) {
 114   Construct::setExtern(e);
 115   entity->setExtern(e);
 116 }
 117
 118 void Template::genVars(XStr& str) {
 119   str << " <";
 120   if (tspec) tspec->genShort(str);
 121   str << "> ";
 122 }
 123
 124 void Template::genSpec(XStr& str, bool printDefault) {
 125   str << generateTemplateSpec(tspec, printDefault);
 126 }
 127
 128 void Template::genDecls(XStr& str) {
 129   if (!external && entity) {
 130     entity->genDecls(str);
 131   }
 132 }
 133
 134 void Template::genDefs(XStr& str) {
 135   if (!external && entity) entity->genDefs(str);
 136 }
 137
 138 void Template::genGlobalCode(XStr scope, XStr& decls, XStr& defs) {
 139   if (!external && entity) entity->genGlobalCode(scope, decls, defs);
 140 }
 141
 142 int Template::genAccels_spe_c_funcBodies(XStr& str) {
 143   int rtn = 0;
 144   if (!external && entity) {
 145     rtn += entity->genAccels_spe_c_funcBodies(str);
 146   }
 147   return rtn;
 148 }
 149
 150 void Template::genAccels_spe_c_regFuncs(XStr& str) {
 151   if (!external && entity) {
 152     entity->genAccels_spe_c_regFuncs(str);
 153   }
 154 }
 155
 156 void Template::genAccels_spe_c_callInits(XStr& str) {
 157   if (!external && entity) {
 158     entity->genAccels_spe_c_callInits(str);
 159   }
 160 }
 161
 162 void Template::genAccels_spe_h_includes(XStr& str) {
 163   if (!external && entity) {
 164     entity->genAccels_spe_h_includes(str);
 165   }
 166 }
 167
 168 void Template::genAccels_spe_h_fiCountDefs(XStr& str) {
 169   if (!external && entity) {
 170     entity->genAccels_spe_h_fiCountDefs(str);
 171   }
 172 }
 173
 174 void Template::genAccels_ppe_c_regFuncs(XStr& str) {
 175   if (!external && entity) {
 176     entity->genAccels_ppe_c_regFuncs(str);
 177   }
 178 }
 179
 180 void Template::preprocess() {
 181   if (entity) entity->preprocess();
 182 }
 183
 184 void Template::check() {
 185   if (entity) entity->check();
 186 }
 187
 188 void TVarList::genLong(XStr& str, bool printDefault) {
 189   if (tvar) tvar->genLong(str, printDefault);
 190   if (next) {
 191     str << ", ";
 192     next->genLong(str, printDefault);
 193   }
 194 }
 195
 196 void TVarList::genShort(XStr& str) {
 197   if (tvar) tvar->genShort(str);
 198   if (next) {
 199     str << ", ";
 200     next->genShort(str);
 201   }
 202 }
 203
 204 void TType::genLong(XStr& str, bool printDefault) {
 205   str << "class ";
 206   if (type) type->print(str);
 207   if (init && printDefault) {
 208     str << "=";
 209     init->print(str);
 210   }
 211 }
 212
 213 void TType::genShort(XStr& str) {
 214   if (type) type->print(str);
 215 }
 216
 217 void TTypeEllipsis::genLong(XStr& str, bool printDefault) {
 218   str << "class... ";
 219   if (type) type->printWithoutEllipsis(str);
 220   if (init && printDefault) {
 221     str << "=";
 222     init->print(str);
 223   }
 224 }
 225
 226 void TTypeEllipsis::genShort(XStr& str) {
 227   if (type) type->print(str);
 228 }
 229
 230 void TName::genLong(XStr& str, bool printDefault) {
 231   if (type) type->print(str);
 232   str << " " << name;
 233   if (val && printDefault) {
 234     str << "=" << val;
 235   }
 236 }
 237
 238 void TName::genShort(XStr& str) { str << name; }
 239
 240 void TParamList::genSpec(XStr& str) {
 241   if (tparam) tparam->genSpec(str);
 242   if (next) {
 243     str << ", ";
 244     next->genSpec(str);
 245   }
 246 }
 247
 248 void TParamList::print(XStr& str) {
 249   if (tparam) tparam->print(str);
 250   if (next) {
 251     str << ",";
 252     next->print(str);
 253   }
 254 }
 255
 256 std::string TParamList::to_string() {
 257   XStr s;
 258   print(s);
 259   return s.get_string();
 260 }
 261
 262 void TType::print(XStr& str) {
 263   str << "class ";
 264   type->print(str);
 265   if (init) {
 266     str << "=";
 267     init->print(str);
 268   }
 269 }
 270
 271 void TTypeEllipsis::print(XStr& str) {
 272   str << "class... ";
 273   type->printWithoutEllipsis(str);
 274   if (init) {
 275     str << "=";
 276     init->print(str);
 277   }
 278 }
 279
 280 void TName::print(XStr& str) {
 281   type->print(str);
 282   str << " " << name;
 283   if (val) {
 284     str << "=";
 285     str << val;
 286   }
 287 }
 288
 289 void TVarList::print(XStr& str) {
 290   tvar->print(str);
 291   if (next) {
 292     str << ", ";
 293     next->print(str);
 294   }
 295 }
 296
 297 void Template::print(XStr& str) {
 298   if (entity) entity->print(str);
 299 }
 300
 301 }  // namespace xi