Christopher Wiley | 89e3586 | 2015-08-30 10:57:07 -0700 | [diff] [blame] | 1 | #ifndef AIDL_AIDL_LANGUAGE_H_ |
| 2 | #define AIDL_AIDL_LANGUAGE_H_ |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 3 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 4 | #include <memory> |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 5 | #include <string> |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 6 | #include <vector> |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 7 | |
Christopher Wiley | 7c3a1eb | 2015-09-12 10:19:52 -0700 | [diff] [blame] | 8 | #include <base/macros.h> |
Casey Dahlin | 73d46b0 | 2015-09-11 02:47:54 +0000 | [diff] [blame] | 9 | |
Christopher Wiley | 4a2884b | 2015-10-07 11:27:45 -0700 | [diff] [blame] | 10 | #include <io_delegate.h> |
| 11 | |
Casey Dahlin | 89d4484 | 2015-09-24 18:45:54 -0700 | [diff] [blame] | 12 | struct yy_buffer_state; |
| 13 | typedef yy_buffer_state* YY_BUFFER_STATE; |
| 14 | |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 15 | enum which_extra_text { |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 16 | NO_EXTRA_TEXT = 0, |
| 17 | SHORT_COMMENT, |
| 18 | LONG_COMMENT, |
| 19 | COPY_TEXT, |
| 20 | WHITESPACE |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 21 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 22 | |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 23 | struct extra_text_type { |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 24 | unsigned lineno; |
| 25 | which_extra_text which; |
| 26 | char* data; |
| 27 | unsigned len; |
| 28 | struct extra_text_type* next; |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 29 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 30 | |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 31 | struct buffer_type { |
Casey Dahlin | 082f1d1 | 2015-09-21 14:06:25 -0700 | [diff] [blame] | 32 | unsigned lineno; |
| 33 | unsigned token; |
| 34 | char *data; |
| 35 | extra_text_type* extra; |
| 36 | |
| 37 | std::string Literal() const { |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 38 | return data ? std::string(data) : ""; |
Casey Dahlin | 082f1d1 | 2015-09-21 14:06:25 -0700 | [diff] [blame] | 39 | } |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 40 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 41 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 42 | class AidlNode { |
| 43 | public: |
| 44 | AidlNode() = default; |
| 45 | virtual ~AidlNode() = default; |
| 46 | |
| 47 | private: |
| 48 | DISALLOW_COPY_AND_ASSIGN(AidlNode); |
| 49 | }; |
| 50 | |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 51 | class AidlType : public AidlNode { |
| 52 | public: |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 53 | AidlType(const std::string& name, unsigned line, |
Casey Dahlin | f7a421c | 2015-10-05 17:24:28 -0700 | [diff] [blame] | 54 | const std::string& comments, bool is_array); |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 55 | virtual ~AidlType() = default; |
| 56 | |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 57 | const std::string& GetName() const { return name_; } |
| 58 | unsigned GetLine() const { return line_; } |
Casey Dahlin | f7a421c | 2015-10-05 17:24:28 -0700 | [diff] [blame] | 59 | bool IsArray() const { return is_array_; } |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 60 | const std::string& GetComments() const { return comments_; } |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 61 | |
Casey Dahlin | 70078e6 | 2015-09-30 17:01:30 -0700 | [diff] [blame] | 62 | std::string ToString() const; |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 63 | |
| 64 | private: |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 65 | std::string name_; |
| 66 | unsigned line_; |
Casey Dahlin | f7a421c | 2015-10-05 17:24:28 -0700 | [diff] [blame] | 67 | bool is_array_; |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 68 | std::string comments_; |
| 69 | |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 70 | DISALLOW_COPY_AND_ASSIGN(AidlType); |
| 71 | }; |
| 72 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 73 | class AidlArgument : public AidlNode { |
| 74 | public: |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 75 | enum Direction { IN_DIR = 1, OUT_DIR = 2, INOUT_DIR = 3 }; |
| 76 | |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 77 | AidlArgument(AidlArgument::Direction direction, AidlType* type, |
Casey Dahlin | 308f9d4 | 2015-10-05 18:48:42 -0700 | [diff] [blame] | 78 | std::string name, unsigned line); |
| 79 | AidlArgument(AidlType *type, std::string name, unsigned line); |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 80 | virtual ~AidlArgument() = default; |
| 81 | |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 82 | Direction GetDirection() const { return direction_; } |
| 83 | bool DirectionWasSpecified() const { return direction_specified_; } |
Casey Dahlin | d127b50 | 2015-09-30 12:51:08 -0700 | [diff] [blame] | 84 | std::string GetName() const { return name_; } |
| 85 | int GetLine() const { return line_; } |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 86 | const AidlType& GetType() const { return *type_; } |
Casey Dahlin | d127b50 | 2015-09-30 12:51:08 -0700 | [diff] [blame] | 87 | |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 88 | std::string ToString() const; |
| 89 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 90 | private: |
Casey Dahlin | 0ee3758 | 2015-09-30 16:31:55 -0700 | [diff] [blame] | 91 | std::unique_ptr<AidlType> type_; |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 92 | Direction direction_; |
| 93 | bool direction_specified_; |
Casey Dahlin | d127b50 | 2015-09-30 12:51:08 -0700 | [diff] [blame] | 94 | std::string name_; |
Casey Dahlin | 308f9d4 | 2015-10-05 18:48:42 -0700 | [diff] [blame] | 95 | unsigned line_; |
Casey Dahlin | c378c99 | 2015-09-29 16:50:40 -0700 | [diff] [blame] | 96 | |
Casey Dahlin | bc7a50a | 2015-09-28 19:20:50 -0700 | [diff] [blame] | 97 | DISALLOW_COPY_AND_ASSIGN(AidlArgument); |
Casey Dahlin | a834dd4 | 2015-09-23 11:52:15 -0700 | [diff] [blame] | 98 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 99 | |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 100 | class AidlMethod { |
| 101 | public: |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 102 | AidlMethod(bool oneway, AidlType* type, std::string name, |
| 103 | std::vector<std::unique_ptr<AidlArgument>>* args, |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 104 | unsigned line, const std::string& comments); |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 105 | AidlMethod(bool oneway, AidlType* type, std::string name, |
| 106 | std::vector<std::unique_ptr<AidlArgument>>* args, |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 107 | unsigned line, const std::string& comments, int id); |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 108 | virtual ~AidlMethod() = default; |
| 109 | |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 110 | const std::string& GetComments() const { return comments_; } |
| 111 | const AidlType& GetType() const { return *type_; } |
| 112 | bool IsOneway() const { return oneway_; } |
| 113 | const std::string& GetName() const { return name_; } |
| 114 | unsigned GetLine() const { return line_; } |
| 115 | bool HasId() const { return has_id_; } |
| 116 | int GetId() { return id_; } |
| 117 | void SetId(unsigned id) { id_ = id; } |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 118 | |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 119 | const std::vector<std::unique_ptr<AidlArgument>>& GetArguments() const { |
| 120 | return arguments_; |
| 121 | } |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 122 | |
| 123 | private: |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 124 | bool oneway_; |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 125 | std::string comments_; |
Casey Dahlin | f4a9311 | 2015-10-05 16:58:09 -0700 | [diff] [blame] | 126 | std::unique_ptr<AidlType> type_; |
| 127 | std::string name_; |
| 128 | unsigned line_; |
| 129 | std::vector<std::unique_ptr<AidlArgument>> arguments_; |
| 130 | bool has_id_; |
| 131 | int id_; |
Casey Dahlin | f2d23f7 | 2015-10-02 16:19:19 -0700 | [diff] [blame] | 132 | |
Casey Dahlin | 5c69deb | 2015-10-01 14:44:12 -0700 | [diff] [blame] | 133 | DISALLOW_COPY_AND_ASSIGN(AidlMethod); |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 134 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 135 | |
| 136 | enum { |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 137 | USER_DATA_TYPE = 12, |
| 138 | INTERFACE_TYPE_BINDER |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 139 | }; |
| 140 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 141 | class AidlDocumentItem : public AidlNode { |
| 142 | public: |
| 143 | AidlDocumentItem() = default; |
| 144 | virtual ~AidlDocumentItem() = default; |
| 145 | |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 146 | AidlDocumentItem* next = nullptr; |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 147 | unsigned item_type; |
| 148 | |
| 149 | private: |
| 150 | DISALLOW_COPY_AND_ASSIGN(AidlDocumentItem); |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 151 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 152 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 153 | class AidlParcelable : public AidlDocumentItem { |
| 154 | public: |
| 155 | AidlParcelable() = default; |
| 156 | virtual ~AidlParcelable() = default; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 157 | |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 158 | std::string GetName() const { return name.data; } |
| 159 | unsigned GetLine() const { return name.lineno; } |
| 160 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 161 | buffer_type keyword_token; // only the first one |
| 162 | char* package; |
| 163 | buffer_type name; |
| 164 | buffer_type semicolon_token; |
| 165 | bool parcelable; |
| 166 | |
| 167 | private: |
| 168 | DISALLOW_COPY_AND_ASSIGN(AidlParcelable); |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 169 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 170 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 171 | class AidlInterface : public AidlDocumentItem { |
| 172 | public: |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 173 | AidlInterface(const std::string& name, unsigned line, |
| 174 | const std::string& comments, bool oneway_, |
| 175 | std::vector<std::unique_ptr<AidlMethod>>* methods, |
| 176 | const std::string& package); |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 177 | virtual ~AidlInterface() = default; |
| 178 | |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 179 | const std::string& GetName() const { return name_; } |
| 180 | unsigned GetLine() const { return line_; } |
| 181 | const std::string& GetComments() const { return comments_; } |
| 182 | bool IsOneway() const { return oneway_; } |
| 183 | const std::vector<std::unique_ptr<AidlMethod>>& GetMethods() const |
| 184 | { return methods_; } |
| 185 | const std::string& GetPackage() const { return package_; } |
| 186 | std::string GetCanonicalName() const { return package_ + "." + name_; } |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 187 | |
| 188 | private: |
Casey Dahlin | fb7da2e | 2015-10-08 17:26:09 -0700 | [diff] [blame] | 189 | std::string name_; |
| 190 | std::string comments_; |
| 191 | unsigned line_; |
| 192 | bool oneway_; |
| 193 | std::vector<std::unique_ptr<AidlMethod>> methods_; |
| 194 | std::string package_; |
| 195 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 196 | DISALLOW_COPY_AND_ASSIGN(AidlInterface); |
Casey Dahlin | 0a2f8be | 2015-09-28 16:15:29 -0700 | [diff] [blame] | 197 | }; |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 198 | |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 199 | |
Adam Lesinski | ffa1686 | 2014-01-23 18:17:42 -0800 | [diff] [blame] | 200 | void init_buffer_type(buffer_type* buf, int lineno); |
| 201 | |
Casey Dahlin | 0edf342 | 2015-10-07 12:34:59 -0700 | [diff] [blame] | 202 | class AidlImport : public AidlNode { |
| 203 | public: |
| 204 | AidlImport(const std::string& from, const std::string& needed_class, |
| 205 | unsigned line); |
| 206 | virtual ~AidlImport() = default; |
| 207 | |
| 208 | const std::string& GetFileFrom() const { return from_; } |
| 209 | const std::string& GetFilename() const { return filename_; } |
| 210 | const std::string& GetNeededClass() const { return needed_class_; } |
| 211 | unsigned GetLine() const { return line_; } |
| 212 | const AidlDocumentItem* GetDocument() { return document_.get(); }; |
| 213 | void SetDocument(AidlDocumentItem* doc) { |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 214 | document_ = std::unique_ptr<AidlDocumentItem>(doc); |
Casey Dahlin | 0edf342 | 2015-10-07 12:34:59 -0700 | [diff] [blame] | 215 | } |
| 216 | |
| 217 | void SetFilename(const std::string& filename) { filename_ = filename; } |
| 218 | |
| 219 | private: |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 220 | std::unique_ptr<AidlDocumentItem> document_; |
Casey Dahlin | 0edf342 | 2015-10-07 12:34:59 -0700 | [diff] [blame] | 221 | std::string from_; |
| 222 | std::string filename_; |
| 223 | std::string needed_class_; |
| 224 | unsigned line_; |
| 225 | |
| 226 | DISALLOW_COPY_AND_ASSIGN(AidlImport); |
Casey Dahlin | e250749 | 2015-09-14 17:11:20 -0700 | [diff] [blame] | 227 | }; |
| 228 | |
| 229 | class Parser { |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 230 | public: |
Christopher Wiley | 4a2884b | 2015-10-07 11:27:45 -0700 | [diff] [blame] | 231 | explicit Parser(const android::aidl::IoDelegate& io_delegate); |
Casey Dahlin | e250749 | 2015-09-14 17:11:20 -0700 | [diff] [blame] | 232 | ~Parser(); |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 233 | |
Christopher Wiley | 4a2884b | 2015-10-07 11:27:45 -0700 | [diff] [blame] | 234 | // Parse contents of file |filename|. |
| 235 | bool ParseFile(const std::string& filename); |
Casey Dahlin | 89d4484 | 2015-09-24 18:45:54 -0700 | [diff] [blame] | 236 | |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 237 | void ReportError(const std::string& err); |
| 238 | |
Casey Dahlin | 3c6df36 | 2015-10-06 15:48:35 -0700 | [diff] [blame] | 239 | bool FoundNoErrors() const { return error_ == 0; } |
| 240 | const std::string& FileName() const { return filename_; } |
| 241 | const std::string& Package() const { return package_; } |
| 242 | void *Scanner() const { return scanner_; } |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 243 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 244 | void SetDocument(AidlDocumentItem *items) { document_ = items; }; |
Casey Dahlin | e250749 | 2015-09-14 17:11:20 -0700 | [diff] [blame] | 245 | |
Casey Dahlin | 3c6df36 | 2015-10-06 15:48:35 -0700 | [diff] [blame] | 246 | void AddImport(std::vector<std::string>* terms, unsigned line); |
| 247 | void SetPackage(std::vector<std::string>* terms); |
| 248 | |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 249 | AidlDocumentItem *GetDocument() const { return document_; } |
Casey Dahlin | 0edf342 | 2015-10-07 12:34:59 -0700 | [diff] [blame] | 250 | const std::vector<std::unique_ptr<AidlImport>>& GetImports() { return imports_; } |
| 251 | |
| 252 | void ReleaseImports(std::vector<std::unique_ptr<AidlImport>>* ret) { |
| 253 | *ret = std::move(imports_); |
| 254 | imports_.clear(); |
| 255 | } |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 256 | |
| 257 | private: |
Christopher Wiley | 4a2884b | 2015-10-07 11:27:45 -0700 | [diff] [blame] | 258 | const android::aidl::IoDelegate& io_delegate_; |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 259 | int error_ = 0; |
| 260 | std::string filename_; |
| 261 | std::string package_; |
| 262 | void *scanner_ = nullptr; |
Casey Dahlin | 1ae2bc5 | 2015-10-07 18:49:10 -0700 | [diff] [blame] | 263 | AidlDocumentItem* document_ = nullptr; |
Casey Dahlin | 0edf342 | 2015-10-07 12:34:59 -0700 | [diff] [blame] | 264 | std::vector<std::unique_ptr<AidlImport>> imports_; |
Christopher Wiley | 4a2884b | 2015-10-07 11:27:45 -0700 | [diff] [blame] | 265 | std::unique_ptr<std::string> raw_buffer_; |
Casey Dahlin | 89d4484 | 2015-09-24 18:45:54 -0700 | [diff] [blame] | 266 | YY_BUFFER_STATE buffer_; |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 267 | |
Casey Dahlin | e250749 | 2015-09-14 17:11:20 -0700 | [diff] [blame] | 268 | DISALLOW_COPY_AND_ASSIGN(Parser); |
Casey Dahlin | dd69181 | 2015-09-09 17:59:06 -0700 | [diff] [blame] | 269 | }; |
| 270 | |
Christopher Wiley | 89e3586 | 2015-08-30 10:57:07 -0700 | [diff] [blame] | 271 | #endif // AIDL_AIDL_LANGUAGE_H_ |