1#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
372