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_CPP_H_
18 #define AIDL_AST_CPP_H_
19 
20 #include <memory>
21 #include <string>
22 #include <vector>
23 
24 #include <android-base/macros.h>
25 
26 namespace android {
27 namespace aidl {
28 class CodeWriter;
29 }  // namespace aidl
30 }  // namespace android
31 
32 namespace android {
33 namespace aidl {
34 namespace cpp {
35 
36 class AstNode {
37  public:
38   AstNode() = default;
39   virtual ~AstNode() = default;
40   virtual void Write(CodeWriter* to) const = 0;
41 };  // class AstNode
42 
43 class Declaration : public AstNode {
44  public:
45   Declaration() = default;
46   virtual ~Declaration() = default;
47 
48  private:
49   DISALLOW_COPY_AND_ASSIGN(Declaration);
50 };  // class Declaration
51 
52 class ClassDecl : public Declaration {
53  public:
54   ClassDecl(const std::string& name,
55             const std::string& parent);
56   ClassDecl(const std::string& name,
57             const std::string& parent,
58             std::vector<std::unique_ptr<Declaration>> public_members,
59             std::vector<std::unique_ptr<Declaration>> private_members);
60   virtual ~ClassDecl() = default;
61 
62   void Write(CodeWriter* to) const override;
63 
64   void AddPublic(std::unique_ptr<Declaration> member);
65   void AddPrivate(std::unique_ptr<Declaration> member);
66 
67  private:
68   std::string name_;
69   std::string parent_;
70   std::vector<std::unique_ptr<Declaration>> public_members_;
71   std::vector<std::unique_ptr<Declaration>> private_members_;
72 
73   DISALLOW_COPY_AND_ASSIGN(ClassDecl);
74 };  // class ClassDecl
75 
76 class Enum : public Declaration {
77  public:
78   Enum(const std::string& name, const std::string& base_type);
79   explicit Enum(const std::string& name);
80   virtual ~Enum() = default;
81 
HasValues()82   bool HasValues() const { return !fields_.empty(); }
83   void Write(CodeWriter* to) const override;
84 
85   void AddValue(const std::string& key, const std::string& value);
86 
87  private:
88   struct EnumField {
89     EnumField(const std::string& k, const std::string& v);
90     const std::string key;
91     const std::string value;
92   };
93 
94   std::string enum_name_;
95   std::string underlying_type_;
96   std::vector<EnumField> fields_;
97 
98   DISALLOW_COPY_AND_ASSIGN(Enum);
99 };  // class Enum
100 
101 class ArgList : public AstNode {
102  public:
103   ArgList() = default;
104   explicit ArgList(const std::string& single_argument);
105   explicit ArgList(const std::vector<std::string>& arg_list);
106   explicit ArgList(std::vector<std::unique_ptr<AstNode>> arg_list);
107   ArgList(ArgList&& arg_list);
108   virtual ~ArgList() = default;
109 
110   void Write(CodeWriter* to) const override;
111 
112  private:
113   std::vector<std::unique_ptr<AstNode>> arguments_;
114 
115   DISALLOW_COPY_AND_ASSIGN(ArgList);
116 };  // class ArgList
117 
118 class ConstructorDecl : public Declaration {
119  public:
120   enum Modifiers {
121     IS_VIRTUAL = 1 << 0,
122     IS_DEFAULT = 1 << 1,
123     IS_EXPLICIT = 1 << 2,
124   };
125 
126   ConstructorDecl(const std::string& name,
127                   ArgList&& arg_list);
128   ConstructorDecl(const std::string& name,
129                   ArgList&& arg_list,
130                   uint32_t modifiers);
131 
132   virtual ~ConstructorDecl() = default;
133 
134   void Write(CodeWriter* to) const override;
135 
136  private:
137   const std::string name_;
138   const ArgList arguments_;
139   const uint32_t modifiers_;
140 
141   DISALLOW_COPY_AND_ASSIGN(ConstructorDecl);
142 };  // class ConstructorDecl
143 
144 class MethodDecl : public Declaration {
145  public:
146   enum Modifiers {
147     IS_CONST = 1 << 0,
148     IS_VIRTUAL = 1 << 1,
149     IS_OVERRIDE = 1 << 2,
150     IS_PURE_VIRTUAL = 1 << 3,
151   };
152 
153   MethodDecl(const std::string& return_type,
154              const std::string& name,
155              ArgList&& arg_list);
156   MethodDecl(const std::string& return_type,
157              const std::string& name,
158              ArgList&& arg_list,
159              uint32_t modifiers);
160   virtual ~MethodDecl() = default;
161 
162   void Write(CodeWriter* to) const override;
163 
164  private:
165   const std::string return_type_;
166   const std::string name_;
167   const ArgList arguments_;
168   bool is_const_ = false;
169   bool is_virtual_ = false;
170   bool is_override_ = false;
171   bool is_pure_virtual_ = false;
172 
173   DISALLOW_COPY_AND_ASSIGN(MethodDecl);
174 };  // class MethodDecl
175 
176 class StatementBlock : public Declaration {
177  public:
178   StatementBlock() = default;
179   virtual ~StatementBlock() = default;
180 
181   void AddStatement(std::unique_ptr<AstNode> statement);
182   void AddStatement(AstNode* statement);  // Takes ownership
183   void AddLiteral(const std::string& expression, bool add_semicolon = true);
Empty()184   bool Empty() const { return statements_.empty(); }
185 
186   void Write(CodeWriter* to) const override;
187 
188  private:
189   std::vector<std::unique_ptr<AstNode>> statements_;
190 
191   DISALLOW_COPY_AND_ASSIGN(StatementBlock);
192 };  // class StatementBlock
193 
194 class ConstructorImpl : public Declaration {
195  public:
196   ConstructorImpl(const std::string& class_name,
197                   ArgList&& arg_list,
198                   const std::vector<std::string>& initializer_list);
199   virtual ~ConstructorImpl() = default;
200 
201   void Write(CodeWriter* to) const override;
202 
203  private:
204   std::string class_name_;
205   ArgList arguments_;
206   std::vector<std::string> initializer_list_;
207   StatementBlock body_;
208 
209   DISALLOW_COPY_AND_ASSIGN(ConstructorImpl);
210 };  // class ConstructorImpl
211 
212 class MethodImpl : public Declaration {
213  public:
214   // Passing an empty class name causes the method to be declared as a normal
215   // function (ie. no ClassName:: qualifier).
216   MethodImpl(const std::string& return_type,
217              const std::string& class_name,
218              const std::string& method_name,
219              ArgList&& arg_list,
220              bool is_const_method = false);
221   virtual ~MethodImpl() = default;
222 
223   // MethodImpl retains ownership of the statement block.
224   StatementBlock* GetStatementBlock();
225 
226   void Write(CodeWriter* to) const override;
227 
228  private:
229   std::string return_type_;
230   std::string method_name_;
231   const ArgList arguments_;
232   StatementBlock statements_;
233   bool is_const_method_ = false;
234 
235   DISALLOW_COPY_AND_ASSIGN(MethodImpl);
236 };  // class MethodImpl
237 
238 class SwitchStatement : public AstNode {
239  public:
240   explicit SwitchStatement(const std::string& expression);
241   virtual ~SwitchStatement() = default;
242 
243   // Add a case statement and return a pointer code block corresponding
244   // to the case.  The switch statement will add a break statement
245   // after the code block by default to prevent accidental fall-through.
246   // Returns nullptr on duplicate value expressions (by strcmp, not value
247   // equivalence).
248   StatementBlock* AddCase(const std::string& value_expression);
249   void Write(CodeWriter* to) const override;
250 
251  private:
252   const std::string switch_expression_;
253   std::vector<std::string> case_values_;
254   std::vector<std::unique_ptr<StatementBlock>> case_logic_;
255 
256   DISALLOW_COPY_AND_ASSIGN(SwitchStatement);
257 };  // class SwitchStatement
258 
259 class Assignment : public AstNode {
260  public:
261   Assignment(const std::string& left, const std::string& right);
262   Assignment(const std::string& left, AstNode* right);
263   ~Assignment() = default;
264   void Write(CodeWriter* to) const override;
265 
266  private:
267   const std::string lhs_;
268   std::unique_ptr<AstNode> rhs_;
269 
270   DISALLOW_COPY_AND_ASSIGN(Assignment);
271 };  // class Assignment
272 
273 class MethodCall : public AstNode {
274  public:
275   MethodCall(const std::string& method_name,
276              const std::string& single_argument);
277   MethodCall(const std::string& method_name, ArgList&& arg_list);
278   ~MethodCall() = default;
279   void Write(CodeWriter* to) const override;
280 
281  private:
282   const std::string method_name_;
283   const ArgList arguments_;
284 
285   DISALLOW_COPY_AND_ASSIGN(MethodCall);
286 };  // class MethodCall
287 
288 class IfStatement : public AstNode {
289  public:
290   IfStatement(AstNode* expression,
291               bool invert_expression = false);
292   virtual ~IfStatement() = default;
OnTrue()293   StatementBlock* OnTrue() { return &on_true_; }
OnFalse()294   StatementBlock* OnFalse() { return &on_false_; }
295   void Write(CodeWriter* to) const override;
296 
297  private:
298   std::unique_ptr<AstNode> expression_;
299   bool invert_expression_ = false;
300   StatementBlock on_true_;
301   StatementBlock on_false_;
302 
303   DISALLOW_COPY_AND_ASSIGN(IfStatement);
304 };  // class IfStatement
305 
306 class Statement : public AstNode {
307  public:
308   explicit Statement(std::unique_ptr<AstNode> expression);
309   explicit Statement(AstNode* expression);  // Takes possession.
310   explicit Statement(const std::string& expression);
311   ~Statement() = default;
312   void Write(CodeWriter* to) const override;
313 
314  private:
315   std::unique_ptr<AstNode> expression_;
316 
317   DISALLOW_COPY_AND_ASSIGN(Statement);
318 };  // class Statement
319 
320 class Comparison : public AstNode {
321  public:
322   Comparison(AstNode* lhs, const std::string& comparison, AstNode* rhs);
323   ~Comparison() = default;
324   void Write(CodeWriter* to) const override;
325 
326  private:
327   std::unique_ptr<AstNode> left_;
328   std::unique_ptr<AstNode> right_;
329   const std::string operator_;
330 
331   DISALLOW_COPY_AND_ASSIGN(Comparison);
332 };  // class Comparison
333 
334 class LiteralExpression : public AstNode {
335  public:
336   explicit LiteralExpression(const std::string& expression);
337   ~LiteralExpression() = default;
338   void Write(CodeWriter* to) const override;
339 
340  private:
341   const std::string expression_;
342 
343   DISALLOW_COPY_AND_ASSIGN(LiteralExpression);
344 };  // class LiteralExpression
345 
346 class CppNamespace : public Declaration {
347  public:
348   CppNamespace(const std::string& name,
349                std::vector<std::unique_ptr<Declaration>> declarations);
350   CppNamespace(const std::string& name,
351                std::unique_ptr<Declaration> declaration);
352   CppNamespace(const std::string& name);
353   virtual ~CppNamespace() = default;
354 
355   void Write(CodeWriter* to) const override;
356 
357  private:
358   std::vector<std::unique_ptr<Declaration>> declarations_;
359   std::string name_;
360 
361   DISALLOW_COPY_AND_ASSIGN(CppNamespace);
362 };  // class CppNamespace
363 
364 class Document : public AstNode {
365  public:
366   Document(const std::vector<std::string>& include_list,
367            std::unique_ptr<CppNamespace> a_namespace);
368 
369   void Write(CodeWriter* to) const override;
370 
371  private:
372   std::vector<std::string> include_list_;
373   std::unique_ptr<CppNamespace> namespace_;
374 
375   DISALLOW_COPY_AND_ASSIGN(Document);
376 };  // class Document
377 
378 class CppHeader final : public Document {
379  public:
380   CppHeader(const std::string& include_guard,
381             const std::vector<std::string>& include_list,
382             std::unique_ptr<CppNamespace> a_namespace);
383   void Write(CodeWriter* to) const override;
384 
385  private:
386   const std::string include_guard_;
387 
388   DISALLOW_COPY_AND_ASSIGN(CppHeader);
389 };  // class CppHeader
390 
391 class CppSource final : public Document {
392  public:
393   CppSource(const std::vector<std::string>& include_list,
394             std::unique_ptr<CppNamespace> a_namespace);
395 
396  private:
397   DISALLOW_COPY_AND_ASSIGN(CppSource);
398 };  // class CppSource
399 
400 }  // namespace cpp
401 }  // namespace aidl
402 }  // namespace android
403 
404 #endif // AIDL_AST_CPP_H_
405