src/ast/generator-data.cc

   1 #include "generator.hh"
   2
   3 namespace ag = ast::generator;
   4
   5 const ag::Node ag::nodes[] = {
   6   {"Node", "", "The root node", {{"", ""}}},
   7
   8   {"File", "Node", "Represent a file", {
   9       {"Scope *", "scope"},
  10       {"std::string", "path"},
  11       {"std::vector<Node *> *", "decls"},
  12     }
  13   },
  14
  15   /* Types */
  16   {"Type", "Node", "Represent a type", {
  17       {"std::string", "name"},
  18       {"bool", "isConst"}
  19     }
  20   },
  21
  22   {"Number", "Type", "Represent an abstract number", {
  23       {"", ""}
  24     }
  25   },
  26
  27   {"Integer", "Number", "Represent an integer", {
  28       {"", ""}
  29     }
  30   },
  31
  32   {"Float", "Number", "Represent a float", {
  33       {"", ""}
  34     }
  35   },
  36
  37   {"Pointer", "Type", "Represent a pointer", {
  38       {"Type *", "type"},
  39       {"", ""}
  40     }
  41   },
  42
  43   {"Enum", "Type", "Represent an enum", {
  44       {"Type *", "type"},
  45       {"unsigned", "count"},
  46       /* FIXME: elements */
  47       {"", ""}
  48     }
  49   },
  50
  51   {"Array", "Type", "Represent an array", {
  52       {"Type *", "type"},
  53       {"", ""}
  54     }
  55   },
  56
  57   {"VarDecl", "Node", "Represent a variable declaration", {
  58       {"std::string", "name"},
  59       {"Type *", "type"},
  60       {"", ""}
  61     }
  62   },
  63
  64   /* Expressions */
  65   {"Exp", "Node", "Represent an abstract expression", {
  66       {"", ""}
  67     }
  68   },
  69
  70   {"AssignExp", "Exp", "Represent an assignment expression", {
  71       {"std::string", "name"},
  72       {"Exp *", "value"},
  73     }
  74   },
  75
  76   {"BinaryExp", "Exp", "Base class for binary expression", {
  77       {"Exp *", "left"},
  78       {"Exp *", "right"},
  79     }
  80   },
  81
  82   {"EqExp", "BinaryExp", "Expression `=='", {
  83       {"", ""}
  84     }
  85   },
  86
  87   {"NeqExp", "BinaryExp", "Expression `!='", {
  88       {"", ""}
  89     }
  90   },
  91
  92   {"LtExp", "BinaryExp", "Expression `<'", {
  93       {"", ""}
  94     }
  95   },
  96
  97   {"LtEqExp", "BinaryExp", "Expression `<='", {
  98       {"", ""}
  99     }
 100   },
 101
 102   {"GtExp", "BinaryExp", "Expression `>'", {
 103       {"", ""}
 104     }
 105   },
 106
 107   {"GtEqExp", "BinaryExp", "Expression `>='", {
 108       {"", ""}
 109     }
 110   },
 111
 112   {"AddExp", "BinaryExp", "Expression `+'", {
 113       {"", ""}
 114     }
 115   },
 116
 117   {"SubExp", "BinaryExp", "Expression `-'", {
 118       {"", ""}
 119     }
 120   },
 121
 122   {"MulExp", "BinaryExp", "Expression `*'", {
 123       {"", ""}
 124     }
 125   },
 126
 127   {"DivExp", "BinaryExp", "Expression `/'", {
 128       {"", ""}
 129     }
 130   },
 131
 132   {"ModExp", "BinaryExp", "Expression `%'", {
 133       {"", ""}
 134     }
 135   },
 136
 137   {"NumberExp", "Exp", "A number", {
 138       {"int", "number"}
 139     }
 140   },
 141
 142   {"IdExp", "Exp", "An identifier", {
 143       {"std::string", "name"}
 144     }
 145   },
 146
 147   /* Block */
 148   {"Block", "Node", "Represent a block with a new scope", {
 149       {"Scope *", "scope"},
 150       {"std::vector<VarDecl *> *", "varDecls"},
 151       {"std::vector<Node *> *", "instrs"},
 152       {"", ""}
 153     }
 154   },
 155
 156   /* Functions */
 157   {"Function", "Node", "Represent a function declaration", {
 158       {"std::string", "name"},
 159       {"Type *", "returnType"},
 160       {"std::vector<Type *> *", "params"},
 161       {"Block *", "block"},
 162       {"", ""}
 163     }
 164   },
 165
 166   /* 3 address decomposition */
 167   {"TmpResultExp", "Exp", "A temporary result, used for 3 address", {
 168       {"std::string", "name"}
 169     }
 170   },
 171
 172   {"LoadVar", "Node", "A temporary result, used for 3 address", {
 173       {"std::string", "name"},
 174       {"std::string", "to"}
 175     }
 176   },
 177
 178   {"StoreVar", "Node", "A temporary result, used for 3 address", {
 179       {"std::string", "name"},
 180       {"Exp *", "value"}, // must be TmpResultExp or NumberExp
 181     }
 182   },
 183
 184   {"", "", "", {{"", ""}}}
 185 };