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 
26 enum {
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 
42 namespace android {
43 namespace aidl {
44 class CodeWriter;
45 }  // namespace aidl
46 }  // namespace android
47 
48 namespace android {
49 namespace aidl {
50 namespace java {
51 
52 class Type;
53 
54 // Write the modifiers that are set in both mod and mask
55 void WriteModifiers(CodeWriter* to, int mod, int mask);
56 
57 struct ClassElement {
58   ClassElement() = default;
59   virtual ~ClassElement() = default;
60 
61   virtual void Write(CodeWriter* to) const = 0;
62 };
63 
64 struct Expression {
65   virtual ~Expression() = default;
66   virtual void Write(CodeWriter* to) const = 0;
67 };
68 
69 struct 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
78 struct 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 
86 struct 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 
100 struct 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 
112 struct 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 
125 struct Statement {
126   virtual ~Statement() = default;
127   virtual void Write(CodeWriter* to) const = 0;
128 };
129 
130 struct 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 
141 struct ExpressionStatement : public Statement {
142   Expression* expression;
143 
144   ExpressionStatement(Expression* expression);
145   virtual ~ExpressionStatement() = default;
146   void Write(CodeWriter* to) const override;
147 };
148 
149 struct 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 
160 struct 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 
180 struct 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 
190 struct 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 
203 struct 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 
212 struct 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 
223 struct 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 
233 struct 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 
245 struct 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 
255 struct ReturnStatement : public Statement {
256   Expression* expression;
257 
258   ReturnStatement(Expression* expression);
259   virtual ~ReturnStatement() = default;
260   void Write(CodeWriter* to) const override;
261 };
262 
263 struct 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 
271 struct 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 
280 struct 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 
288 struct 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 
298 struct 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 
307 struct Break : public Statement {
308   Break() = default;
309   virtual ~Break() = default;
310   void Write(CodeWriter* to) const override;
311 };
312 
313 struct 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 
329 struct 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 
339 struct 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 
356 class 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