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 #include <cstdint>
16
17 #include "metadata/metadata_reader.h"
18 #include "metadata/metadata_serializer.h"
19 #include "util/file.h"
20 #include "util/logger.h"
21
22 namespace OHOS {
23 namespace Idl {
24 std::string MetadataReader::tag_ = "MetadataReader";
25
ReadMetadataFromFile(const std::string & filePath)26 std::shared_ptr<MetaComponent> MetadataReader::ReadMetadataFromFile(const std::string& filePath)
27 {
28 File file(filePath, File::READ);
29 if (!file.IsValid()) {
30 Logger::E(tag_.c_str(), "Open \"%s\" file failed.", filePath.c_str());
31 return nullptr;
32 }
33
34 if (!file.Reset()) {
35 Logger::E(tag_.c_str(), "Reset \"%s\" file failed.", filePath.c_str());
36 return nullptr;
37 }
38
39 MetaComponent header;
40
41 if (!file.ReadData((void*)&header, sizeof(MetaComponent))) {
42 Logger::E(tag_.c_str(), "Read \"%s\" file failed.", filePath.c_str());
43 return nullptr;
44 }
45
46 if (header.magic_ != METADATA_MAGIC_NUMBER || header.size_ < 0 || header.size_ > UINT16_MAX) {
47 Logger::E(tag_.c_str(), "The metadata in \"%s\" file is bad.", filePath.c_str());
48 return nullptr;
49 }
50
51 if (!file.Reset()) {
52 Logger::E(tag_.c_str(), "Reset \"%s\" file failed.", filePath.c_str());
53 return nullptr;
54 }
55
56 void* data = malloc(header.size_);
57 if (data == nullptr) {
58 Logger::E(tag_.c_str(), "Malloc metadata failed.");
59 return nullptr;
60 }
61
62 if (!file.ReadData(data, header.size_)) {
63 Logger::E(tag_.c_str(), "Read \"%s\" file failed.", filePath.c_str());
64 free(data);
65 return nullptr;
66 }
67
68 std::shared_ptr<MetaComponent> metadata(reinterpret_cast<MetaComponent *>(data), [](MetaComponent* p) { free(p); });
69
70 MetadataSerializer serializer((uintptr_t)data);
71 serializer.Deserialize();
72
73 return metadata;
74 }
75
ReadMetadataToAst()76 std::unordered_map<std::string, AutoPtr<AST>> MetadataReader::ReadMetadataToAst()
77 {
78 std::unordered_map<std::string, AutoPtr<AST>> allAsts;
79
80 ast_ = new AST();
81 for (int i = 0; i < metaComponent_->sequenceableNumber_; i++) {
82 ReadMetaSequenceable(metaComponent_->sequenceables_[i]);
83 }
84
85 for (int i = 0; i < metaComponent_->rawdataNumber_; i++) {
86 ReadMetaRawData(metaComponent_->rawdatas_[i]);
87 }
88
89 for (int i = 0; i < metaComponent_->interfaceNumber_; i++) {
90 ReadMetaInterface(metaComponent_->interfaces_[i]);
91 }
92
93 ast_->SetFullName(std::string(reinterpret_cast<char*>(metaComponent_->name_)));
94 ast_->SetAStFileType(ASTFileType::AST_IFACE);
95 allAsts[std::string(reinterpret_cast<char*>(metaComponent_->name_))] = ast_;
96
97 return allAsts;
98 }
99
ReadMetaSequenceable(MetaSequenceable * mp)100 void MetadataReader::ReadMetaSequenceable(MetaSequenceable* mp)
101 {
102 AutoPtr<ASTSequenceableType> seqType = new ASTSequenceableType();
103
104 seqType->SetName(std::string(reinterpret_cast<char*>(mp->name_)));
105 seqType->SetNamespace(ast_->ParseNamespace(std::string(reinterpret_cast<char*>(mp->namespace_))));
106 AutoPtr<AST> seqAst = new AST();
107 seqAst->SetFullName(seqType->GetFullName());
108 seqAst->AddSequenceableDef(seqType);
109 seqAst->SetAStFileType(ASTFileType::AST_SEQUENCEABLE);
110 ast_->AddImport(seqAst);
111 ast_->AddSequenceableDef(seqType);
112 }
113
ReadMetaRawData(MetaRawData * mp)114 void MetadataReader::ReadMetaRawData(MetaRawData* mp)
115 {
116 AutoPtr<ASTRawDataType> rawdataType = new ASTRawDataType();
117
118 rawdataType->SetName(std::string(reinterpret_cast<char*>(mp->name_)));
119 rawdataType->SetNamespace(ast_->ParseNamespace(std::string(reinterpret_cast<char*>(mp->namespace_))));
120 AutoPtr<AST> rawdataAst = new AST();
121 rawdataAst->SetFullName(rawdataType->GetFullName());
122 rawdataAst->AddRawDataDef(rawdataType);
123 rawdataAst->SetAStFileType(ASTFileType::AST_RAWDATA);
124 ast_->AddImport(rawdataAst);
125 ast_->AddRawDataDef(rawdataType);
126 }
127
ReadMetaInterface(MetaInterface * mi)128 void MetadataReader::ReadMetaInterface(MetaInterface* mi)
129 {
130 AutoPtr<ASTInterfaceType> interface = new ASTInterfaceType();
131 AutoPtr<ASTAttr> infAttr = new ASTAttr();
132 if (mi->properties_ == INTERFACE_PROPERTY_ONEWAY) {
133 infAttr->SetValue(ASTAttr::ONEWAY);
134 }
135 interface->SetAttribute(infAttr);
136 if (!mi->external_) {
137 interface->SetLicense(std::string(reinterpret_cast<char*>(mi->license_)));
138 ast_->SetLicense(std::string(reinterpret_cast<char*>(mi->license_)));
139 }
140 interface->SetName(std::string(reinterpret_cast<char*>(mi->name_)));
141
142 interface->SetNamespace(ast_->ParseNamespace(std::string(reinterpret_cast<char*>(mi->namespace_))));
143 interface->SetExternal(mi->external_);
144 ast_->AddInterfaceDef(interface);
145 for (int i = 0; i < mi->methodNumber_; i++) {
146 ReadMetaMethod(interface, mi->methods_[i]);
147 }
148 }
149
ReadMetaMethod(AutoPtr<ASTInterfaceType> & interface,MetaMethod * mm)150 void MetadataReader::ReadMetaMethod(AutoPtr<ASTInterfaceType>& interface, MetaMethod* mm)
151 {
152 AutoPtr<ASTMethod> method = new ASTMethod();
153 AutoPtr<ASTAttr> methodAttr = new ASTAttr();
154 if (mm->properties_ == METHOD_PROPERTY_ONEWAY) {
155 methodAttr->SetValue(ASTAttr::ONEWAY);
156 }
157 method->SetAttribute(methodAttr);
158
159 MetaType* type = metaComponent_->types_[mm->returnTypeIndex_];
160 method->SetReturnType(ReadMetaType(type));
161 method->SetName(std::string(reinterpret_cast<char*>((mm->name_))));
162 for (int i = 0; i < mm->parameterNumber_; i++) {
163 ReadMetaParam(method, mm->parameters_[i]);
164 }
165 interface->AddMethod(method);
166 }
167
ReadMetaParam(AutoPtr<ASTMethod> & method,MetaParameter * mp)168 void MetadataReader::ReadMetaParam(AutoPtr<ASTMethod>& method, MetaParameter* mp)
169 {
170 AutoPtr<ASTParamAttr> attr = new ASTParamAttr(ASTParamAttr::PARAM_NONE);
171
172 if ((mp->attributes_ & ATTR_IN) == ATTR_IN) {
173 attr->value_ |= ASTParamAttr::PARAM_IN;
174 }
175
176 if ((mp->attributes_ & ATTR_OUT) == ATTR_OUT) {
177 attr->value_ |= ASTParamAttr::PARAM_OUT;
178 }
179
180 MetaType* type = metaComponent_->types_[mp->typeIndex_];
181 AutoPtr<ASTParameter> param = new ASTParameter(std::string(reinterpret_cast<char*>((mp->name_))),
182 attr, ReadMetaType(type));
183 method->AddParameter(param);
184 }
185
ReadMetaType(MetaType * type)186 AutoPtr<ASTType> MetadataReader::ReadMetaType(MetaType* type)
187 {
188 std::string typeName = MetaTypeName(type);
189 AutoPtr<ASTType> astType = ast_->FindType(typeName);
190 switch (type->kind_) {
191 case MetaTypeKind::List:
192 if (astType == nullptr) {
193 MetaType* elementMt = metaComponent_->types_[type->nestedTypeIndexes_[0]];
194 AutoPtr<ASTListType> listType = new ASTListType();
195 listType->SetElementType(ReadMetaType(elementMt));
196 astType = listType.Get();
197 }
198 break;
199 case MetaTypeKind::Map:
200 if (astType == nullptr) {
201 MetaType* keyMt = metaComponent_->types_[type->nestedTypeIndexes_[0]];
202 MetaType* valueMt = metaComponent_->types_[type->nestedTypeIndexes_[1]];
203 AutoPtr<ASTMapType> mapType = new ASTMapType();
204 mapType->SetKeyType(ReadMetaType(keyMt));
205 mapType->SetValueType(ReadMetaType(valueMt));
206 astType = mapType.Get();
207 }
208 break;
209 case MetaTypeKind::Array:
210 if (astType == nullptr) {
211 MetaType* elementMt = metaComponent_->types_[type->nestedTypeIndexes_[0]];
212 AutoPtr<ASTArrayType> arrayType = new ASTArrayType();
213 arrayType->SetElementType(ReadMetaType(elementMt));
214 astType = arrayType.Get();
215 }
216 break;
217 default:
218 break;
219 }
220 ast_->AddType(astType);
221 return astType;
222 }
223
MetaTypeName(MetaType * mt)224 std::string MetadataReader::MetaTypeName(MetaType* mt)
225 {
226 switch (mt->kind_) {
227 case MetaTypeKind::Char:
228 return "char";
229 case MetaTypeKind::Boolean:
230 return "boolean";
231 case MetaTypeKind::Byte:
232 return "byte";
233 case MetaTypeKind::Short:
234 return "short";
235 case MetaTypeKind::Integer:
236 return "int";
237 case MetaTypeKind::Long:
238 return "long";
239 case MetaTypeKind::Float:
240 return "float";
241 case MetaTypeKind::Double:
242 return "double";
243 case MetaTypeKind::String:
244 return "String";
245 case MetaTypeKind::Void:
246 return "void";
247 case MetaTypeKind::Sequenceable:
248 case MetaTypeKind::RawData:
249 case MetaTypeKind::Interface:
250 return GetMetaTypeName(mt);
251 case MetaTypeKind::List: {
252 MetaType* elementMt = metaComponent_->types_[mt->nestedTypeIndexes_[0]];
253 return "List<" + MetaTypeName(elementMt) + ">";
254 }
255 case MetaTypeKind::Map: {
256 MetaType* keyMt = metaComponent_->types_[mt->nestedTypeIndexes_[0]];
257 MetaType* valueMt = metaComponent_->types_[mt->nestedTypeIndexes_[1]];
258 return "Map<" + MetaTypeName(keyMt) + ", " + MetaTypeName(valueMt) + ">";
259 }
260 case MetaTypeKind::Array: {
261 MetaType* elementMt = metaComponent_->types_[mt->nestedTypeIndexes_[0]];
262 return MetaTypeName(elementMt) + "[]";
263 }
264 case MetaTypeKind::Unknown:
265 default:
266 printf("Unknown %d\n", mt->index_);
267 return "unknown";
268 }
269 }
270
GetMetaTypeName(MetaType * mt)271 std::string MetadataReader::GetMetaTypeName(MetaType* mt)
272 {
273 switch (mt->kind_) {
274 case MetaTypeKind::Sequenceable: {
275 MetaSequenceable* mp = metaComponent_->sequenceables_[mt->index_];
276 return reinterpret_cast<char*>(mp->name_);
277 }
278 case MetaTypeKind::RawData: {
279 MetaRawData* mr = metaComponent_->rawdatas_[mt->index_];
280 return reinterpret_cast<char*>(mr->name_);
281 }
282 case MetaTypeKind::Interface: {
283 MetaInterface* mi = metaComponent_->interfaces_[mt->index_];
284 return reinterpret_cast<char*>(mi->name_);
285 }
286 default:
287 return "unknown";
288 }
289 }
290 } // namespace Idl
291 } // namespace OHOS
292