• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  
10  using namespace std;
11  
12  class Type;
13  
14  enum {
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
31  void WriteModifiers(FILE* to, int mod, int mask);
32  
33  struct 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  
42  struct Expression
43  {
44      virtual ~Expression();
45      virtual void Write(FILE* to) = 0;
46  };
47  
48  struct 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
58  struct StringLiteralExpression : public Expression
59  {
60      string value;
61  
62      StringLiteralExpression(const string& value);
63      virtual ~StringLiteralExpression();
64      virtual void Write(FILE* to);
65  };
66  
67  struct 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  
83  struct 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  
96  struct 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  
111  struct Statement
112  {
113      virtual ~Statement();
114      virtual void Write(FILE* to) = 0;
115  };
116  
117  struct 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  
129  struct ExpressionStatement : public Statement
130  {
131      Expression* expression;
132  
133      ExpressionStatement(Expression* expression);
134      virtual ~ExpressionStatement();
135      virtual void Write(FILE* to);
136  };
137  
138  struct 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  
150  struct 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  
167  private:
168      void init(int n, va_list args);
169  };
170  
171  struct 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  
182  struct 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  
192  private:
193      void init(int n, va_list args);
194  };
195  
196  struct 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  
206  struct 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  
218  struct 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  
229  struct 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  
241  struct 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  
252  struct ReturnStatement : public Statement
253  {
254      Expression* expression;
255  
256      ReturnStatement(Expression* expression);
257      virtual ~ReturnStatement();
258      virtual void Write(FILE* to);
259  };
260  
261  struct TryStatement : public Statement
262  {
263      StatementBlock* statements;
264  
265      TryStatement();
266      virtual ~TryStatement();
267      virtual void Write(FILE* to);
268  };
269  
270  struct 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  
280  struct FinallyStatement : public Statement
281  {
282      StatementBlock* statements;
283  
284      FinallyStatement();
285      virtual ~FinallyStatement();
286      virtual void Write(FILE* to);
287  };
288  
289  struct 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  
300  struct 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  
310  struct Break : public Statement
311  {
312      Break();
313      virtual ~Break();
314      virtual void Write(FILE* to);
315  };
316  
317  struct 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  
335  struct 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  
357  struct 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