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