1 // THIS FILE IS GENERATED 2 // WARNING! All changes made in this file will be lost! 3 4 #ifndef cool_AST_H_INCLUDED 5 #define cool_AST_H_INCLUDED 6 7 #include "kdev-pg-list.h" 8 9 10 namespace cool 11 { 12 13 struct additive_expression_ast; 14 struct block_expression_ast; 15 struct case_condition_ast; 16 struct case_expression_ast; 17 struct class_ast; 18 struct expression_ast; 19 struct feature_ast; 20 struct formal_ast; 21 struct if_expression_ast; 22 struct let_declaration_ast; 23 struct let_expression_ast; 24 struct multiplicative_expression_ast; 25 struct postfix_expression_ast; 26 struct primary_expression_ast; 27 struct program_ast; 28 struct relational_expression_ast; 29 struct unary_expression_ast; 30 struct while_expression_ast; 31 32 33 struct ast_node 34 { 35 enum ast_node_kind_enum { 36 Kind_additive_expression = 1000, 37 Kind_block_expression = 1001, 38 Kind_case_condition = 1002, 39 Kind_case_expression = 1003, 40 Kind_class = 1004, 41 Kind_expression = 1005, 42 Kind_feature = 1006, 43 Kind_formal = 1007, 44 Kind_if_expression = 1008, 45 Kind_let_declaration = 1009, 46 Kind_let_expression = 1010, 47 Kind_multiplicative_expression = 1011, 48 Kind_postfix_expression = 1012, 49 Kind_primary_expression = 1013, 50 Kind_program = 1014, 51 Kind_relational_expression = 1015, 52 Kind_unary_expression = 1016, 53 Kind_while_expression = 1017, 54 AST_NODE_KIND_COUNT 55 }; 56 57 int kind; 58 std::size_t start_token; 59 std::size_t end_token; 60 }; 61 62 struct additive_expression_ast: public ast_node 63 { 64 enum 65 { 66 KIND = Kind_additive_expression 67 }; 68 69 const list_node<multiplicative_expression_ast *> *expression_sequence; 70 std::size_t op; 71 }; 72 73 struct block_expression_ast: public ast_node 74 { 75 enum 76 { 77 KIND = Kind_block_expression 78 }; 79 80 const list_node<expression_ast *> *expression_sequence; 81 }; 82 83 struct case_condition_ast: public ast_node 84 { 85 enum 86 { 87 KIND = Kind_case_condition 88 }; 89 90 std::size_t name; 91 std::size_t type; 92 expression_ast *expression; 93 }; 94 95 struct case_expression_ast: public ast_node 96 { 97 enum 98 { 99 KIND = Kind_case_expression 100 }; 101 102 expression_ast *expression; 103 const list_node<case_condition_ast *> *condition_sequence; 104 }; 105 106 struct class_ast: public ast_node 107 { 108 enum 109 { 110 KIND = Kind_class 111 }; 112 113 std::size_t type; 114 std::size_t base_type; 115 const list_node<feature_ast *> *feature_sequence; 116 }; 117 118 struct expression_ast: public ast_node 119 { 120 enum 121 { 122 KIND = Kind_expression 123 }; 124 125 relational_expression_ast *expression; 126 }; 127 128 struct feature_ast: public ast_node 129 { 130 enum 131 { 132 KIND = Kind_feature 133 }; 134 135 std::size_t name; 136 const list_node<formal_ast *> *formal_sequence; 137 std::size_t type; 138 expression_ast *expression; 139 }; 140 141 struct formal_ast: public ast_node 142 { 143 enum 144 { 145 KIND = Kind_formal 146 }; 147 148 std::size_t name; 149 std::size_t type; 150 }; 151 152 struct if_expression_ast: public ast_node 153 { 154 enum 155 { 156 KIND = Kind_if_expression 157 }; 158 159 expression_ast *condition; 160 expression_ast *true_expression; 161 expression_ast *false_expression; 162 }; 163 164 struct let_declaration_ast: public ast_node 165 { 166 enum 167 { 168 KIND = Kind_let_declaration 169 }; 170 171 std::size_t name; 172 std::size_t type; 173 expression_ast *expression; 174 }; 175 176 struct let_expression_ast: public ast_node 177 { 178 enum 179 { 180 KIND = Kind_let_expression 181 }; 182 183 const list_node<let_declaration_ast *> *declaration_sequence; 184 expression_ast *body_expression; 185 }; 186 187 struct multiplicative_expression_ast: public ast_node 188 { 189 enum 190 { 191 KIND = Kind_multiplicative_expression 192 }; 193 194 const list_node<postfix_expression_ast *> *expression_sequence; 195 std::size_t op; 196 }; 197 198 struct postfix_expression_ast: public ast_node 199 { 200 enum 201 { 202 KIND = Kind_postfix_expression 203 }; 204 205 unary_expression_ast *base_expression; 206 std::size_t at_type; 207 std::size_t name; 208 const list_node<expression_ast *> *arguments_sequence; 209 }; 210 211 struct primary_expression_ast: public ast_node 212 { 213 enum 214 { 215 KIND = Kind_primary_expression 216 }; 217 218 std::size_t name; 219 expression_ast *expression; 220 const list_node<expression_ast *> *argument_sequence; 221 std::size_t variable; 222 std::size_t integer_literal; 223 std::size_t string_literal; 224 std::size_t true_literal; 225 std::size_t false_literal; 226 std::size_t new_type; 227 if_expression_ast *if_expression; 228 while_expression_ast *while_expression; 229 block_expression_ast *block_expression; 230 let_expression_ast *let_expression; 231 case_expression_ast *case_expression; 232 }; 233 234 struct program_ast: public ast_node 235 { 236 enum 237 { 238 KIND = Kind_program 239 }; 240 241 const list_node<class_ast *> *klass_sequence; 242 }; 243 244 struct relational_expression_ast: public ast_node 245 { 246 enum 247 { 248 KIND = Kind_relational_expression 249 }; 250 251 const list_node<additive_expression_ast *> *expression_sequence; 252 std::size_t op; 253 }; 254 255 struct unary_expression_ast: public ast_node 256 { 257 enum 258 { 259 KIND = Kind_unary_expression 260 }; 261 262 std::size_t op; 263 primary_expression_ast *expression; 264 }; 265 266 struct while_expression_ast: public ast_node 267 { 268 enum 269 { 270 KIND = Kind_while_expression 271 }; 272 273 expression_ast *condition; 274 expression_ast *loop_expression; 275 }; 276 277 278 279 } // end of namespace cool 280 281 #endif 282 283 284