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 #include "metadata/metadata_builder.h"
17 #include <cstring>
18 #include "securec.h"
19 #include "ast/ast_array_type.h"
20 #include "ast/ast_map_type.h"
21 #include "util/logger.h"
22
23 #define ALIGN8(v) (((v) + 7) & ~7)
24
25 namespace OHOS {
26 namespace Idl {
27 std::string MetadataBuilder::tag_ = "MetadataBuilder";
Build()28 std::shared_ptr<MetaComponent> MetadataBuilder::Build()
29 {
30 if (!module_->IsValid()) {
31 Logger::E(tag_.c_str(), "The module is not validate.");
32 return nullptr;
33 }
34
35 size_ = CalculateMetadataSize();
36 if (size_ > 0) {
37 void* metadata = calloc(size_, 1);
38 if (metadata == nullptr) {
39 Logger::E(tag_.c_str(), "Out of memory.");
40 return nullptr;
41 }
42 metaComponent_.reset(
43 new(metadata) MetaComponent, [](MetaComponent* p) { free(p); });
44
45 WriteMetadata(reinterpret_cast<uintptr_t>(metadata));
46 } else {
47 return nullptr;
48 }
49
50 return metaComponent_;
51 }
52
CalculateMetadataSize()53 size_t MetadataBuilder::CalculateMetadataSize()
54 {
55 baseAddr_ = 0;
56 CalculateMetaComponent(module_);
57 return baseAddr_;
58 }
59
CalculateMetaComponent(AST * module)60 void MetadataBuilder::CalculateMetaComponent(AST* module)
61 {
62 size_t namespaceNumber = module->GetNamespaceNumber();
63 size_t sequenceableNumber = module->GetSequenceableDefNumber();
64 size_t rawdataNumber = module->GetRawDataDefNumber();
65 size_t interfaceNumber = module->GetInterfaceDefNumber();
66 size_t typeNumber = module->GetTypeNumber();
67
68 // begin address
69 baseAddr_ = ALIGN8(baseAddr_);
70 stringPool_.Add(module_->GetName());
71 // namespaces_'s address
72 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaComponent));
73 // sequenceables_'s address
74 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber);
75 // rawdata_'s address
76 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaSequenceable*) * sequenceableNumber);
77 // interfaces_'s address
78 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaRawData*) * rawdataNumber);
79 // types_'s address
80 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface*) * interfaceNumber);
81 // stringPool_'s address
82 baseAddr_ = baseAddr_ + sizeof(MetaType*) * typeNumber;
83
84 for (size_t i = 0; i < namespaceNumber; i++) {
85 CalculateMetaNamespace(module->GetNamespace(i));
86 }
87
88 for (size_t i = 0; i < sequenceableNumber; i++) {
89 CalculateMetaSequenceable(module->GetSequenceableDef(i));
90 }
91
92 for (size_t i = 0; i < rawdataNumber; i++) {
93 CalculateMetaRawData(module->GetRawDataDef(i));
94 }
95
96 for (size_t i = 0; i < interfaceNumber; i++) {
97 CalculateMetaInterface(module->GetInterfaceDef(i));
98 }
99
100 const AST::TypeStringMap& types = module_->GetTypes();
101 for (const auto& pair : types) {
102 CalculateMetaType(pair.second);
103 }
104
105 // end address
106 CalculateStringPool();
107 }
108
CalculateMetaNamespace(ASTNamespace * nspace)109 void MetadataBuilder::CalculateMetaNamespace(ASTNamespace* nspace)
110 {
111 size_t sequenceableNumber = nspace->GetSequenceableNumber();
112 size_t rawdataNumber = nspace->GetRawDataNumber();
113 size_t interfaceNumber = nspace->GetInterfaceNumber();
114 size_t namespaceNumber = nspace->GetNamespaceNumber();
115
116 // begin address
117 baseAddr_ = ALIGN8(baseAddr_);
118 stringPool_.Add(nspace->GetName());
119 // sequenceables_'s address
120 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace));
121 // rawdatas_'s address
122 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * sequenceableNumber);
123 // interfaces_'s address
124 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * rawdataNumber);
125 // namespaces_'s address
126 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * interfaceNumber);
127 // end address
128 baseAddr_ = baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber;
129
130 for (size_t i = 0; i < namespaceNumber; i++) {
131 CalculateMetaNamespace(nspace->GetNamespace(i));
132 }
133 }
134
CalculateMetaSequenceable(ASTSequenceableType * sequenceable)135 void MetadataBuilder::CalculateMetaSequenceable(ASTSequenceableType* sequenceable)
136 {
137 // begin address
138 baseAddr_ = ALIGN8(baseAddr_);
139 stringPool_.Add(sequenceable->GetName());
140 stringPool_.Add(sequenceable->GetNamespace()->ToString());
141 // end address
142 baseAddr_ = baseAddr_ + sizeof(MetaSequenceable);
143 }
144
CalculateMetaRawData(ASTRawDataType * rawdata)145 void MetadataBuilder::CalculateMetaRawData(ASTRawDataType* rawdata)
146 {
147 // begin address
148 baseAddr_ = ALIGN8(baseAddr_);
149 stringPool_.Add(rawdata->GetName());
150 stringPool_.Add(rawdata->GetNamespace()->ToString());
151 // end address
152 baseAddr_ = baseAddr_ + sizeof(MetaRawData);
153 }
154
CalculateMetaInterface(ASTInterfaceType * interface)155 void MetadataBuilder::CalculateMetaInterface(ASTInterfaceType* interface)
156 {
157 size_t methodNumber = interface->GetMethodNumber();
158
159 // begin address
160 baseAddr_ = ALIGN8(baseAddr_);
161 stringPool_.Add(interface->GetLicense());
162 stringPool_.Add(interface->GetName());
163 stringPool_.Add(interface->GetNamespace()->ToString());
164 // methods_'s address
165 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface));
166 // end address
167 baseAddr_ = baseAddr_ + sizeof(MetaMethod*) * methodNumber;
168
169 for (size_t i = 0; i < methodNumber; i++) {
170 CalculateMetaMethod(interface->GetMethod(i));
171 }
172 }
173
CalculateMetaMethod(ASTMethod * method)174 void MetadataBuilder::CalculateMetaMethod(ASTMethod* method)
175 {
176 size_t parameterNumber = method->GetParameterNumber();
177
178 // begin address
179 baseAddr_ = ALIGN8(baseAddr_);
180 stringPool_.Add(method->GetName());
181 stringPool_.Add(method->GetSignature());
182 // parameters_'s address
183 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaMethod));
184 // end address
185 baseAddr_ = baseAddr_ + sizeof(MetaParameter*) * parameterNumber;
186
187 for (size_t i = 0; i < parameterNumber; i++) {
188 CalculateMetaParameter(method->GetParameter(i));
189 }
190 }
191
CalculateMetaParameter(ASTParameter * parameter)192 void MetadataBuilder::CalculateMetaParameter(ASTParameter* parameter)
193 {
194 // begin address
195 baseAddr_ = ALIGN8(baseAddr_);
196 stringPool_.Add(parameter->GetName());
197 // end address
198 baseAddr_ = baseAddr_ + sizeof(MetaParameter);
199 }
200
CalculateMetaType(ASTType * type)201 void MetadataBuilder::CalculateMetaType(ASTType* type)
202 {
203 // begin address
204 baseAddr_ = ALIGN8(baseAddr_);
205 // nestedTypeIndexes_'s address
206 baseAddr_ = baseAddr_ + sizeof(MetaType);
207 if (type->IsListType()) {
208 baseAddr_ = ALIGN8(baseAddr_);
209 // end address
210 baseAddr_ = baseAddr_ + sizeof(int*);
211 } else if (type->IsMapType()) {
212 // end address
213 size_t typeNumber = 2;
214 baseAddr_ = baseAddr_ + sizeof(int*) * typeNumber;
215 } else if (type->IsArrayType()) {
216 baseAddr_ = baseAddr_ + sizeof(int*);
217 }
218 }
219
CalculateStringPool()220 void MetadataBuilder::CalculateStringPool()
221 {
222 // begin address
223 baseAddr_ = ALIGN8(baseAddr_);
224 // end address
225 baseAddr_ = baseAddr_ + stringPool_.GetSize();
226 }
227
WriteMetadata(uintptr_t base)228 void MetadataBuilder::WriteMetadata(uintptr_t base)
229 {
230 baseAddr_ = base;
231 WriteMetaComponent(module_);
232 }
233
WriteMetaComponent(AST * module)234 void MetadataBuilder::WriteMetaComponent(AST* module)
235 {
236 size_t namespaceNumber = module->GetNamespaceNumber();
237 size_t sequenceableNumber = module->GetSequenceableDefNumber();
238 size_t rawdataNumber = module->GetRawDataDefNumber();
239 size_t interfaceNumber = module->GetInterfaceDefNumber();
240 size_t typeNumber = module->GetTypeNumber();
241
242 // begin address
243 baseAddr_ = ALIGN8(baseAddr_);
244 MetaComponent* mc = reinterpret_cast<MetaComponent*>(baseAddr_);
245 mc->magic_ = METADATA_MAGIC_NUMBER;
246 mc->size_ = static_cast<int>(size_);
247 mc->namespaceNumber_ = static_cast<int>(namespaceNumber);
248 mc->sequenceableNumber_ = static_cast<int>(sequenceableNumber);
249 mc->rawdataNumber_ = static_cast<int>(rawdataNumber);
250 mc->interfaceNumber_ = static_cast<int>(interfaceNumber);
251 mc->typeNumber_ = static_cast<int>(typeNumber);
252 mc->stringPoolSize_ = static_cast<int>(stringPool_.GetSize());
253 // namespaces_'s address
254 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaComponent));
255 mc->namespaces_ = reinterpret_cast<MetaNamespace**>(baseAddr_);
256 // sequenceables_'s address
257 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber);
258 mc->sequenceables_ = reinterpret_cast<MetaSequenceable**>(baseAddr_);
259 // rawdatas_'s address
260 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaSequenceable*) * sequenceableNumber);
261 mc->rawdatas_ = reinterpret_cast<MetaRawData**>(baseAddr_);
262 // interfaces_'s address
263 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaRawData*) * rawdataNumber);
264 mc->interfaces_ = reinterpret_cast<MetaInterface**>(baseAddr_);
265 // types_'s address
266 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface*) * interfaceNumber);
267 mc->types_ = reinterpret_cast<MetaType**>(baseAddr_);
268 // stringPool_'s address
269 baseAddr_ = baseAddr_ + sizeof(MetaType*) * typeNumber;
270 mc->stringPool_ = reinterpret_cast<char*>(baseAddr_);
271 // end address
272 baseAddr_ = baseAddr_ + stringPool_.GetSize();
273 (void)memcpy_s(mc->stringPool_, stringPool_.GetSize(), stringPool_.GetData(), stringPool_.GetSize());
274
275 mc->name_ = WriteString(module->GetName());
276
277 for (size_t i = 0; i < namespaceNumber; i++) {
278 mc->namespaces_[i] = WriteMetaNamespace(module->GetNamespace(i));
279 }
280
281 for (size_t i = 0; i < sequenceableNumber; i++) {
282 mc->sequenceables_[i] = WriteMetaSequenceable(module->GetSequenceableDef(i));
283 }
284
285 for (size_t i = 0; i < rawdataNumber; i++) {
286 mc->rawdatas_[i] = WriteMetaRawData(module->GetRawDataDef(i));
287 }
288
289 for (size_t i = 0; i < interfaceNumber; i++) {
290 mc->interfaces_[i] = WriteMetaInterface(module->GetInterfaceDef(i));
291 }
292
293 const AST::TypeStringMap& types = module->GetTypes();
294 int i = 0;
295 for (const auto& pair : types) {
296 mc->types_[i++] = WriteMetaType(pair.second);
297 }
298 }
299
WriteMetaNamespace(ASTNamespace * nspace)300 MetaNamespace* MetadataBuilder::WriteMetaNamespace(ASTNamespace* nspace)
301 {
302 size_t sequenceableNumber = nspace->GetSequenceableNumber();
303 size_t rawdataNumber = nspace->GetRawDataNumber();
304 size_t interfaceNumber = nspace->GetInterfaceNumber();
305 size_t namespaceNumber = nspace->GetNamespaceNumber();
306
307 // begin address
308 baseAddr_ = ALIGN8(baseAddr_);
309 MetaNamespace* mn = reinterpret_cast<MetaNamespace*>(baseAddr_);
310 mn->name_ = WriteString(nspace->GetName());
311 mn->sequenceableNumber_ = static_cast<int>(sequenceableNumber);
312 mn->rawdataNumber_ = static_cast<int>(rawdataNumber);
313 mn->interfaceNumber_ = static_cast<int>(interfaceNumber);
314 mn->namespaceNumber_ = static_cast<int>(namespaceNumber);
315 // sequenceables_'s address
316 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaNamespace));
317 mn->sequenceableIndexes_ = reinterpret_cast<int*>(baseAddr_);
318 // rawdata_'s address
319 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * sequenceableNumber);
320 mn->rawdataIndexes_ = reinterpret_cast<int*>(baseAddr_);
321 // interfaces_'s address
322 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * rawdataNumber);
323 mn->interfaceIndexes_ = reinterpret_cast<int*>(baseAddr_);
324 // namespaces_'s address
325 baseAddr_ = ALIGN8(baseAddr_ + sizeof(int) * interfaceNumber);
326 mn->namespaces_ = reinterpret_cast<MetaNamespace**>(baseAddr_);
327 // end address
328 baseAddr_ = baseAddr_ + sizeof(MetaNamespace*) * namespaceNumber;
329
330 for (size_t i = 0; i < sequenceableNumber; i++) {
331 AutoPtr<ASTSequenceableType> sequenceable = nspace->GetSequenceable(i);
332 mn->sequenceableIndexes_[i] = module_->IndexOf(sequenceable.Get());
333 }
334
335 for (size_t i = 0; i < rawdataNumber; i++) {
336 AutoPtr<ASTRawDataType> rawdata = nspace->GetRawData(i);
337 mn->rawdataIndexes_[i] = module_->IndexOf(rawdata.Get());
338 }
339
340 for (size_t i = 0; i < interfaceNumber; i++) {
341 AutoPtr<ASTInterfaceType> interface = nspace->GetInterface(i);
342 mn->interfaceIndexes_[i] = module_->IndexOf(interface.Get());
343 }
344
345 for (size_t i = 0; i < namespaceNumber; i++) {
346 AutoPtr<ASTNamespace> inner = nspace->GetNamespace(i);
347 mn->namespaces_[i] = WriteMetaNamespace(inner);
348 }
349
350 return mn;
351 }
352
WriteMetaSequenceable(ASTSequenceableType * parcelabe)353 MetaSequenceable* MetadataBuilder::WriteMetaSequenceable(ASTSequenceableType* parcelabe)
354 {
355 // begin address
356 baseAddr_ = ALIGN8(baseAddr_);
357 MetaSequenceable* mp = reinterpret_cast<MetaSequenceable*>(baseAddr_);
358 mp->name_ = WriteString(parcelabe->GetName());
359 mp->namespace_ = WriteString(parcelabe->GetNamespace()->ToString());
360 // end address
361 baseAddr_ = baseAddr_ + sizeof(MetaSequenceable);
362
363 return mp;
364 }
365
WriteMetaRawData(ASTRawDataType * parcelabe)366 MetaRawData* MetadataBuilder::WriteMetaRawData(ASTRawDataType* parcelabe)
367 {
368 // begin address
369 baseAddr_ = ALIGN8(baseAddr_);
370 MetaRawData* mp = reinterpret_cast<MetaRawData*>(baseAddr_);
371 mp->name_ = WriteString(parcelabe->GetName());
372 mp->namespace_ = WriteString(parcelabe->GetNamespace()->ToString());
373 // end address
374 baseAddr_ = baseAddr_ + sizeof(MetaRawData);
375
376 return mp;
377 }
378
379
WriteMetaInterface(ASTInterfaceType * interface)380 MetaInterface* MetadataBuilder::WriteMetaInterface(ASTInterfaceType* interface)
381 {
382 size_t methodNumber = interface->GetMethodNumber();
383
384 // begin address
385 baseAddr_ = ALIGN8(baseAddr_);
386 MetaInterface* mi = reinterpret_cast<MetaInterface*>(baseAddr_);
387 mi->license_ = WriteString(interface->GetLicense());
388 mi->name_ = WriteString(interface->GetName());
389 mi->namespace_ = WriteString(interface->GetNamespace()->ToString());
390 mi->properties_ = interface->GetAttribute()->GetValue() == ASTAttr::ONEWAY ? INTERFACE_PROPERTY_ONEWAY : 0;
391 mi->methodNumber_ = static_cast<int>(methodNumber);
392 mi->external_ = interface->IsExternal();
393 // methods_'s address
394 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaInterface));
395 mi->methods_ = reinterpret_cast<MetaMethod**>(baseAddr_);
396 // end address
397 baseAddr_ = baseAddr_ + sizeof(MetaMethod*) * methodNumber;
398
399 for (size_t i = 0; i < methodNumber; i++) {
400 mi->methods_[i] = WriteMetaMethod(interface->GetMethod(i));
401 }
402
403 return mi;
404 }
405
WriteMetaMethod(ASTMethod * method)406 MetaMethod* MetadataBuilder::WriteMetaMethod(ASTMethod* method)
407 {
408 size_t parameterNumber = method->GetParameterNumber();
409
410 // begin address
411 baseAddr_ = ALIGN8(baseAddr_);
412 MetaMethod* mm = reinterpret_cast<MetaMethod*>(baseAddr_);
413 mm->name_ = WriteString(method->GetName());
414 mm->signature_ = WriteString(method->GetSignature());
415 mm->properties_ = method->GetAttribute()->GetValue() == ASTAttr::ONEWAY ? METHOD_PROPERTY_ONEWAY : 0;
416 mm->returnTypeIndex_ = module_->IndexOf(method->GetReturnType());
417 mm->parameterNumber_ = static_cast<int>(parameterNumber);
418 // parameters_'s address
419 baseAddr_ = ALIGN8(baseAddr_ + sizeof(MetaMethod));
420 mm->parameters_ = reinterpret_cast<MetaParameter**>(baseAddr_);
421 // end address
422 baseAddr_ = baseAddr_ + sizeof(MetaParameter*) * parameterNumber;
423
424 for (size_t i = 0; i < parameterNumber; i++) {
425 mm->parameters_[i] = WriteMetaParameter(method->GetParameter(i));
426 }
427
428 return mm;
429 }
430
WriteMetaParameter(ASTParameter * parameter)431 MetaParameter* MetadataBuilder::WriteMetaParameter(ASTParameter* parameter)
432 {
433 // begin address
434 baseAddr_ = ALIGN8(baseAddr_);
435 MetaParameter* mp = reinterpret_cast<MetaParameter*>(baseAddr_);
436 mp->name_ = WriteString(parameter->GetName());
437 if (parameter->GetAttribute() & ASTParamAttr::PARAM_IN) {
438 mp->attributes_ |= ATTR_IN;
439 }
440 if (parameter->GetAttribute() & ASTParamAttr::PARAM_OUT) {
441 mp->attributes_ |= ATTR_OUT;
442 }
443 mp->typeIndex_ = module_->IndexOf(parameter->GetType());
444 // end address
445 baseAddr_ = baseAddr_ + sizeof(MetaParameter);
446
447 return mp;
448 }
449
WriteMetaType(ASTType * type)450 MetaType* MetadataBuilder::WriteMetaType(ASTType* type)
451 {
452 // begin address
453 baseAddr_ = ALIGN8(baseAddr_);
454 MetaType* mt = reinterpret_cast<MetaType*>(baseAddr_);
455 mt->kind_ = Type2Kind(type);
456 if (type->IsSequenceableType()) {
457 mt->index_ = module_->IndexOf(static_cast<ASTSequenceableType*>(type));
458 } else if (type->IsRawDataType()) {
459 mt->index_ = module_->IndexOf(static_cast<ASTRawDataType*>(type));
460 } else if (type->IsInterfaceType()) {
461 mt->index_ = module_->IndexOf(static_cast<ASTInterfaceType*>(type));
462 } else {
463 mt->index_ = module_->IndexOf(type);
464 }
465 baseAddr_ = baseAddr_ + sizeof(MetaType);
466 if (type->IsListType()) {
467 mt->nestedTypeNumber_ = 1;
468 // nestedTypeIndexes_'s address
469 baseAddr_ = ALIGN8(baseAddr_);
470 mt->nestedTypeIndexes_ = reinterpret_cast<int*>(baseAddr_);
471 AutoPtr<ASTType> elementType = (static_cast<ASTListType*>(type))->GetElementType();
472 mt->nestedTypeIndexes_[0] = module_->IndexOf(elementType);
473 // end address
474 baseAddr_ = baseAddr_ + sizeof(int*);
475 } else if (type->IsMapType()) {
476 size_t typeNumber = 2;
477 mt->nestedTypeNumber_ = static_cast<int>(typeNumber);
478 // nestedTypeIndexes_'s address
479 baseAddr_ = ALIGN8(baseAddr_);
480 mt->nestedTypeIndexes_ = reinterpret_cast<int*>(baseAddr_);
481 AutoPtr<ASTType> keyType = (static_cast<ASTMapType*>(type))->GetKeyType();
482 AutoPtr<ASTType> valueType = (static_cast<ASTMapType*>(type))->GetValueType();
483 mt->nestedTypeIndexes_[0] = module_->IndexOf(keyType);
484 mt->nestedTypeIndexes_[1] = module_->IndexOf(valueType);
485 // end address
486 baseAddr_ = baseAddr_ + sizeof(int*) * typeNumber;
487 } else if (type->IsArrayType()) {
488 mt->nestedTypeNumber_ = 1;
489 // nestedTypeIndexes_'s address
490 baseAddr_ = ALIGN8(baseAddr_);
491 mt->nestedTypeIndexes_ = reinterpret_cast<int*>(baseAddr_);
492 AutoPtr<ASTType> elementType = (static_cast<ASTArrayType*>(type))->GetElementType();
493 mt->nestedTypeIndexes_[0] = module_->IndexOf(elementType);
494 // end address
495 baseAddr_ = baseAddr_ + sizeof(int*);
496 }
497
498 return mt;
499 }
500
WriteString(const std::string & string)501 char* MetadataBuilder::WriteString(const std::string& string)
502 {
503 return string.empty() ? nullptr : metaComponent_->stringPool_ + stringPool_.GetOffset(string);
504 }
505
Type2Kind(ASTType * type)506 MetaTypeKind MetadataBuilder::Type2Kind(ASTType* type)
507 {
508 if (type->IsCharType()) {
509 return MetaTypeKind::Char;
510 } else if (type->IsBooleanType()) {
511 return MetaTypeKind::Boolean;
512 } else if (type->IsByteType()) {
513 return MetaTypeKind::Byte;
514 } else if (type->IsShortType()) {
515 return MetaTypeKind::Short;
516 } else if (type->IsIntegerType()) {
517 return MetaTypeKind::Integer;
518 } else if (type->IsLongType()) {
519 return MetaTypeKind::Long;
520 } else if (type->IsFloatType()) {
521 return MetaTypeKind::Float;
522 } else if (type->IsDoubleType()) {
523 return MetaTypeKind::Double;
524 } else if (type->IsStringType()) {
525 return MetaTypeKind::String;
526 } else if (type->IsVoidType()) {
527 return MetaTypeKind::Void;
528 } else if (type->IsSequenceableType()) {
529 return MetaTypeKind::Sequenceable;
530 } else if (type->IsRawDataType()) {
531 return MetaTypeKind::RawData;
532 } else if (type->IsInterfaceType()) {
533 return MetaTypeKind::Interface;
534 } else if (type->IsListType()) {
535 return MetaTypeKind::List;
536 } else if (type->IsMapType()) {
537 return MetaTypeKind::Map;
538 } else if (type->IsArrayType()) {
539 return MetaTypeKind::Array;
540 }
541 return MetaTypeKind::Unknown;
542 }
543 } // namespace Idl
544 } // namespace OHOS
545