| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "fidl/coded_types_generator.h" |
| |
| #include "fidl/names.h" |
| |
| namespace fidl { |
| |
| const coded::Type* CodedTypesGenerator::CompileType(const flat::Type* type) { |
| switch (type->kind) { |
| case flat::Type::Kind::kArray: { |
| auto array_type = static_cast<const flat::ArrayType*>(type); |
| auto iter = array_type_map_.find(array_type); |
| if (iter != array_type_map_.end()) |
| return iter->second; |
| auto coded_element_type = CompileType(array_type->element_type.get()); |
| uint32_t array_size = array_type->size; |
| uint32_t element_size = array_type->element_type->size; |
| auto name = NameCodedArray(coded_element_type->coded_name, array_size); |
| auto coded_array_type = std::make_unique<coded::ArrayType>( |
| std::move(name), coded_element_type, array_size, element_size); |
| array_type_map_[array_type] = coded_array_type.get(); |
| coded_types_.push_back(std::move(coded_array_type)); |
| return coded_types_.back().get(); |
| } |
| case flat::Type::Kind::kVector: { |
| auto vector_type = static_cast<const flat::VectorType*>(type); |
| auto iter = vector_type_map_.find(vector_type); |
| if (iter != vector_type_map_.end()) |
| return iter->second; |
| auto coded_element_type = CompileType(vector_type->element_type.get()); |
| uint32_t max_count = |
| static_cast<const flat::Size&>(vector_type->element_count->Value()).value; |
| uint32_t element_size = coded_element_type->size; |
| StringView element_name = coded_element_type->coded_name; |
| auto name = NameCodedVector(element_name, max_count, vector_type->nullability); |
| auto coded_vector_type = std::make_unique<coded::VectorType>( |
| std::move(name), coded_element_type, max_count, element_size, vector_type->nullability); |
| vector_type_map_[vector_type] = coded_vector_type.get(); |
| coded_types_.push_back(std::move(coded_vector_type)); |
| return coded_types_.back().get(); |
| } |
| case flat::Type::Kind::kString: { |
| auto string_type = static_cast<const flat::StringType*>(type); |
| auto iter = string_type_map_.find(string_type); |
| if (iter != string_type_map_.end()) |
| return iter->second; |
| uint32_t max_size = |
| static_cast<const flat::Size&>(string_type->max_size->Value()).value; |
| auto name = NameCodedString(max_size, string_type->nullability); |
| auto coded_string_type = std::make_unique<coded::StringType>(std::move(name), max_size, |
| string_type->nullability); |
| string_type_map_[string_type] = coded_string_type.get(); |
| coded_types_.push_back(std::move(coded_string_type)); |
| return coded_types_.back().get(); |
| } |
| case flat::Type::Kind::kHandle: { |
| auto handle_type = static_cast<const flat::HandleType*>(type); |
| auto iter = handle_type_map_.find(handle_type); |
| if (iter != handle_type_map_.end()) |
| return iter->second; |
| auto name = NameCodedHandle(handle_type->subtype, handle_type->nullability); |
| auto coded_handle_type = std::make_unique<coded::HandleType>( |
| std::move(name), handle_type->subtype, handle_type->nullability); |
| handle_type_map_[handle_type] = coded_handle_type.get(); |
| coded_types_.push_back(std::move(coded_handle_type)); |
| return coded_types_.back().get(); |
| } |
| case flat::Type::Kind::kRequestHandle: { |
| auto request_type = static_cast<const flat::RequestHandleType*>(type); |
| auto iter = request_type_map_.find(request_type); |
| if (iter != request_type_map_.end()) |
| return iter->second; |
| auto name = NameCodedRequestHandle(NameName(request_type->name, "_", "_"), request_type->nullability); |
| auto coded_request_type = |
| std::make_unique<coded::RequestHandleType>(std::move(name), request_type->nullability); |
| request_type_map_[request_type] = coded_request_type.get(); |
| coded_types_.push_back(std::move(coded_request_type)); |
| return coded_types_.back().get(); |
| } |
| case flat::Type::Kind::kPrimitive: { |
| auto primitive_type = static_cast<const flat::PrimitiveType*>(type); |
| auto iter = primitive_type_map_.find(primitive_type); |
| if (iter != primitive_type_map_.end()) |
| return iter->second; |
| auto name = NamePrimitiveSubtype(primitive_type->subtype); |
| auto coded_primitive_type = std::make_unique<coded::PrimitiveType>( |
| std::move(name), primitive_type->subtype, |
| flat::PrimitiveType::SubtypeSize(primitive_type->subtype)); |
| primitive_type_map_[primitive_type] = coded_primitive_type.get(); |
| coded_types_.push_back(std::move(coded_primitive_type)); |
| return coded_types_.back().get(); |
| } |
| case flat::Type::Kind::kIdentifier: { |
| auto identifier_type = static_cast<const flat::IdentifierType*>(type); |
| auto iter = named_coded_types_.find(&identifier_type->name); |
| if (iter == named_coded_types_.end()) { |
| assert(false && "unknown type in named type map!"); |
| } |
| // We may need to set the emit-pointer bit on structs, unions, and xunions now. |
| auto coded_type = iter->second.get(); |
| switch (coded_type->kind) { |
| case coded::Type::Kind::kStruct: { |
| // Structs were compiled as part of decl compilation, |
| // but we may now need to generate the StructPointer. |
| if (identifier_type->nullability != types::Nullability::kNullable) |
| break; |
| auto coded_struct_type = static_cast<coded::StructType*>(coded_type); |
| coded_struct_type->referenced_by_pointer = true; |
| coded_types_.push_back(std::make_unique<coded::StructPointerType>( |
| coded_struct_type->pointer_name, coded_struct_type)); |
| return coded_types_.back().get(); |
| } |
| case coded::Type::Kind::kTable: { |
| // Tables were compiled as part of decl compilation, |
| // but we may now need to generate the TablePointer. |
| if (identifier_type->nullability != types::Nullability::kNullable) |
| break; |
| auto coded_table_type = static_cast<coded::TableType*>(coded_type); |
| coded_table_type->referenced_by_pointer = true; |
| coded_types_.push_back(std::make_unique<coded::TablePointerType>( |
| coded_table_type->pointer_name, coded_table_type)); |
| return coded_types_.back().get(); |
| } |
| case coded::Type::Kind::kUnion: { |
| // Unions were compiled as part of decl compilation, |
| // but we may now need to generate the UnionPointer. |
| if (identifier_type->nullability != types::Nullability::kNullable) |
| break; |
| auto coded_union_type = static_cast<coded::UnionType*>(coded_type); |
| coded_union_type->referenced_by_pointer = true; |
| coded_types_.push_back(std::make_unique<coded::UnionPointerType>( |
| coded_union_type->pointer_name, coded_union_type)); |
| return coded_types_.back().get(); |
| } |
| case coded::Type::Kind::kXUnion: { |
| // XUnions were compiled as part of decl compilation, |
| // but we may now need to generate the XUnionPointer. |
| if (identifier_type->nullability != types::Nullability::kNullable) |
| break; |
| auto coded_xunion_type = static_cast<coded::XUnionType*>(coded_type); |
| coded_xunion_type->referenced_by_pointer = true; |
| coded_types_.push_back(std::make_unique<coded::XUnionPointerType>( |
| coded_xunion_type->pointer_name, coded_xunion_type)); |
| return coded_types_.back().get(); |
| } |
| case coded::Type::Kind::kInterface: { |
| auto iter = interface_type_map_.find(identifier_type); |
| if (iter != interface_type_map_.end()) |
| return iter->second; |
| auto name = NameCodedInterfaceHandle(NameName(identifier_type->name, "_", "_"), |
| identifier_type->nullability); |
| auto coded_interface_type = std::make_unique<coded::InterfaceHandleType>( |
| std::move(name), identifier_type->nullability); |
| interface_type_map_[identifier_type] = coded_interface_type.get(); |
| coded_types_.push_back(std::move(coded_interface_type)); |
| return coded_types_.back().get(); |
| } |
| case coded::Type::Kind::kPrimitive: |
| // These are from enums. We don't need to do anything with them. |
| break; |
| case coded::Type::Kind::kInterfaceHandle: |
| case coded::Type::Kind::kStructPointer: |
| case coded::Type::Kind::kTablePointer: |
| case coded::Type::Kind::kUnionPointer: |
| case coded::Type::Kind::kXUnionPointer: |
| case coded::Type::Kind::kMessage: |
| case coded::Type::Kind::kRequestHandle: |
| case coded::Type::Kind::kHandle: |
| case coded::Type::Kind::kArray: |
| case coded::Type::Kind::kVector: |
| case coded::Type::Kind::kString: |
| assert(false && "anonymous type in named type map!"); |
| break; |
| } |
| return coded_type; |
| } |
| } |
| } |
| |
| void CodedTypesGenerator::CompileFields(const flat::Decl* decl) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kInterface: { |
| auto interface_decl = static_cast<const flat::Interface*>(decl); |
| coded::InterfaceType* coded_interface = |
| static_cast<coded::InterfaceType*>(named_coded_types_[&decl->name].get()); |
| size_t i = 0; |
| for (const auto& method_pointer : interface_decl->all_methods) { |
| assert(method_pointer != nullptr); |
| const auto& method = *method_pointer; |
| auto CompileMessage = [&](const flat::Struct& message) -> void { |
| std::unique_ptr<coded::MessageType>& coded_message = coded_interface->messages[i++]; |
| std::vector<coded::StructField>& request_fields = coded_message->fields; |
| for (const auto& parameter : message.members) { |
| std::string parameter_name = |
| coded_message->coded_name + "_" + std::string(parameter.name.data()); |
| auto coded_parameter_type = CompileType(parameter.type.get()); |
| if (coded_parameter_type->coding_needed == coded::CodingNeeded::kNeeded) |
| request_fields.emplace_back(coded_parameter_type, |
| parameter.fieldshape.Offset()); |
| } |
| // We move the coded_message to coded_types_ so that we'll generate tables for the |
| // message |
| // in the proper order. |
| coded_types_.push_back(std::move(coded_message)); |
| }; |
| if (method.maybe_request) { |
| CompileMessage(*method.maybe_request); |
| } |
| if (method.maybe_response) { |
| CompileMessage(*method.maybe_response); |
| } |
| } |
| break; |
| } |
| case flat::Decl::Kind::kStruct: { |
| auto struct_decl = static_cast<const flat::Struct*>(decl); |
| if (struct_decl->anonymous) |
| break; |
| coded::StructType* coded_struct = |
| static_cast<coded::StructType*>(named_coded_types_[&decl->name].get()); |
| std::vector<coded::StructField>& struct_fields = coded_struct->fields; |
| for (const auto& member : struct_decl->members) { |
| std::string member_name = |
| coded_struct->coded_name + "_" + std::string(member.name.data()); |
| auto coded_member_type = CompileType(member.type.get()); |
| if (coded_member_type->coding_needed == coded::CodingNeeded::kNeeded) |
| struct_fields.emplace_back(coded_member_type, member.fieldshape.Offset()); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kUnion: { |
| auto union_decl = static_cast<const flat::Union*>(decl); |
| coded::UnionType* union_struct = |
| static_cast<coded::UnionType*>(named_coded_types_[&decl->name].get()); |
| std::vector<const coded::Type*>& union_members = union_struct->types; |
| for (const auto& member : union_decl->members) { |
| std::string member_name = |
| union_struct->coded_name + "_" + std::string(member.name.data()); |
| auto coded_member_type = CompileType(member.type.get()); |
| if (coded_member_type->coding_needed == coded::CodingNeeded::kNeeded) { |
| union_members.push_back(coded_member_type); |
| } else { |
| // We need union_members.size() to match union_decl->members.size() because |
| // the coding tables will use the union |tag| to index into the member array. |
| union_members.push_back(nullptr); |
| } |
| } |
| break; |
| } |
| case flat::Decl::Kind::kXUnion: { |
| auto xunion_decl = static_cast<const flat::XUnion*>(decl); |
| auto coded_xunion = |
| static_cast<coded::XUnionType*>(named_coded_types_[&decl->name].get()); |
| |
| std::map<uint32_t, const flat::XUnion::Member*> members; |
| for (const auto& member : xunion_decl->members) { |
| if (!members.emplace(member.ordinal->value, &member).second) { |
| assert(false && "Duplicate ordinal found in table generation"); |
| } |
| } |
| |
| for (const auto& member_pair : members) { |
| const auto& member = *member_pair.second; |
| auto coded_member_type = CompileType(member.type.get()); |
| if (coded_member_type->coding_needed == coded::CodingNeeded::kNeeded) { |
| coded_xunion->fields.emplace_back(coded_member_type, member.ordinal->value); |
| } |
| } |
| break; |
| } |
| case flat::Decl::Kind::kTable: { |
| auto table_decl = static_cast<const flat::Table*>(decl); |
| coded::TableType* coded_table = |
| static_cast<coded::TableType*>(named_coded_types_[&decl->name].get()); |
| std::vector<coded::TableField>& table_fields = coded_table->fields; |
| std::map<uint32_t, const flat::Table::Member*> members; |
| for (const auto& member : table_decl->members) { |
| if (!members.emplace(member.ordinal->value, &member).second) { |
| assert(false && "Duplicate ordinal found in table generation"); |
| } |
| } |
| for (const auto& member_pair : members) { |
| const auto& member = *member_pair.second; |
| if (!member.maybe_used) |
| continue; |
| std::string member_name = |
| coded_table->coded_name + "_" + std::string(member.maybe_used->name.data()); |
| auto coded_member_type = CompileType(member.maybe_used->type.get()); |
| if (coded_member_type->coding_needed == coded::CodingNeeded::kNeeded) |
| table_fields.emplace_back(coded_member_type, member.ordinal->value); |
| } |
| break; |
| } |
| default: { |
| break; |
| } |
| } |
| } |
| |
| void CodedTypesGenerator::CompileDecl(const flat::Decl* decl) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: |
| // Nothing to do for const declarations. |
| break; |
| case flat::Decl::Kind::kEnum: { |
| auto enum_decl = static_cast<const flat::Enum*>(decl); |
| std::string enum_name = NameName(enum_decl->name, "_", "_"); |
| named_coded_types_.emplace(&enum_decl->name, |
| std::make_unique<coded::PrimitiveType>( |
| std::move(enum_name), enum_decl->type->subtype, |
| flat::PrimitiveType::SubtypeSize(enum_decl->type->subtype))); |
| break; |
| } |
| case flat::Decl::Kind::kInterface: { |
| auto interface_decl = static_cast<const flat::Interface*>(decl); |
| std::string interface_name = NameInterface(*interface_decl); |
| std::string interface_qname = NameName(interface_decl->name, ".", "/"); |
| std::vector<std::unique_ptr<coded::MessageType>> interface_messages; |
| for (const auto& method_pointer : interface_decl->all_methods) { |
| assert(method_pointer != nullptr); |
| const auto& method = *method_pointer; |
| std::string method_name = NameMethod(interface_name, method); |
| std::string method_qname = NameMethod(interface_qname, method); |
| auto CreateMessage = [&](const flat::Struct& message, |
| types::MessageKind kind) -> void { |
| std::string message_name = NameMessage(method_name, kind); |
| std::string message_qname = NameMessage(method_qname, kind); |
| interface_messages.push_back(std::make_unique<coded::MessageType>( |
| std::move(message_name), std::vector<coded::StructField>(), |
| message.typeshape.Size(), std::move(message_qname))); |
| }; |
| if (method.maybe_request) { |
| CreateMessage(*method.maybe_request, types::MessageKind::kRequest); |
| } |
| if (method.maybe_response) { |
| auto kind = method.maybe_request ? types::MessageKind::kResponse |
| : types::MessageKind::kEvent; |
| CreateMessage(*method.maybe_response, kind); |
| } |
| } |
| named_coded_types_.emplace( |
| &decl->name, std::make_unique<coded::InterfaceType>(std::move(interface_messages))); |
| break; |
| } |
| case flat::Decl::Kind::kTable: { |
| auto table_decl = static_cast<const flat::Table*>(decl); |
| std::string table_name = NameCodedTable(table_decl); |
| std::string pointer_name = NamePointer(table_name); |
| named_coded_types_.emplace( |
| &decl->name, |
| std::make_unique<coded::TableType>(std::move(table_name), std::vector<coded::TableField>(), |
| table_decl->typeshape.Size(), |
| std::move(pointer_name), NameName(table_decl->name, ".", "/"))); |
| break; |
| } |
| case flat::Decl::Kind::kStruct: { |
| auto struct_decl = static_cast<const flat::Struct*>(decl); |
| if (struct_decl->anonymous) |
| break; |
| std::string struct_name = NameCodedStruct(struct_decl); |
| std::string pointer_name = NamePointer(struct_name); |
| named_coded_types_.emplace( |
| &decl->name, |
| std::make_unique<coded::StructType>(std::move(struct_name), std::vector<coded::StructField>(), |
| struct_decl->typeshape.Size(), |
| std::move(pointer_name), NameName(struct_decl->name, ".", "/"))); |
| break; |
| } |
| case flat::Decl::Kind::kUnion: { |
| auto union_decl = static_cast<const flat::Union*>(decl); |
| std::string union_name = NameCodedUnion(union_decl); |
| std::string pointer_name = NamePointer(union_name); |
| named_coded_types_.emplace( |
| &decl->name, std::make_unique<coded::UnionType>( |
| std::move(union_name), std::vector<const coded::Type*>(), |
| union_decl->membershape.Offset(), union_decl->typeshape.Size(), |
| std::move(pointer_name), NameName(union_decl->name, ".", "/"))); |
| break; |
| } |
| case flat::Decl::Kind::kXUnion: { |
| auto xunion_decl = static_cast<const flat::XUnion*>(decl); |
| std::string xunion_name = NameCodedXUnion(xunion_decl); |
| std::string pointer_name = NamePointer(xunion_name); |
| named_coded_types_.emplace( |
| &decl->name, std::make_unique<coded::XUnionType>( |
| std::move(xunion_name), std::vector<coded::XUnionField>(), |
| std::move(pointer_name), NameName(xunion_decl->name, ".", "/"))); |
| break; |
| } |
| } |
| } |
| |
| void CodedTypesGenerator::CompileCodedTypes() { |
| for (const auto& decl : library_->declaration_order_) { |
| CompileDecl(decl); |
| } |
| |
| for (const auto& decl : library_->declaration_order_) { |
| if (decl->name.library() != library_) |
| continue; |
| CompileFields(decl); |
| } |
| } |
| |
| } // namespace fidl |
