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