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