Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 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 | |
Steven Moreland | 9fccf58 | 2018-08-27 20:36:27 -0700 | [diff] [blame] | 17 | #pragma once |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 18 | |
Casey Dahlin | 60a4916 | 2015-09-17 14:23:10 -0700 | [diff] [blame] | 19 | #include <memory> |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 20 | #include <string> |
| 21 | #include <vector> |
| 22 | |
Elliott Hughes | 0a62067 | 2015-12-04 13:53:18 -0800 | [diff] [blame] | 23 | #include <android-base/macros.h> |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 24 | |
| 25 | namespace android { |
| 26 | namespace aidl { |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 27 | class CodeWriter; |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 28 | } // namespace aidl |
| 29 | } // namespace android |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 30 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 31 | namespace android { |
| 32 | namespace aidl { |
| 33 | namespace cpp { |
| 34 | |
| 35 | class AstNode { |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 36 | public: |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 37 | AstNode() = default; |
| 38 | virtual ~AstNode() = default; |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 39 | virtual void Write(CodeWriter* to) const = 0; |
Jiyong Park | 176905e | 2018-07-04 22:29:41 +0900 | [diff] [blame] | 40 | std::string ToString(); |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 41 | }; // class AstNode |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 42 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 43 | class Declaration : public AstNode { |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 44 | public: |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 45 | Declaration() = default; |
| 46 | virtual ~Declaration() = default; |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 47 | |
| 48 | private: |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 49 | DISALLOW_COPY_AND_ASSIGN(Declaration); |
| 50 | }; // class Declaration |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 51 | |
Steven Moreland | 5557f1c | 2018-07-02 13:50:23 -0700 | [diff] [blame] | 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 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 64 | class ClassDecl : public Declaration { |
Casey Dahlin | 60a4916 | 2015-09-17 14:23:10 -0700 | [diff] [blame] | 65 | public: |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 66 | ClassDecl(const std::string& name, |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 67 | const std::string& parent); |
| 68 | ClassDecl(const std::string& name, |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 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; |
Casey Dahlin | 60a4916 | 2015-09-17 14:23:10 -0700 | [diff] [blame] | 73 | |
| 74 | void Write(CodeWriter* to) const override; |
| 75 | |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 76 | void AddPublic(std::unique_ptr<Declaration> member); |
| 77 | void AddPrivate(std::unique_ptr<Declaration> member); |
| 78 | |
Casey Dahlin | 60a4916 | 2015-09-17 14:23:10 -0700 | [diff] [blame] | 79 | private: |
| 80 | std::string name_; |
| 81 | std::string parent_; |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 82 | std::vector<std::unique_ptr<Declaration>> public_members_; |
| 83 | std::vector<std::unique_ptr<Declaration>> private_members_; |
Casey Dahlin | 60a4916 | 2015-09-17 14:23:10 -0700 | [diff] [blame] | 84 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 85 | DISALLOW_COPY_AND_ASSIGN(ClassDecl); |
| 86 | }; // class ClassDecl |
Casey Dahlin | 60a4916 | 2015-09-17 14:23:10 -0700 | [diff] [blame] | 87 | |
Christopher Wiley | a7a5c10 | 2015-09-29 16:26:52 -0700 | [diff] [blame] | 88 | class Enum : public Declaration { |
| 89 | public: |
Christopher Wiley | fd7dc03 | 2016-02-02 17:58:39 -0800 | [diff] [blame] | 90 | Enum(const std::string& name, const std::string& base_type); |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 91 | explicit Enum(const std::string& name); |
Christopher Wiley | a7a5c10 | 2015-09-29 16:26:52 -0700 | [diff] [blame] | 92 | virtual ~Enum() = default; |
| 93 | |
Christopher Wiley | fd7dc03 | 2016-02-02 17:58:39 -0800 | [diff] [blame] | 94 | bool HasValues() const { return !fields_.empty(); } |
Christopher Wiley | a7a5c10 | 2015-09-29 16:26:52 -0700 | [diff] [blame] | 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_; |
Christopher Wiley | fd7dc03 | 2016-02-02 17:58:39 -0800 | [diff] [blame] | 107 | std::string underlying_type_; |
Christopher Wiley | a7a5c10 | 2015-09-29 16:26:52 -0700 | [diff] [blame] | 108 | std::vector<EnumField> fields_; |
| 109 | |
| 110 | DISALLOW_COPY_AND_ASSIGN(Enum); |
| 111 | }; // class Enum |
| 112 | |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 113 | class ArgList : public AstNode { |
| 114 | public: |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 115 | ArgList() = default; |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 116 | explicit ArgList(const std::string& single_argument); |
| 117 | explicit ArgList(const std::vector<std::string>& arg_list); |
Christopher Wiley | f02facf | 2015-11-12 08:54:08 -0800 | [diff] [blame] | 118 | explicit ArgList(std::vector<std::unique_ptr<AstNode>> arg_list); |
Chih-Hung Hsieh | f5cbb68 | 2018-09-25 13:43:32 -0700 | [diff] [blame] | 119 | ArgList(ArgList&& arg_list) noexcept; |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 120 | virtual ~ArgList() = default; |
| 121 | |
| 122 | void Write(CodeWriter* to) const override; |
| 123 | |
| 124 | private: |
Christopher Wiley | f02facf | 2015-11-12 08:54:08 -0800 | [diff] [blame] | 125 | std::vector<std::unique_ptr<AstNode>> arguments_; |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 126 | |
| 127 | DISALLOW_COPY_AND_ASSIGN(ArgList); |
| 128 | }; // class ArgList |
| 129 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 130 | class ConstructorDecl : public Declaration { |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 131 | public: |
Christopher Wiley | b23149d | 2015-10-14 13:52:21 -0700 | [diff] [blame] | 132 | enum Modifiers { |
| 133 | IS_VIRTUAL = 1 << 0, |
| 134 | IS_DEFAULT = 1 << 1, |
| 135 | IS_EXPLICIT = 1 << 2, |
| 136 | }; |
| 137 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 138 | ConstructorDecl(const std::string& name, |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 139 | ArgList&& arg_list); |
Christopher Wiley | a7a5c10 | 2015-09-29 16:26:52 -0700 | [diff] [blame] | 140 | ConstructorDecl(const std::string& name, |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 141 | ArgList&& arg_list, |
Christopher Wiley | b23149d | 2015-10-14 13:52:21 -0700 | [diff] [blame] | 142 | uint32_t modifiers); |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 143 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 144 | virtual ~ConstructorDecl() = default; |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 145 | |
| 146 | void Write(CodeWriter* to) const override; |
| 147 | |
| 148 | private: |
| 149 | const std::string name_; |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 150 | const ArgList arguments_; |
Christopher Wiley | b23149d | 2015-10-14 13:52:21 -0700 | [diff] [blame] | 151 | const uint32_t modifiers_; |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 152 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 153 | DISALLOW_COPY_AND_ASSIGN(ConstructorDecl); |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 154 | }; // class ConstructorDecl |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 155 | |
Christopher Wiley | 11a9d79 | 2016-02-24 17:20:33 -0800 | [diff] [blame] | 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 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 170 | class MethodDecl : public Declaration { |
Casey Dahlin | 88924d6 | 2015-09-17 16:28:24 -0700 | [diff] [blame] | 171 | public: |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 172 | enum Modifiers { |
| 173 | IS_CONST = 1 << 0, |
| 174 | IS_VIRTUAL = 1 << 1, |
| 175 | IS_OVERRIDE = 1 << 2, |
| 176 | IS_PURE_VIRTUAL = 1 << 3, |
Christopher Wiley | 69b44cf | 2016-05-03 13:43:33 -0700 | [diff] [blame] | 177 | IS_STATIC = 1 << 4, |
Jeongik Cha | a2ada0c | 2018-11-17 15:11:45 +0900 | [diff] [blame] | 178 | IS_FINAL = 1 << 5, |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 179 | }; |
| 180 | |
| 181 | MethodDecl(const std::string& return_type, |
| 182 | const std::string& name, |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 183 | ArgList&& arg_list); |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 184 | MethodDecl(const std::string& return_type, |
| 185 | const std::string& name, |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 186 | ArgList&& arg_list, |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 187 | uint32_t modifiers); |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 188 | virtual ~MethodDecl() = default; |
Casey Dahlin | 88924d6 | 2015-09-17 16:28:24 -0700 | [diff] [blame] | 189 | |
| 190 | void Write(CodeWriter* to) const override; |
| 191 | |
| 192 | private: |
| 193 | const std::string return_type_; |
| 194 | const std::string name_; |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 195 | const ArgList arguments_; |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 196 | bool is_const_ = false; |
| 197 | bool is_virtual_ = false; |
| 198 | bool is_override_ = false; |
| 199 | bool is_pure_virtual_ = false; |
Christopher Wiley | 69b44cf | 2016-05-03 13:43:33 -0700 | [diff] [blame] | 200 | bool is_static_ = true; |
Jeongik Cha | a2ada0c | 2018-11-17 15:11:45 +0900 | [diff] [blame] | 201 | bool is_final_ = false; |
Casey Dahlin | 88924d6 | 2015-09-17 16:28:24 -0700 | [diff] [blame] | 202 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 203 | DISALLOW_COPY_AND_ASSIGN(MethodDecl); |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 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); |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 212 | void AddStatement(AstNode* statement); // Takes ownership |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 213 | void AddLiteral(const std::string& expression, bool add_semicolon = true); |
Christopher Wiley | 0eb903e | 2015-10-20 17:07:08 -0700 | [diff] [blame] | 214 | bool Empty() const { return statements_.empty(); } |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 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 | |
Christopher Wiley | f9688b0 | 2015-10-08 17:17:50 -0700 | [diff] [blame] | 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 | |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 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, |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 249 | ArgList&& arg_list, |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 250 | bool is_const_method = false); |
| 251 | virtual ~MethodImpl() = default; |
| 252 | |
Christopher Wiley | f9688b0 | 2015-10-08 17:17:50 -0700 | [diff] [blame] | 253 | // MethodImpl retains ownership of the statement block. |
| 254 | StatementBlock* GetStatementBlock(); |
| 255 | |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 256 | void Write(CodeWriter* to) const override; |
| 257 | |
| 258 | private: |
| 259 | std::string return_type_; |
| 260 | std::string method_name_; |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 261 | const ArgList arguments_; |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 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 | |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 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); |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 307 | MethodCall(const std::string& method_name, ArgList&& arg_list); |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 308 | ~MethodCall() = default; |
| 309 | void Write(CodeWriter* to) const override; |
| 310 | |
| 311 | private: |
| 312 | const std::string method_name_; |
Christopher Wiley | ade4b45 | 2015-10-10 11:06:03 -0700 | [diff] [blame] | 313 | const ArgList arguments_; |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 314 | |
| 315 | DISALLOW_COPY_AND_ASSIGN(MethodCall); |
| 316 | }; // class MethodCall |
| 317 | |
Christopher Wiley | 0eb903e | 2015-10-20 17:07:08 -0700 | [diff] [blame] | 318 | class IfStatement : public AstNode { |
| 319 | public: |
Chih-Hung Hsieh | 156a57f | 2016-06-02 16:17:28 -0700 | [diff] [blame] | 320 | explicit IfStatement(AstNode* expression, |
Christopher Wiley | 0eb903e | 2015-10-20 17:07:08 -0700 | [diff] [blame] | 321 | bool invert_expression = false); |
| 322 | virtual ~IfStatement() = default; |
| 323 | StatementBlock* OnTrue() { return &on_true_; } |
| 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 | |
Christopher Wiley | 3c5d28d | 2015-10-21 09:53:46 -0700 | [diff] [blame] | 336 | class Statement : public AstNode { |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 337 | public: |
Christopher Wiley | 3c5d28d | 2015-10-21 09:53:46 -0700 | [diff] [blame] | 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; |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 342 | void Write(CodeWriter* to) const override; |
| 343 | |
| 344 | private: |
Christopher Wiley | 3c5d28d | 2015-10-21 09:53:46 -0700 | [diff] [blame] | 345 | std::unique_ptr<AstNode> expression_; |
Christopher Wiley | da69599 | 2015-10-05 11:31:41 -0700 | [diff] [blame] | 346 | |
Christopher Wiley | 3c5d28d | 2015-10-21 09:53:46 -0700 | [diff] [blame] | 347 | DISALLOW_COPY_AND_ASSIGN(Statement); |
| 348 | }; // class Statement |
Casey Dahlin | 88924d6 | 2015-09-17 16:28:24 -0700 | [diff] [blame] | 349 | |
Christopher Wiley | d55db28 | 2015-10-20 18:16:47 -0700 | [diff] [blame] | 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 | |
Christopher Wiley | 2328526 | 2015-10-09 15:06:14 -0700 | [diff] [blame] | 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 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 376 | class CppNamespace : public Declaration { |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 377 | public: |
| 378 | CppNamespace(const std::string& name, |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 379 | std::vector<std::unique_ptr<Declaration>> declarations); |
Christopher Wiley | 0c732db | 2015-09-29 14:36:44 -0700 | [diff] [blame] | 380 | CppNamespace(const std::string& name, |
| 381 | std::unique_ptr<Declaration> declaration); |
Chih-Hung Hsieh | 156a57f | 2016-06-02 16:17:28 -0700 | [diff] [blame] | 382 | explicit CppNamespace(const std::string& name); |
Casey Dahlin | b7d0f7f | 2015-09-22 17:21:08 -0700 | [diff] [blame] | 383 | virtual ~CppNamespace() = default; |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 384 | |
| 385 | void Write(CodeWriter* to) const override; |
| 386 | |
| 387 | private: |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 388 | std::vector<std::unique_ptr<Declaration>> declarations_; |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 389 | std::string name_; |
| 390 | |
| 391 | DISALLOW_COPY_AND_ASSIGN(CppNamespace); |
| 392 | }; // class CppNamespace |
| 393 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 394 | class Document : public AstNode { |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 395 | public: |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 396 | Document(const std::vector<std::string>& include_list, |
Steven Moreland | f3da089 | 2018-10-05 14:52:01 -0700 | [diff] [blame] | 397 | std::vector<std::unique_ptr<Declaration>> declarations); |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 398 | |
| 399 | void Write(CodeWriter* to) const override; |
| 400 | |
| 401 | private: |
| 402 | std::vector<std::string> include_list_; |
Steven Moreland | f3da089 | 2018-10-05 14:52:01 -0700 | [diff] [blame] | 403 | std::vector<std::unique_ptr<Declaration>> declarations_; |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 404 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 405 | DISALLOW_COPY_AND_ASSIGN(Document); |
| 406 | }; // class Document |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 407 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 408 | class CppHeader final : public Document { |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 409 | public: |
Steven Moreland | f3da089 | 2018-10-05 14:52:01 -0700 | [diff] [blame] | 410 | CppHeader(const std::string& include_guard, const std::vector<std::string>& include_list, |
| 411 | std::vector<std::unique_ptr<Declaration>> declarations); |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 412 | void Write(CodeWriter* to) const override; |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 413 | |
| 414 | private: |
| 415 | const std::string include_guard_; |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 416 | |
| 417 | DISALLOW_COPY_AND_ASSIGN(CppHeader); |
| 418 | }; // class CppHeader |
| 419 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 420 | class CppSource final : public Document { |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 421 | public: |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 422 | CppSource(const std::vector<std::string>& include_list, |
Steven Moreland | f3da089 | 2018-10-05 14:52:01 -0700 | [diff] [blame] | 423 | std::vector<std::unique_ptr<Declaration>> declarations); |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 424 | |
| 425 | private: |
Casey Dahlin | 34b8610 | 2015-09-16 16:03:06 -0700 | [diff] [blame] | 426 | DISALLOW_COPY_AND_ASSIGN(CppSource); |
| 427 | }; // class CppSource |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 428 | |
Christopher Wiley | f944e79 | 2015-09-29 10:00:46 -0700 | [diff] [blame] | 429 | } // namespace cpp |
Christopher Wiley | f600a55 | 2015-09-12 14:07:44 -0700 | [diff] [blame] | 430 | } // namespace aidl |
| 431 | } // namespace android |