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