blob: ead5e7ae3439cd9dae94cc321c306b4e311de362 [file] [log] [blame]
Adam Lesinski282e1812014-01-23 18:17:42 -08001#ifndef AIDL_AST_H
2#define AIDL_AST_H
3
4#include <string>
5#include <vector>
6#include <set>
7#include <stdarg.h>
8#include <stdio.h>
9
10using namespace std;
11
12class Type;
13
14enum {
15 PACKAGE_PRIVATE = 0x00000000,
16 PUBLIC = 0x00000001,
17 PRIVATE = 0x00000002,
18 PROTECTED = 0x00000003,
19 SCOPE_MASK = 0x00000003,
20
21 STATIC = 0x00000010,
22 FINAL = 0x00000020,
23 ABSTRACT = 0x00000040,
24
25 OVERRIDE = 0x00000100,
26
27 ALL_MODIFIERS = 0xffffffff
28};
29
30// Write the modifiers that are set in both mod and mask
31void WriteModifiers(FILE* to, int mod, int mask);
32
33struct ClassElement
34{
35 ClassElement();
36 virtual ~ClassElement();
37
38 virtual void GatherTypes(set<Type*>* types) const = 0;
39 virtual void Write(FILE* to) = 0;
40};
41
42struct Expression
43{
44 virtual ~Expression();
45 virtual void Write(FILE* to) = 0;
46};
47
48struct LiteralExpression : public Expression
49{
50 string value;
51
52 LiteralExpression(const string& value);
53 virtual ~LiteralExpression();
54 virtual void Write(FILE* to);
55};
56
57// TODO: also escape the contents. not needed for now
58struct StringLiteralExpression : public Expression
59{
60 string value;
61
62 StringLiteralExpression(const string& value);
63 virtual ~StringLiteralExpression();
64 virtual void Write(FILE* to);
65};
66
67struct Variable : public Expression
68{
69 Type* type;
70 string name;
71 int dimension;
72
73 Variable();
74 Variable(Type* type, const string& name);
75 Variable(Type* type, const string& name, int dimension);
76 virtual ~Variable();
77
78 virtual void GatherTypes(set<Type*>* types) const;
79 void WriteDeclaration(FILE* to);
80 void Write(FILE* to);
81};
82
83struct FieldVariable : public Expression
84{
85 Expression* object;
86 Type* clazz;
87 string name;
88
89 FieldVariable(Expression* object, const string& name);
90 FieldVariable(Type* clazz, const string& name);
91 virtual ~FieldVariable();
92
93 void Write(FILE* to);
94};
95
96struct Field : public ClassElement
97{
98 string comment;
99 int modifiers;
100 Variable *variable;
101 string value;
102
103 Field();
104 Field(int modifiers, Variable* variable);
105 virtual ~Field();
106
107 virtual void GatherTypes(set<Type*>* types) const;
108 virtual void Write(FILE* to);
109};
110
111struct Statement
112{
113 virtual ~Statement();
114 virtual void Write(FILE* to) = 0;
115};
116
117struct StatementBlock : public Statement
118{
119 vector<Statement*> statements;
120
121 StatementBlock();
122 virtual ~StatementBlock();
123 virtual void Write(FILE* to);
124
125 void Add(Statement* statement);
126 void Add(Expression* expression);
127};
128
129struct ExpressionStatement : public Statement
130{
131 Expression* expression;
132
133 ExpressionStatement(Expression* expression);
134 virtual ~ExpressionStatement();
135 virtual void Write(FILE* to);
136};
137
138struct Assignment : public Expression
139{
140 Variable* lvalue;
141 Expression* rvalue;
142 Type* cast;
143
144 Assignment(Variable* lvalue, Expression* rvalue);
145 Assignment(Variable* lvalue, Expression* rvalue, Type* cast);
146 virtual ~Assignment();
147 virtual void Write(FILE* to);
148};
149
150struct MethodCall : public Expression
151{
152 Expression* obj;
153 Type* clazz;
154 string name;
155 vector<Expression*> arguments;
156 vector<string> exceptions;
157
158 MethodCall(const string& name);
159 MethodCall(const string& name, int argc, ...);
160 MethodCall(Expression* obj, const string& name);
161 MethodCall(Type* clazz, const string& name);
162 MethodCall(Expression* obj, const string& name, int argc, ...);
163 MethodCall(Type* clazz, const string& name, int argc, ...);
164 virtual ~MethodCall();
165 virtual void Write(FILE* to);
166
167private:
168 void init(int n, va_list args);
169};
170
171struct Comparison : public Expression
172{
173 Expression* lvalue;
174 string op;
175 Expression* rvalue;
176
177 Comparison(Expression* lvalue, const string& op, Expression* rvalue);
178 virtual ~Comparison();
179 virtual void Write(FILE* to);
180};
181
182struct NewExpression : public Expression
183{
184 Type* type;
185 vector<Expression*> arguments;
186
187 NewExpression(Type* type);
188 NewExpression(Type* type, int argc, ...);
189 virtual ~NewExpression();
190 virtual void Write(FILE* to);
191
192private:
193 void init(int n, va_list args);
194};
195
196struct NewArrayExpression : public Expression
197{
198 Type* type;
199 Expression* size;
200
201 NewArrayExpression(Type* type, Expression* size);
202 virtual ~NewArrayExpression();
203 virtual void Write(FILE* to);
204};
205
206struct Ternary : public Expression
207{
208 Expression* condition;
209 Expression* ifpart;
210 Expression* elsepart;
211
212 Ternary();
213 Ternary(Expression* condition, Expression* ifpart, Expression* elsepart);
214 virtual ~Ternary();
215 virtual void Write(FILE* to);
216};
217
218struct Cast : public Expression
219{
220 Type* type;
221 Expression* expression;
222
223 Cast();
224 Cast(Type* type, Expression* expression);
225 virtual ~Cast();
226 virtual void Write(FILE* to);
227};
228
229struct VariableDeclaration : public Statement
230{
231 Variable* lvalue;
232 Type* cast;
233 Expression* rvalue;
234
235 VariableDeclaration(Variable* lvalue);
236 VariableDeclaration(Variable* lvalue, Expression* rvalue, Type* cast = NULL);
237 virtual ~VariableDeclaration();
238 virtual void Write(FILE* to);
239};
240
241struct IfStatement : public Statement
242{
243 Expression* expression;
244 StatementBlock* statements;
245 IfStatement* elseif;
246
247 IfStatement();
248 virtual ~IfStatement();
249 virtual void Write(FILE* to);
250};
251
252struct ReturnStatement : public Statement
253{
254 Expression* expression;
255
256 ReturnStatement(Expression* expression);
257 virtual ~ReturnStatement();
258 virtual void Write(FILE* to);
259};
260
261struct TryStatement : public Statement
262{
263 StatementBlock* statements;
264
265 TryStatement();
266 virtual ~TryStatement();
267 virtual void Write(FILE* to);
268};
269
270struct CatchStatement : public Statement
271{
272 StatementBlock* statements;
273 Variable* exception;
274
275 CatchStatement(Variable* exception);
276 virtual ~CatchStatement();
277 virtual void Write(FILE* to);
278};
279
280struct FinallyStatement : public Statement
281{
282 StatementBlock* statements;
283
284 FinallyStatement();
285 virtual ~FinallyStatement();
286 virtual void Write(FILE* to);
287};
288
289struct Case
290{
291 vector<string> cases;
292 StatementBlock* statements;
293
294 Case();
295 Case(const string& c);
296 virtual ~Case();
297 virtual void Write(FILE* to);
298};
299
300struct SwitchStatement : public Statement
301{
302 Expression* expression;
303 vector<Case*> cases;
304
305 SwitchStatement(Expression* expression);
306 virtual ~SwitchStatement();
307 virtual void Write(FILE* to);
308};
309
310struct Break : public Statement
311{
312 Break();
313 virtual ~Break();
314 virtual void Write(FILE* to);
315};
316
317struct Method : public ClassElement
318{
319 string comment;
320 int modifiers;
321 Type* returnType;
322 size_t returnTypeDimension;
323 string name;
324 vector<Variable*> parameters;
325 vector<Type*> exceptions;
326 StatementBlock* statements;
327
328 Method();
329 virtual ~Method();
330
331 virtual void GatherTypes(set<Type*>* types) const;
332 virtual void Write(FILE* to);
333};
334
335struct Class : public ClassElement
336{
337 enum {
338 CLASS,
339 INTERFACE
340 };
341
342 string comment;
343 int modifiers;
344 int what; // CLASS or INTERFACE
345 Type* type;
346 Type* extends;
347 vector<Type*> interfaces;
348 vector<ClassElement*> elements;
349
350 Class();
351 virtual ~Class();
352
353 virtual void GatherTypes(set<Type*>* types) const;
354 virtual void Write(FILE* to);
355};
356
357struct Document
358{
359 string comment;
360 string package;
361 string originalSrc;
362 set<Type*> imports;
363 vector<Class*> classes;
364
365 Document();
366 virtual ~Document();
367
368 virtual void Write(FILE* to);
369};
370
371#endif // AIDL_AST_H