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