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