src/ast/generator-data.cc

   1 #include "generator.hh"
   2
   3 namespace ag = ast::generator;
   4
   5 const ag::Node ag::nodes[] = {
   6   {"Node", "gc", "The root node", {
   7       {"core::id_t", "nodeType"}
   8     }
   9   },
  10
  11   {"File", "Node", "Represent a file", {
  12       {"Scope *", "scope"},
  13       {"std::string", "path"},
  14       {"std::vector<Node *> *", "decls"},
  15     }
  16   },
  17
  18   {"Symbol", "Node", "Represent a symbol", {
  19       {"std::string", "name"},
  20       {"Type *", "type"},
  21       {"Address *", "address"}
  22     }
  23   },
  24
  25   {"Address", "Node", "Represent an address", {
  26       {"", ""}
  27     }
  28   },
  29
  30   {"RegisterAddress", "Address", "Represent a register address", {
  31       {"std::string", "name"}
  32     }
  33   },
  34
  35   {"MemoryAddress", "Address", "Represent a memory address", {
  36       {"std::string", "name"}
  37     }
  38   },
  39
  40   /* Types */
  41   {"Type", "Node", "Represent a type", {
  42       {"std::string", "name"}, ///< @todo remove this
  43       {"bool", "isConst"}
  44     }
  45   },
  46
  47   {"VoidType", "Type", "Represent the void type", {
  48       {"", ""}
  49     }
  50   },
  51
  52   {"NumberType", "Type", "Represent an abstract number", {
  53       {"", ""}
  54     }
  55   },
  56
  57   {"BoolType", "NumberType", "Represent a boolean value", {
  58       {"", ""}
  59     }
  60   },
  61
  62   {"IntegerType", "NumberType", "Represent an integer", {
  63       {"bool", "isSigned"},
  64       {"int", "size"}
  65     }
  66   },
  67
  68   {"FloatType", "NumberType", "Represent a float", {
  69       {"", ""}
  70     }
  71   },
  72
  73   {"DoubleType", "NumberType", "Represent a float", {
  74       {"", ""}
  75     }
  76   },
  77
  78   {"PointerType", "Type", "Represent a pointer", {
  79       {"Type *", "type"},
  80       {"", ""}
  81     }
  82   },
  83
  84   {"ReferenceType", "Type", "Represent a reference", {
  85       {"Type *", "type"},
  86       {"", ""}
  87     }
  88   },
  89
  90   {"EnumType", "Type", "Represent an enum", {
  91       {"Type *", "type"},
  92       {"unsigned", "count"},
  93       /* FIXME: elements */
  94       {"", ""}
  95     }
  96   },
  97
  98   {"ArrayType", "Type", "Represent an array", {
  99       {"Type *", "type"},
 100       {"uint16_t", "size"},
 101       {"", ""}
 102     }
 103   },
 104
 105   {"FunctionType", "Type", "Represent a function", {
 106       {"Type *", "returnType"},
 107       {"std::vector<Type *> *", "argsType"},
 108       {"", ""}
 109     }
 110   },
 111
 112   {"VarDecl", "Node", "Represent a variable declaration", {
 113       {"std::string", "name"},
 114       {"Type *", "type"},
 115       {"", ""}
 116     }
 117   },
 118
 119   /* Expressions */
 120   {"Exp", "Node", "Represent an abstract expression", {
 121       {"Type *", "type"}
 122     }
 123   },
 124
 125   {"VoidExp", "Exp", "Represent a void expression", {
 126       {"", ""}
 127     }
 128   },
 129
 130
 131   {"AssignExp", "Exp", "Represent an assignment expression", {
 132       {"Symbol *", "dest"},
 133       {"Exp *", "value"},
 134     }
 135   },
 136
 137   {"UnaryExp", "Exp", "Base class for unary expression", {
 138       {"Exp *", "exp"},
 139     }
 140   },
 141
 142   {"NegExp", "UnaryExp", "Unary expression `-'", {
 143       {"", ""}
 144     }
 145   },
 146
 147   {"BangExp", "UnaryExp", "Unary expression `!'", {
 148       {"", ""}
 149     }
 150   },
 151
 152   {"NotExp", "UnaryExp", "Unary expression `~'", {
 153       {"", ""}
 154     }
 155   },
 156
 157   {"CastExp", "UnaryExp", "A cast from exp->type to type", {
 158       {"", ""}
 159     }
 160   },
 161
 162   {"DereferenceExp", "UnaryExp", "Derefence a pointer", {
 163       {"", ""}
 164     }
 165   },
 166
 167   {"BinaryExp", "Exp", "Base class for binary expression", {
 168       {"Exp *", "left"},
 169       {"Exp *", "right"},
 170     }
 171   },
 172
 173   {"EqExp", "BinaryExp", "Expression `=='", {
 174       {"", ""}
 175     }
 176   },
 177
 178   {"NeqExp", "BinaryExp", "Expression `!='", {
 179       {"", ""}
 180     }
 181   },
 182
 183   {"LtExp", "BinaryExp", "Expression `<'", {
 184       {"", ""}
 185     }
 186   },
 187
 188   {"LtEqExp", "BinaryExp", "Expression `<='", {
 189       {"", ""}
 190     }
 191   },
 192
 193   {"GtExp", "BinaryExp", "Expression `>'", {
 194       {"", ""}
 195     }
 196   },
 197
 198   {"GtEqExp", "BinaryExp", "Expression `>='", {
 199       {"", ""}
 200     }
 201   },
 202
 203   {"AddExp", "BinaryExp", "Expression `+'", {
 204       {"", ""}
 205     }
 206   },
 207
 208   {"SubExp", "BinaryExp", "Expression `-'", {
 209       {"", ""}
 210     }
 211   },
 212
 213   {"MulExp", "BinaryExp", "Expression `*'", {
 214       {"", ""}
 215     }
 216   },
 217
 218   {"DivExp", "BinaryExp", "Expression `/'", {
 219       {"", ""}
 220     }
 221   },
 222
 223   {"ModExp", "BinaryExp", "Expression `%'", {
 224       {"", ""}
 225     }
 226   },
 227
 228   {"AndExp", "BinaryExp", "Expression `&'", {
 229       {"", ""}
 230     }
 231   },
 232
 233   {"OrExp", "BinaryExp", "Expression `|'", {
 234       {"", ""}
 235     }
 236   },
 237
 238   {"XorExp", "BinaryExp", "Expression `^'", {
 239       {"", ""}
 240     }
 241   },
 242
 243   {"AndAndExp", "BinaryExp", "Expression `&&'", {
 244       {"", ""}
 245     }
 246   },
 247
 248   {"OrOrExp", "BinaryExp", "Expression `||'", {
 249       {"", ""}
 250     }
 251   },
 252
 253   {"ShlExp", "BinaryExp", "Expression `>>'", {
 254       {"", ""}
 255     }
 256   },
 257
 258   {"AShrExp", "BinaryExp", "Expression `<<'", {
 259       {"", ""}
 260     }
 261   },
 262
 263   {"LShrExp", "BinaryExp", "Expression `<<<'", {
 264       {"", ""}
 265     }
 266   },
 267
 268   {"NumberExp", "Exp", "A number", {
 269       {"double", "number"}
 270     }
 271   },
 272
 273   {"IdExp", "Exp", "An identifier", {
 274       {"Symbol *", "symbol"}
 275     }
 276   },
 277
 278   {"CallExp", "Exp", "A call to a function", {
 279       {"std::string", "id"},
 280       {"std::vector<Exp *> *", "args"},
 281       {"FunctionType *", "ftype"}
 282     }
 283   },
 284
 285   /* Statements */
 286   {"Block", "Node", "Represent a block with a new scope", {
 287       {"Scope *", "scope"},
 288       {"std::vector<VarDecl *> *", "varDecls"},
 289       {"std::vector<Node *> *", "statements"},
 290       {"", ""}
 291     }
 292   },
 293
 294   {"EmptyStatement", "Node", "An empty statement", {
 295       {"", ""}
 296     }
 297   },
 298
 299   {"Label", "Node", "A label", {
 300       {"std::string", "name"}
 301     }
 302   },
 303
 304   {"Goto", "Node", "goto statement", {
 305       {"std::string", "label"}
 306     }
 307   },
 308
 309   {"Return", "Node", "return statement", {
 310       {"Exp *", "exp"},
 311     }
 312   },
 313
 314   {"ConditionalBranch", "Node", "Factorisation code for loops", {
 315       {"Exp *", "cond"},
 316       {"Label *", "trueLabel"},
 317       {"Label *", "falseLabel"},
 318     },
 319   },
 320
 321   {"If", "Node", "If statement", {
 322       {"ConditionalBranch *", "branch"},
 323       {"Node *", "trueBlock"},
 324       {"Node *", "falseBlock"},
 325       {"Label *", "endLabel"}
 326     },
 327   },
 328
 329   {"While", "Node", "While statement", {
 330       {"ConditionalBranch *", "branch"},
 331       {"Node *", "block"},
 332       {"Label *", "beginLabel"}
 333     },
 334   },
 335
 336   {"DoWhile", "Node", "Do while statement", {
 337       {"ConditionalBranch *", "branch"},
 338       {"Node *", "block"},
 339     },
 340   },
 341
 342   /* Functions */
 343   {"Function", "Node", "Represent a function declaration", {
 344       {"std::string", "name"},
 345       {"Type *", "returnType"},
 346       {"std::vector<VarDecl *> *", "args"},
 347       {"Scope *", "scope"},
 348       {"Block *", "block"},
 349       {"", ""}
 350     }
 351   },
 352
 353   /* 3 address decomposition */
 354   {"LoadVar", "Node", "A temporary result, used for 3 address", {
 355       {"Exp *", "from"},
 356       {"std::string", "to"}
 357     }
 358   },
 359
 360   {"StoreVar", "Node", "A temporary result, used for 3 address", {
 361       {"std::string", "name"},
 362       {"Exp *", "value"}, // must be IdExp or NumberExp
 363     }
 364   },
 365
 366   {"", "", "", {{"", ""}}}
 367 };