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
26namespace android {
27namespace aidl {
28class CodeWriter;
29}  // namespace aidl
30}  // namespace android
31
32namespace android {
33namespace aidl {
34namespace cpp {
35
36class AstNode {
37 public:
38  AstNode() = default;
39  virtual ~AstNode() = default;
40  virtual void Write(CodeWriter* to) const = 0;
41};  // class AstNode
42
43class 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
52class 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
76class 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
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
101class 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
118class 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
144class 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
176class 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);
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
194class 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
212class 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
238class 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
259class 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
273class 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
288class IfStatement : public AstNode {
289 public:
290  IfStatement(AstNode* expression,
291              bool invert_expression = false);
292  virtual ~IfStatement() = default;
293  StatementBlock* OnTrue() { return &on_true_; }
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
306class 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
320class 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
334class 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
346class 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
364class 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
378class 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
391class 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