ast_java.h revision f76b59aeac2ce35e954c15c676e9102777ec8faa 
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