1/*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#ifndef OHOS_IDL_AST_H
17#define OHOS_IDL_AST_H
18
19#include <unordered_map>
20#include <vector>
21
22#include "ast/ast_void_type.h"
23#include "ast/ast_array_type.h"
24#include "ast/base/ast_boolean_type.h"
25#include "ast/ast_native_buffer_type.h"
26#include "ast/base/ast_byte_type.h"
27#include "ast/base/ast_double_type.h"
28#include "ast/ast_enum_type.h"
29#include "ast/ast_fd_type.h"
30#include "ast/base/ast_float_type.h"
31#include "ast/base/ast_integer_type.h"
32#include "ast/ast_interface_type.h"
33#include "ast/base/ast_long_type.h"
34#include "ast/ast_map_type.h"
35#include "ast/ast_namespace.h"
36#include "ast/ast_node.h"
37#include "ast/ast_pointer_type.h"
38#include "ast/ast_sequenceable_type.h"
39#include "ast/base/ast_short_type.h"
40#include "ast/ast_smq_type.h"
41#include "ast/base/ast_string_type.h"
42#include "ast/base/ast_string16_type.h"
43#include "ast/ast_struct_type.h"
44#include "ast/base/ast_char_type.h"
45#include "ast/base/ast_uchar_type.h"
46#include "ast/base/ast_uint_type.h"
47#include "ast/base/ast_ulong_type.h"
48#include "ast/ast_union_type.h"
49#include "ast/base/ast_ushort_type.h"
50#include "util/autoptr.h"
51
52namespace OHOS {
53namespace Idl {
54enum class ASTFileType {
55    AST_IFACE,        // this idl file contains class of normal interface
56    AST_CALL_IFACE,   // this idl file contains class of interface that as parameter
57    AST_ICALLBACK,    // this idl file contains class of callback interface
58    AST_TYPES,        // this idl file contains custom types
59    AST_SEQUENCEABLE, // this is not an idl file, but a c++/java file
60};
61
62class AST : public ASTNode {
63public:
64    using StrASTMap = std::unordered_map<std::string, AutoPtr<AST>>;
65    using TypeStringMap = std::unordered_map<std::string, AutoPtr<ASTType>>;
66
67    ~AST() override = default;
68
69    void SetAStFileType(ASTFileType fileType)
70    {
71        astFileType_ = fileType;
72    }
73
74    ASTFileType GetASTFileType() const
75    {
76        return astFileType_;
77    }
78
79    void SetIdlFile(const std::string &idlFile);
80
81    inline std::string GetName()
82    {
83        return name_;
84    }
85
86    void SetFullName(const std::string &fullName);
87
88    inline std::string GetFullName()
89    {
90        return packageName_ + "." + name_;
91    }
92
93    inline std::string GetPackageName() const
94    {
95        return packageName_;
96    }
97
98    inline void SetLicense(const std::string &license)
99    {
100        license_ = license;
101    }
102
103    inline std::string GetLicense()
104    {
105        return license_;
106    }
107
108    void SetPackageName(const std::string &packageName);
109
110    AutoPtr<ASTNamespace> ParseNamespace(const std::string &nspaceStr);
111
112    void AddNamespace(const AutoPtr<ASTNamespace> &nspace);
113
114    AutoPtr<ASTNamespace> FindNamespace(const std::string &nspaceStr);
115
116    AutoPtr<ASTNamespace> GetNamespace(size_t index);
117
118    inline std::vector<AutoPtr<ASTNamespace>> GetNamespace()
119    {
120        return namespaces_;
121    }
122
123    inline size_t GetNamespaceNumber()
124    {
125        return namespaces_.size();
126    }
127
128    void AddInterfaceDef(const AutoPtr<ASTInterfaceType> &interface);
129
130    AutoPtr<ASTInterfaceType> GetInterfaceDef(size_t index = 0);
131
132    inline size_t GetInterfaceDefNumber() const
133    {
134        return interfaceDefs_.size();
135    }
136
137    void AddSequenceableDef(const AutoPtr<ASTSequenceableType> &sequenceable);
138
139    AutoPtr<ASTSequenceableType> GetSequenceableDef(size_t index = 0);
140
141    inline size_t GetSequenceableDefNumber() const
142    {
143        return sequenceableDefs_.size();
144    }
145
146    int IndexOf(ASTInterfaceType* interface);
147
148    int IndexOf(ASTSequenceableType* sequenceable);
149
150    int IndexOf(ASTType* type);
151
152    void AddType(const AutoPtr<ASTType> &type);
153
154    AutoPtr<ASTType> FindType(const std::string &typeName, bool lookImports = true);
155
156    inline const TypeStringMap &GetTypes() const
157    {
158        return types_;
159    }
160
161    inline size_t GetTypeNumber() const
162    {
163        return types_.size();
164    }
165
166    void AddTypeDefinition(const AutoPtr<ASTType> &type);
167
168    inline size_t GetTypeDefinitionNumber() const
169    {
170        return typeDefinitions_.size();
171    }
172
173    AutoPtr<ASTType> GetTypeDefintion(size_t index);
174
175    std::string Dump(const std::string &prefix) override;
176
177    bool AddImport(const AutoPtr<AST> &importAst);
178
179    void ClearImport()
180    {
181        return imports_.clear();
182    }
183
184    inline const StrASTMap &GetImports() const
185    {
186        return imports_;
187    }
188
189    void SetVersion(size_t &majorVer, size_t &minorVer);
190
191    inline size_t GetMajorVer() const
192    {
193        return majorVersion_;
194    }
195
196    inline size_t GetMinorVer() const
197    {
198        return minorVersion_;
199    }
200
201    std::string GetVersion() const
202    {
203        return StringHelper::Format("%u.%u", majorVersion_, minorVersion_);
204    }
205
206    inline std::string GetIdlFilePath()
207    {
208        return idlFilePath_;
209    }
210
211    bool IsValid();
212    std::vector<AutoPtr<ASTInterfaceType>> GetInterfaceDefs() const
213    {
214        return interfaceDefs_;
215    }
216
217    bool GetHasCacheableProxyMethods() const
218    {
219        return hasCacheableProxyMethods_;
220    }
221
222    void SetHasCacheableProxyMethods(bool cacheable)
223    {
224        hasCacheableProxyMethods_ = cacheable;
225    }
226
227    inline void SetInterfaceToken(std::string &interfaceToken)
228    {
229        interfaceToken_ = interfaceToken;
230    }
231
232    inline std::string GetInterfaceToken() const
233    {
234        return interfaceToken_;
235    }
236
237    inline void SetSupportDelegator(std::string &supportDelegator)
238    {
239        if (supportDelegator == "on") {
240            supportDelegatorOn_ = true;
241        } else {
242            supportDelegatorOn_ = false;
243        }
244    }
245
246    inline bool GetSupportDelegatorOn() const
247    {
248        return supportDelegatorOn_;
249    }
250
251private:
252    AutoPtr<ASTNamespace> NewNameSpace(std::string nameSpace);
253
254    ASTFileType astFileType_ = ASTFileType::AST_IFACE;
255    std::string name_;
256    std::string license_;
257    std::string packageName_;
258    size_t majorVersion_;
259    size_t minorVersion_;
260    std::vector<AutoPtr<ASTNamespace>> namespaces_;
261    std::vector<AutoPtr<ASTType>> typeDefinitions_; // enum, struct, union
262    std::vector<AutoPtr<ASTSequenceableType>> sequenceableDefs_;
263    std::vector<AutoPtr<ASTInterfaceType>> interfaceDefs_;
264
265    StrASTMap imports_;
266    TypeStringMap types_;
267
268    static TypeStringMap basicTypes_;
269
270    std::string idlFilePath_;
271    bool hasCacheableProxyMethods_ = false;
272    std::string interfaceToken_;
273    bool supportDelegatorOn_ = false;
274};
275} // namespace Idl
276} // namespace OHOS
277
278#endif // OHOS_IDL_AST_H