tools/aidl/AST.h

   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