File indexing completed on 2024-05-19 08:27:44
0001 // THIS FILE IS GENERATED 0002 // WARNING! All changes made in this file will be lost! 0003 0004 #ifndef cool_AST_H_INCLUDED 0005 #define cool_AST_H_INCLUDED 0006 0007 #include "kdev-pg-list.h" 0008 0009 0010 namespace cool 0011 { 0012 0013 struct additive_expression_ast; 0014 struct block_expression_ast; 0015 struct case_condition_ast; 0016 struct case_expression_ast; 0017 struct class_ast; 0018 struct expression_ast; 0019 struct feature_ast; 0020 struct formal_ast; 0021 struct if_expression_ast; 0022 struct let_declaration_ast; 0023 struct let_expression_ast; 0024 struct multiplicative_expression_ast; 0025 struct postfix_expression_ast; 0026 struct primary_expression_ast; 0027 struct program_ast; 0028 struct relational_expression_ast; 0029 struct unary_expression_ast; 0030 struct while_expression_ast; 0031 0032 0033 struct ast_node 0034 { 0035 enum ast_node_kind_enum { 0036 Kind_additive_expression = 1000, 0037 Kind_block_expression = 1001, 0038 Kind_case_condition = 1002, 0039 Kind_case_expression = 1003, 0040 Kind_class = 1004, 0041 Kind_expression = 1005, 0042 Kind_feature = 1006, 0043 Kind_formal = 1007, 0044 Kind_if_expression = 1008, 0045 Kind_let_declaration = 1009, 0046 Kind_let_expression = 1010, 0047 Kind_multiplicative_expression = 1011, 0048 Kind_postfix_expression = 1012, 0049 Kind_primary_expression = 1013, 0050 Kind_program = 1014, 0051 Kind_relational_expression = 1015, 0052 Kind_unary_expression = 1016, 0053 Kind_while_expression = 1017, 0054 AST_NODE_KIND_COUNT 0055 }; 0056 0057 int kind; 0058 std::size_t start_token; 0059 std::size_t end_token; 0060 }; 0061 0062 struct additive_expression_ast: public ast_node 0063 { 0064 enum 0065 { 0066 KIND = Kind_additive_expression 0067 }; 0068 0069 const list_node<multiplicative_expression_ast *> *expression_sequence; 0070 std::size_t op; 0071 }; 0072 0073 struct block_expression_ast: public ast_node 0074 { 0075 enum 0076 { 0077 KIND = Kind_block_expression 0078 }; 0079 0080 const list_node<expression_ast *> *expression_sequence; 0081 }; 0082 0083 struct case_condition_ast: public ast_node 0084 { 0085 enum 0086 { 0087 KIND = Kind_case_condition 0088 }; 0089 0090 std::size_t name; 0091 std::size_t type; 0092 expression_ast *expression; 0093 }; 0094 0095 struct case_expression_ast: public ast_node 0096 { 0097 enum 0098 { 0099 KIND = Kind_case_expression 0100 }; 0101 0102 expression_ast *expression; 0103 const list_node<case_condition_ast *> *condition_sequence; 0104 }; 0105 0106 struct class_ast: public ast_node 0107 { 0108 enum 0109 { 0110 KIND = Kind_class 0111 }; 0112 0113 std::size_t type; 0114 std::size_t base_type; 0115 const list_node<feature_ast *> *feature_sequence; 0116 }; 0117 0118 struct expression_ast: public ast_node 0119 { 0120 enum 0121 { 0122 KIND = Kind_expression 0123 }; 0124 0125 relational_expression_ast *expression; 0126 }; 0127 0128 struct feature_ast: public ast_node 0129 { 0130 enum 0131 { 0132 KIND = Kind_feature 0133 }; 0134 0135 std::size_t name; 0136 const list_node<formal_ast *> *formal_sequence; 0137 std::size_t type; 0138 expression_ast *expression; 0139 }; 0140 0141 struct formal_ast: public ast_node 0142 { 0143 enum 0144 { 0145 KIND = Kind_formal 0146 }; 0147 0148 std::size_t name; 0149 std::size_t type; 0150 }; 0151 0152 struct if_expression_ast: public ast_node 0153 { 0154 enum 0155 { 0156 KIND = Kind_if_expression 0157 }; 0158 0159 expression_ast *condition; 0160 expression_ast *true_expression; 0161 expression_ast *false_expression; 0162 }; 0163 0164 struct let_declaration_ast: public ast_node 0165 { 0166 enum 0167 { 0168 KIND = Kind_let_declaration 0169 }; 0170 0171 std::size_t name; 0172 std::size_t type; 0173 expression_ast *expression; 0174 }; 0175 0176 struct let_expression_ast: public ast_node 0177 { 0178 enum 0179 { 0180 KIND = Kind_let_expression 0181 }; 0182 0183 const list_node<let_declaration_ast *> *declaration_sequence; 0184 expression_ast *body_expression; 0185 }; 0186 0187 struct multiplicative_expression_ast: public ast_node 0188 { 0189 enum 0190 { 0191 KIND = Kind_multiplicative_expression 0192 }; 0193 0194 const list_node<postfix_expression_ast *> *expression_sequence; 0195 std::size_t op; 0196 }; 0197 0198 struct postfix_expression_ast: public ast_node 0199 { 0200 enum 0201 { 0202 KIND = Kind_postfix_expression 0203 }; 0204 0205 unary_expression_ast *base_expression; 0206 std::size_t at_type; 0207 std::size_t name; 0208 const list_node<expression_ast *> *arguments_sequence; 0209 }; 0210 0211 struct primary_expression_ast: public ast_node 0212 { 0213 enum 0214 { 0215 KIND = Kind_primary_expression 0216 }; 0217 0218 std::size_t name; 0219 expression_ast *expression; 0220 const list_node<expression_ast *> *argument_sequence; 0221 std::size_t variable; 0222 std::size_t integer_literal; 0223 std::size_t string_literal; 0224 std::size_t true_literal; 0225 std::size_t false_literal; 0226 std::size_t new_type; 0227 if_expression_ast *if_expression; 0228 while_expression_ast *while_expression; 0229 block_expression_ast *block_expression; 0230 let_expression_ast *let_expression; 0231 case_expression_ast *case_expression; 0232 }; 0233 0234 struct program_ast: public ast_node 0235 { 0236 enum 0237 { 0238 KIND = Kind_program 0239 }; 0240 0241 const list_node<class_ast *> *klass_sequence; 0242 }; 0243 0244 struct relational_expression_ast: public ast_node 0245 { 0246 enum 0247 { 0248 KIND = Kind_relational_expression 0249 }; 0250 0251 const list_node<additive_expression_ast *> *expression_sequence; 0252 std::size_t op; 0253 }; 0254 0255 struct unary_expression_ast: public ast_node 0256 { 0257 enum 0258 { 0259 KIND = Kind_unary_expression 0260 }; 0261 0262 std::size_t op; 0263 primary_expression_ast *expression; 0264 }; 0265 0266 struct while_expression_ast: public ast_node 0267 { 0268 enum 0269 { 0270 KIND = Kind_while_expression 0271 }; 0272 0273 expression_ast *condition; 0274 expression_ast *loop_expression; 0275 }; 0276 0277 0278 0279 } // end of namespace cool 0280 0281 #endif 0282 0283