| // Copyright 2018 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/c_generator.h" |
| |
| #include "fidl/attributes.h" |
| #include "fidl/names.h" |
| |
| namespace fidl { |
| |
| namespace { |
| |
| // Various string values are looked up or computed in these |
| // functions. Nothing else should be dealing in string literals, or |
| // computing strings from these or AST values. |
| |
| constexpr const char* kIndent = " "; |
| |
| CGenerator::Member MessageHeader() { |
| return {flat::Type::Kind::kIdentifier, "fidl_message_header_t", "hdr", {}, {}}; |
| } |
| |
| // Functions named "Emit..." are called to actually emit to an std::ostream |
| // is here. No other functions should directly emit to the streams. |
| |
| std::ostream& operator<<(std::ostream& stream, StringView view) { |
| stream.rdbuf()->sputn(view.data(), view.size()); |
| return stream; |
| } |
| |
| void EmitFileComment(std::ostream* file) { |
| *file << "// WARNING: This file is machine generated by fidlc.\n\n"; |
| } |
| |
| void EmitHeaderGuard(std::ostream* file) { |
| // TODO(704) Generate an appropriate header guard name. |
| *file << "#pragma once\n"; |
| } |
| |
| void EmitIncludeHeader(std::ostream* file, StringView header) { |
| *file << "#include " << header << "\n"; |
| } |
| |
| void EmitBeginExternC(std::ostream* file) { |
| *file << "#if defined(__cplusplus)\nextern \"C\" {\n#endif\n"; |
| } |
| |
| void EmitEndExternC(std::ostream* file) { |
| *file << "#if defined(__cplusplus)\n}\n#endif\n"; |
| } |
| |
| void EmitBlank(std::ostream* file) { |
| *file << "\n"; |
| } |
| |
| void EmitMemberDecl(std::ostream* file, const CGenerator::Member& member) { |
| *file << member.type << " " << member.name; |
| for (uint32_t array_count : member.array_counts) { |
| *file << "[" << array_count << "]"; |
| } |
| } |
| |
| void EmitMethodInParamDecl(std::ostream* file, const CGenerator::Member& member) { |
| switch (member.kind) { |
| case flat::Type::Kind::kArray: |
| *file << "const " << member.type << " " << member.name; |
| for (uint32_t array_count : member.array_counts) { |
| *file << "[" << array_count << "]"; |
| } |
| break; |
| case flat::Type::Kind::kVector: |
| *file << "const " << member.element_type << "* " << member.name << "_data, " |
| << "size_t " << member.name << "_count"; |
| break; |
| case flat::Type::Kind::kString: |
| *file << "const char* " << member.name << "_data, " |
| << "size_t " << member.name << "_size"; |
| break; |
| case flat::Type::Kind::kHandle: |
| case flat::Type::Kind::kRequestHandle: |
| case flat::Type::Kind::kPrimitive: |
| *file << member.type << " " << member.name; |
| break; |
| case flat::Type::Kind::kIdentifier: |
| *file << "const " << member.type << "* " << member.name; |
| break; |
| } |
| } |
| |
| void EmitMethodOutParamDecl(std::ostream* file, const CGenerator::Member& member) { |
| switch (member.kind) { |
| case flat::Type::Kind::kArray: |
| *file << member.type << " out_" << member.name; |
| for (uint32_t array_count : member.array_counts) { |
| *file << "[" << array_count << "]"; |
| } |
| case flat::Type::Kind::kVector: |
| *file << member.element_type << "* " << member.name << "_data, " |
| << "size_t " << member.name << "_capacity, " |
| << "size_t* out_" << member.name << "_count"; |
| break; |
| case flat::Type::Kind::kString: |
| *file << "char* " << member.name << "_data, " |
| << "size_t " << member.name << "_capacity, " |
| << "size_t* out_" << member.name << "_size"; |
| break; |
| case flat::Type::Kind::kHandle: |
| case flat::Type::Kind::kRequestHandle: |
| case flat::Type::Kind::kPrimitive: |
| case flat::Type::Kind::kIdentifier: |
| *file << member.type << "* " << member.name; |
| break; |
| } |
| } |
| |
| void EmitClientMethodDecl(std::ostream* file, StringView method_name, |
| const std::vector<CGenerator::Member>& request, |
| const std::vector<CGenerator::Member>& response) { |
| *file << "zx_status_t " << method_name << "(zx_handle_t _channel"; |
| for (const auto& member : request) { |
| *file << ", "; |
| EmitMethodInParamDecl(file, member); |
| } |
| for (auto member : response) { |
| *file << ", "; |
| EmitMethodOutParamDecl(file, member); |
| } |
| *file << ")"; |
| } |
| |
| void EmitServerMethodDecl(std::ostream* file, StringView method_name, |
| const std::vector<CGenerator::Member>& request, |
| bool has_response) { |
| *file << "zx_status_t (*" << method_name << ")(void* ctx"; |
| for (const auto& member : request) { |
| *file << ", "; |
| EmitMethodInParamDecl(file, member); |
| } |
| if (has_response) { |
| *file << ", fidl_txn_t* txn"; |
| } |
| *file << ")"; |
| } |
| |
| void EmitServerDispatchDecl(std::ostream* file, StringView interface_name) { |
| *file << "zx_status_t " << interface_name |
| << "_dispatch(void* ctx, fidl_txn_t* txn, fidl_msg_t* msg, const " |
| << interface_name << "_ops_t* ops)"; |
| } |
| |
| void EmitServerReplyDecl(std::ostream* file, StringView method_name, |
| const std::vector<CGenerator::Member>& response) { |
| *file << "zx_status_t " << method_name << "_reply(fidl_txn_t* _txn"; |
| for (const auto& member : response) { |
| *file << ", "; |
| EmitMethodInParamDecl(file, member); |
| } |
| *file << ")"; |
| } |
| |
| void EmitMeasureParams(std::ostream* file, |
| const std::vector<CGenerator::Member>& params, |
| StringView vector_suffix, |
| StringView string_suffix) { |
| for (const auto& member : params) { |
| if (member.kind == flat::Type::Kind::kVector) |
| *file << " + FIDL_ALIGN(sizeof(*" << member.name << "_data) * " << member.name << vector_suffix << ")"; |
| else if (member.kind == flat::Type::Kind::kString) |
| *file << " + FIDL_ALIGN(" << member.name << string_suffix << ")"; |
| } |
| } |
| |
| // This function assumes the |params| are part of a [Layout="Simple"] interface. |
| // In particular, simple interfaces don't have nullable structs or nested |
| // vectors. The only secondary objects they contain are top-level vectors and |
| // strings. |
| size_t CountSecondaryObjects(const std::vector<CGenerator::Member>& params) { |
| size_t count = 0u; |
| for (const auto& member : params) { |
| if (member.kind == flat::Type::Kind::kVector || |
| member.kind == flat::Type::Kind::kString) |
| ++count; |
| } |
| return count; |
| } |
| |
| void EmitLinearizeMessage(std::ostream* file, |
| StringView receiver, |
| StringView bytes, |
| const std::vector<CGenerator::Member>& request) { |
| if (CountSecondaryObjects(request) > 0) |
| *file << kIndent << "uint32_t _next = sizeof(*" << receiver << ");\n"; |
| for (const auto& member : request) { |
| const auto& name = member.name; |
| switch (member.kind) { |
| case flat::Type::Kind::kArray: |
| *file << kIndent << "memcpy(" << receiver << "->" << name << ", " |
| << name << ", sizeof(" << receiver << "->" << name << "));\n"; |
| break; |
| case flat::Type::Kind::kVector: |
| *file << kIndent << receiver << "->" << name << ".data = &" << bytes << "[_next];\n"; |
| *file << kIndent << receiver << "->" << name << ".count = " << name << "_count;\n"; |
| *file << kIndent << "memcpy(" << receiver << "->" << name << ".data, " << name << "_data, sizeof(*" << name << "_data) * " << name << "_count);\n"; |
| *file << kIndent << "_next += FIDL_ALIGN(sizeof(*" << name << "_data) * " << name << "_count);\n"; |
| break; |
| case flat::Type::Kind::kString: |
| *file << kIndent << receiver << "->" << name << ".data = &" << bytes << "[_next];\n"; |
| *file << kIndent << receiver << "->" << name << ".size = " << name << "_size;\n"; |
| *file << kIndent << "memcpy(" << receiver << "->" << name << ".data, " << name << "_data, " << name << "_size);\n"; |
| *file << kIndent << "_next += FIDL_ALIGN(" << name << "_size);\n"; |
| break; |
| case flat::Type::Kind::kHandle: |
| case flat::Type::Kind::kRequestHandle: |
| case flat::Type::Kind::kPrimitive: |
| *file << kIndent << receiver << "->" << name << " = " << name << ";\n"; |
| break; |
| case flat::Type::Kind::kIdentifier: |
| *file << kIndent << receiver << "->" << name << " = *" << name << ";\n"; |
| break; |
| } |
| } |
| } |
| |
| // Various computational helper routines. |
| |
| void EnumValue(types::PrimitiveSubtype type, const flat::Constant* constant, |
| const flat::Library* library, std::string* out_value) { |
| // TODO(kulakowski) Move this into library resolution. |
| |
| std::ostringstream member_value; |
| |
| switch (type) { |
| case types::PrimitiveSubtype::kInt8: { |
| int8_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| // The char-sized overloads of operator<< here print |
| // the character value, not the numeric value, so cast up. |
| member_value << static_cast<int>(value); |
| break; |
| } |
| case types::PrimitiveSubtype::kInt16: { |
| int16_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| member_value << value; |
| break; |
| } |
| case types::PrimitiveSubtype::kInt32: { |
| int32_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| member_value << value; |
| break; |
| } |
| case types::PrimitiveSubtype::kInt64: { |
| int64_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| member_value << value; |
| break; |
| } |
| case types::PrimitiveSubtype::kUint8: { |
| uint8_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| // The char-sized overloads of operator<< here print |
| // the character value, not the numeric value, so cast up. |
| member_value << static_cast<unsigned int>(value); |
| break; |
| } |
| case types::PrimitiveSubtype::kUint16: { |
| uint16_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| member_value << value; |
| break; |
| } |
| case types::PrimitiveSubtype::kUint32: { |
| uint32_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| member_value << value; |
| break; |
| } |
| case types::PrimitiveSubtype::kUint64: { |
| uint64_t value; |
| bool success = library->ParseIntegerConstant(constant, &value); |
| if (!success) { |
| __builtin_trap(); |
| } |
| member_value << value; |
| break; |
| } |
| case types::PrimitiveSubtype::kBool: |
| case types::PrimitiveSubtype::kStatus: |
| case types::PrimitiveSubtype::kFloat32: |
| case types::PrimitiveSubtype::kFloat64: |
| assert(false && "bad primitive type for an enum"); |
| break; |
| } |
| |
| *out_value = member_value.str(); |
| } |
| |
| std::vector<uint32_t> ArrayCounts(const flat::Library* library, const flat::Type* type) { |
| std::vector<uint32_t> array_counts; |
| for (;;) { |
| switch (type->kind) { |
| default: { return array_counts; } |
| case flat::Type::Kind::kArray: { |
| auto array_type = static_cast<const flat::ArrayType*>(type); |
| uint32_t element_count = array_type->element_count.Value(); |
| array_counts.push_back(element_count); |
| type = array_type->element_type.get(); |
| continue; |
| } |
| } |
| } |
| } |
| |
| template <typename T> |
| CGenerator::Member CreateMember(const flat::Library* library, const T& decl) { |
| std::string name = NameIdentifier(decl.name); |
| const flat::Type* type = decl.type.get(); |
| auto type_name = NameFlatCType(library, type); |
| std::vector<uint32_t> array_counts = ArrayCounts(library, type); |
| std::string element_type; |
| if (type->kind == flat::Type::Kind::kVector) { |
| auto vector_type = static_cast<const flat::VectorType*>(type); |
| element_type = NameFlatCType(library, vector_type->element_type.get()); |
| } |
| return CGenerator::Member{ |
| type->kind, |
| std::move(type_name), |
| std::move(name), |
| std::move(element_type), |
| std::move(array_counts), |
| }; |
| } |
| |
| std::vector<CGenerator::Member> |
| GenerateMembers(const flat::Library* library, |
| const std::vector<flat::Union::Member>& union_members) { |
| std::vector<CGenerator::Member> members; |
| members.reserve(union_members.size()); |
| for (const auto& union_member : union_members) { |
| members.push_back(CreateMember(library, union_member)); |
| } |
| return members; |
| } |
| |
| void GetMethodParameters(const flat::Library* library, |
| const CGenerator::NamedMethod& method_info, |
| std::vector<CGenerator::Member>* request, |
| std::vector<CGenerator::Member>* response) { |
| if (request) { |
| request->reserve(method_info.request->parameters.size()); |
| for (const auto& parameter : method_info.request->parameters) { |
| request->push_back(CreateMember(library, parameter)); |
| } |
| } |
| |
| if (response && method_info.response) { |
| response->reserve(method_info.request->parameters.size()); |
| for (const auto& parameter : method_info.response->parameters) { |
| response->push_back(CreateMember(library, parameter)); |
| } |
| } |
| } |
| |
| } // namespace |
| |
| void CGenerator::GeneratePrologues() { |
| EmitFileComment(&file_); |
| EmitHeaderGuard(&file_); |
| EmitBlank(&file_); |
| EmitIncludeHeader(&file_, "<stdalign.h>"); |
| EmitIncludeHeader(&file_, "<stdbool.h>"); |
| EmitIncludeHeader(&file_, "<stdint.h>"); |
| EmitIncludeHeader(&file_, "<zircon/fidl.h>"); |
| EmitIncludeHeader(&file_, "<zircon/syscalls/object.h>"); |
| EmitIncludeHeader(&file_, "<zircon/types.h>"); |
| for (const auto& pair : *library_->dependencies_) { |
| if (pair.second.get() == library_) |
| continue; |
| EmitIncludeHeader(&file_, "<" + NameLibraryCHeader(pair.first) + ">"); |
| } |
| EmitBlank(&file_); |
| EmitBeginExternC(&file_); |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::GenerateEpilogues() { |
| EmitEndExternC(&file_); |
| } |
| |
| void CGenerator::GenerateIntegerDefine(StringView name, types::PrimitiveSubtype subtype, |
| StringView value) { |
| std::string literal_macro = NamePrimitiveIntegerCConstantMacro(subtype); |
| file_ << "#define " << name << " " << literal_macro << "(" << value << ")\n"; |
| } |
| |
| void CGenerator::GenerateIntegerTypedef(types::PrimitiveSubtype subtype, StringView name) { |
| std::string underlying_type = NamePrimitiveCType(subtype); |
| file_ << "typedef " << underlying_type << " " << name << ";\n"; |
| } |
| |
| void CGenerator::GenerateStructTypedef(StringView name) { |
| file_ << "typedef struct " << name << " " << name << ";\n"; |
| } |
| |
| void CGenerator::GenerateStructDeclaration(StringView name, const std::vector<Member>& members) { |
| file_ << "struct " << name << " {\n"; |
| file_ << kIndent << "FIDL_ALIGNDECL\n"; |
| for (const auto& member : members) { |
| file_ << kIndent; |
| EmitMemberDecl(&file_, member); |
| file_ << ";\n"; |
| } |
| file_ << "};\n"; |
| } |
| |
| void CGenerator::GenerateTaggedUnionDeclaration(StringView name, |
| const std::vector<Member>& members) { |
| file_ << "struct " << name << " {\n"; |
| file_ << kIndent << "FIDL_ALIGNDECL\n"; |
| file_ << kIndent << "fidl_union_tag_t tag;\n"; |
| file_ << kIndent << "union {\n"; |
| for (const auto& member : members) { |
| file_ << kIndent << kIndent; |
| EmitMemberDecl(&file_, member); |
| file_ << ";\n"; |
| } |
| file_ << kIndent << "};\n"; |
| file_ << "};\n"; |
| } |
| |
| // TODO(TO-702) These should maybe check for global name |
| // collisions? Otherwise, is there some other way they should fail? |
| std::map<const flat::Decl*, CGenerator::NamedConst> |
| CGenerator::NameConsts(const std::vector<std::unique_ptr<flat::Const>>& const_infos) { |
| std::map<const flat::Decl*, NamedConst> named_consts; |
| for (const auto& const_info : const_infos) { |
| named_consts.emplace(const_info.get(), NamedConst{"", *const_info}); |
| } |
| return named_consts; |
| } |
| |
| std::map<const flat::Decl*, CGenerator::NamedEnum> |
| CGenerator::NameEnums(const std::vector<std::unique_ptr<flat::Enum>>& enum_infos) { |
| std::map<const flat::Decl*, NamedEnum> named_enums; |
| for (const auto& enum_info : enum_infos) { |
| std::string enum_name = NameName(enum_info->name, "_", "_"); |
| named_enums.emplace(enum_info.get(), NamedEnum{std::move(enum_name), *enum_info}); |
| } |
| return named_enums; |
| } |
| |
| std::map<const flat::Decl*, CGenerator::NamedInterface> |
| CGenerator::NameInterfaces(const std::vector<std::unique_ptr<flat::Interface>>& interface_infos) { |
| std::map<const flat::Decl*, NamedInterface> named_interfaces; |
| for (const auto& interface_info : interface_infos) { |
| NamedInterface named_interface; |
| named_interface.c_name = NameInterface(*interface_info); |
| if (interface_info->HasAttribute("Discoverable")) { |
| named_interface.discoverable_name = NameDiscoverable(*interface_info); |
| } |
| for (const auto& method : interface_info->methods) { |
| NamedMethod named_method; |
| std::string method_name = NameMethod(named_interface.c_name, method); |
| named_method.ordinal = method.ordinal.Value(); |
| named_method.ordinal_name = NameOrdinal(method_name); |
| named_method.identifier = NameIdentifier(method.name); |
| named_method.c_name = method_name; |
| if (method.maybe_request != nullptr) { |
| std::string c_name = NameMessage(method_name, types::MessageKind::kRequest); |
| std::string coded_name = NameTable(c_name); |
| named_method.request = std::make_unique<NamedMessage>(NamedMessage{ |
| std::move(c_name), std::move(coded_name), method.maybe_request->parameters}); |
| } |
| if (method.maybe_response != nullptr) { |
| if (method.maybe_request == nullptr) { |
| std::string c_name = |
| NameMessage(method_name, types::MessageKind::kEvent); |
| std::string coded_name = NameTable(c_name); |
| named_method.response = std::make_unique<NamedMessage>( |
| NamedMessage{std::move(c_name), std::move(coded_name), |
| method.maybe_response->parameters}); |
| } else { |
| std::string c_name = NameMessage(method_name, types::MessageKind::kResponse); |
| std::string coded_name = NameTable(c_name); |
| named_method.response = std::make_unique<NamedMessage>( |
| NamedMessage{std::move(c_name), std::move(coded_name), |
| method.maybe_response->parameters}); |
| } |
| } |
| named_interface.methods.push_back(std::move(named_method)); |
| } |
| named_interfaces.emplace(interface_info.get(), std::move(named_interface)); |
| } |
| return named_interfaces; |
| } |
| |
| std::map<const flat::Decl*, CGenerator::NamedStruct> |
| CGenerator::NameStructs(const std::vector<std::unique_ptr<flat::Struct>>& struct_infos) { |
| std::map<const flat::Decl*, NamedStruct> named_structs; |
| for (const auto& struct_info : struct_infos) { |
| std::string c_name = NameName(struct_info->name, "_", "_"); |
| std::string coded_name = c_name + "Coded"; |
| named_structs.emplace(struct_info.get(), |
| NamedStruct{std::move(c_name), std::move(coded_name), *struct_info}); |
| } |
| return named_structs; |
| } |
| |
| std::map<const flat::Decl*, CGenerator::NamedUnion> |
| CGenerator::NameUnions(const std::vector<std::unique_ptr<flat::Union>>& union_infos) { |
| std::map<const flat::Decl*, NamedUnion> named_unions; |
| for (const auto& union_info : union_infos) { |
| std::string union_name = NameName(union_info->name, "_", "_"); |
| named_unions.emplace(union_info.get(), NamedUnion{std::move(union_name), *union_info}); |
| } |
| return named_unions; |
| } |
| |
| void CGenerator::ProduceConstForwardDeclaration(const NamedConst& named_const) { |
| // TODO(TO-702) |
| } |
| |
| void CGenerator::ProduceEnumForwardDeclaration(const NamedEnum& named_enum) { |
| types::PrimitiveSubtype subtype = named_enum.enum_info.type; |
| GenerateIntegerTypedef(subtype, named_enum.name); |
| for (const auto& member : named_enum.enum_info.members) { |
| std::string member_name = named_enum.name + "_" + NameIdentifier(member.name); |
| std::string member_value; |
| EnumValue(named_enum.enum_info.type, member.value.get(), library_, &member_value); |
| GenerateIntegerDefine(member_name, subtype, std::move(member_value)); |
| } |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceInterfaceForwardDeclaration(const NamedInterface& named_interface) { |
| if (!named_interface.discoverable_name.empty()) { |
| file_ << "#define " << named_interface.c_name << "_Name \"" << named_interface.discoverable_name << "\"\n"; |
| } |
| for (const auto& method_info : named_interface.methods) { |
| file_ << "#define " << method_info.ordinal_name << " ((uint32_t)" |
| << method_info.ordinal << ")\n"; |
| if (method_info.request) |
| GenerateStructTypedef(method_info.request->c_name); |
| if (method_info.response) |
| GenerateStructTypedef(method_info.response->c_name); |
| } |
| } |
| |
| void CGenerator::ProduceStructForwardDeclaration(const NamedStruct& named_struct) { |
| GenerateStructTypedef(named_struct.c_name); |
| } |
| |
| void CGenerator::ProduceUnionForwardDeclaration(const NamedUnion& named_union) { |
| GenerateStructTypedef(named_union.name); |
| } |
| |
| void CGenerator::ProduceInterfaceExternDeclaration(const NamedInterface& named_interface) { |
| for (const auto& method_info : named_interface.methods) { |
| if (method_info.request) |
| file_ << "extern const fidl_type_t " << method_info.request->coded_name << ";\n"; |
| if (method_info.response) |
| file_ << "extern const fidl_type_t " << method_info.response->coded_name |
| << ";\n"; |
| } |
| } |
| |
| void CGenerator::ProduceConstDeclaration(const NamedConst& named_const) { |
| // TODO(TO-702) |
| static_cast<void>(named_const); |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceMessageDeclaration(const NamedMessage& named_message) { |
| std::vector<CGenerator::Member> members; |
| members.reserve(1 + named_message.parameters.size()); |
| members.push_back(MessageHeader()); |
| for (const auto& parameter : named_message.parameters) { |
| members.push_back(CreateMember(library_, parameter)); |
| } |
| |
| GenerateStructDeclaration(named_message.c_name, members); |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceInterfaceDeclaration(const NamedInterface& named_interface) { |
| for (const auto& method_info : named_interface.methods) { |
| if (method_info.request) |
| ProduceMessageDeclaration(*method_info.request); |
| if (method_info.response) |
| ProduceMessageDeclaration(*method_info.response); |
| } |
| } |
| |
| void CGenerator::ProduceStructDeclaration(const NamedStruct& named_struct) { |
| std::vector<CGenerator::Member> members; |
| members.reserve(named_struct.struct_info.members.size()); |
| for (const auto& struct_member : named_struct.struct_info.members) { |
| members.push_back(CreateMember(library_, struct_member)); |
| } |
| |
| GenerateStructDeclaration(named_struct.c_name, members); |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceUnionDeclaration(const NamedUnion& named_union) { |
| std::vector<CGenerator::Member> members = |
| GenerateMembers(library_, named_union.union_info.members); |
| GenerateTaggedUnionDeclaration(named_union.name, members); |
| |
| uint32_t tag = 0u; |
| for (const auto& member : named_union.union_info.members) { |
| std::string tag_name = NameUnionTag(named_union.name, member); |
| auto union_tag_type = types::PrimitiveSubtype::kUint32; |
| std::ostringstream value; |
| value << tag; |
| GenerateIntegerDefine(std::move(tag_name), union_tag_type, value.str()); |
| ++tag; |
| } |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceInterfaceClientDeclaration(const NamedInterface& named_interface) { |
| for (const auto& method_info : named_interface.methods) { |
| if (!method_info.request) |
| continue; |
| std::vector<Member> request; |
| std::vector<Member> response; |
| GetMethodParameters(library_, method_info, &request, &response); |
| EmitClientMethodDecl(&file_, method_info.c_name, request, response); |
| file_ << ";\n"; |
| } |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceInterfaceClientImplementation(const NamedInterface& named_interface) { |
| for (const auto& method_info : named_interface.methods) { |
| if (!method_info.request) |
| continue; |
| std::vector<Member> request; |
| std::vector<Member> response; |
| GetMethodParameters(library_, method_info, &request, &response); |
| EmitClientMethodDecl(&file_, method_info.c_name, request, response); |
| file_ << " {\n"; |
| file_ << kIndent << "uint32_t _wr_num_bytes = sizeof(" << method_info.request->c_name << ")"; |
| EmitMeasureParams(&file_, request, "_count", "_size"); |
| file_ << ";\n"; |
| file_ << kIndent << "FIDL_ALIGNDECL char _wr_bytes[_wr_num_bytes];\n"; |
| file_ << kIndent << method_info.request->c_name << "* _request = (" << method_info.request->c_name << "*)_wr_bytes;\n"; |
| file_ << kIndent << "memset(_wr_bytes, 0, sizeof(_wr_bytes));\n"; |
| file_ << kIndent << "_request->hdr.ordinal = " << method_info.ordinal << ";\n"; |
| EmitLinearizeMessage(&file_, "_request", "_wr_bytes", request); |
| file_ << kIndent << "zx_handle_t _handles[ZX_CHANNEL_MAX_MSG_HANDLES];\n"; |
| file_ << kIndent << "uint32_t _wr_num_handles = 0u;\n"; |
| file_ << kIndent << "zx_status_t _status = fidl_encode(&" << method_info.request->coded_name |
| << ", _wr_bytes, _wr_num_bytes, _handles, ZX_CHANNEL_MAX_MSG_HANDLES" |
| << ", &_wr_num_handles, NULL);\n"; |
| file_ << kIndent << "if (_status != ZX_OK)\n"; |
| file_ << kIndent << kIndent << "return _status;\n"; |
| if (!method_info.response) { |
| file_ << kIndent << "return zx_channel_write(_channel, 0u, _wr_bytes, _wr_num_bytes, _handles, _wr_num_handles);\n"; |
| } else { |
| file_ << kIndent << "uint32_t _rd_num_bytes = sizeof(" << method_info.response->c_name << ")"; |
| EmitMeasureParams(&file_, response, "_capacity", "_capacity"); |
| file_ << ";\n"; |
| file_ << kIndent << "FIDL_ALIGNDECL char _rd_bytes[_rd_num_bytes];\n"; |
| if (!response.empty()) |
| file_ << kIndent << method_info.response->c_name << "* _response = (" << method_info.response->c_name << "*)_rd_bytes;\n"; |
| file_ << kIndent << "zx_channel_call_args_t _args = {\n"; |
| file_ << kIndent << kIndent << ".wr_bytes = _wr_bytes,\n"; |
| file_ << kIndent << kIndent << ".wr_handles = _handles,\n"; |
| file_ << kIndent << kIndent << ".rd_bytes = _rd_bytes,\n"; |
| file_ << kIndent << kIndent << ".rd_handles = _handles,\n"; |
| file_ << kIndent << kIndent << ".wr_num_bytes = _wr_num_bytes,\n"; |
| file_ << kIndent << kIndent << ".wr_num_handles = _wr_num_handles,\n"; |
| file_ << kIndent << kIndent << ".rd_num_bytes = _rd_num_bytes,\n"; |
| file_ << kIndent << kIndent << ".rd_num_handles = ZX_CHANNEL_MAX_MSG_HANDLES,\n"; |
| file_ << kIndent << "};\n"; |
| |
| file_ << kIndent << "uint32_t _actual_num_bytes = 0u;\n"; |
| file_ << kIndent << "uint32_t _actual_num_handles = 0u;\n"; |
| file_ << kIndent << "_status = zx_channel_call(_channel, 0u, ZX_TIME_INFINITE, &_args, &_actual_num_bytes, &_actual_num_handles);\n"; |
| file_ << kIndent << "if (_status != ZX_OK)\n"; |
| file_ << kIndent << kIndent << "return _status;\n"; |
| |
| // We check that we have enough capacity to copy out the parameters |
| // before decoding the message so that we can close the handles |
| // using |_handles| rather than trying to find them in the decoded |
| // message. |
| size_t count = CountSecondaryObjects(response); |
| if (count > 0u) { |
| file_ << kIndent << "if "; |
| if (count > 1u) |
| file_ << "("; |
| size_t i = 0; |
| for (const auto& member : response) { |
| if (member.kind == flat::Type::Kind::kVector) { |
| if (i++ > 0u) |
| file_ << " || "; |
| file_ << "(_response->" << member.name << ".count > " << member.name << "_capacity)"; |
| } else if (member.kind == flat::Type::Kind::kString) { |
| if (i++ > 0u) |
| file_ << " || "; |
| file_ << "(_response->" << member.name << ".size > " << member.name << "_capacity)"; |
| } |
| } |
| if (count > 1u) |
| file_ << ")"; |
| file_ << " {\n"; |
| file_ << kIndent << kIndent << "zx_handle_close_many(_handles, _actual_num_handles);\n"; |
| file_ << kIndent << kIndent << "return ZX_ERR_BUFFER_TOO_SMALL;\n"; |
| file_ << kIndent << "}\n"; |
| } |
| |
| // TODO(FIDL-162): Validate the response ordinal. C++ bindings also need to do that. |
| file_ << kIndent << "_status = fidl_decode(&" << method_info.response->coded_name |
| << ", _rd_bytes, _actual_num_bytes, _handles, _actual_num_handles, NULL);\n"; |
| file_ << kIndent << "if (_status != ZX_OK)\n"; |
| file_ << kIndent << kIndent << "return _status;\n"; |
| |
| for (const auto& member : response) { |
| const auto& name = member.name; |
| switch (member.kind) { |
| case flat::Type::Kind::kArray: |
| file_ << kIndent << "memcpy(out_" << name << ", _response->" << name << ", sizeof(out_" << name << "));\n"; |
| break; |
| case flat::Type::Kind::kVector: |
| file_ << kIndent << "memcpy(" << name << "_data, _response->" << name << ".data, sizeof(*" << name << "_data) * _response->" << name << ".count);\n"; |
| file_ << kIndent << "*out_" << name << "_count = _response->" << name << ".count;\n"; |
| break; |
| case flat::Type::Kind::kString: |
| file_ << kIndent << "memcpy(" << name << "_data, _response->" << name << ".data, _response->" << name << ".size);\n"; |
| file_ << kIndent << "*out_" << name << "_size = _response->" << name << ".size;\n"; |
| break; |
| case flat::Type::Kind::kHandle: |
| case flat::Type::Kind::kRequestHandle: |
| case flat::Type::Kind::kPrimitive: |
| case flat::Type::Kind::kIdentifier: |
| file_ << kIndent << "*" << name << " = _response->" << name << ";\n"; |
| break; |
| } |
| } |
| |
| file_ << kIndent << "return ZX_OK;\n"; |
| } |
| file_ << "}\n\n"; |
| } |
| } // namespace fidl |
| |
| void CGenerator::ProduceInterfaceServerDeclaration(const NamedInterface& named_interface) { |
| file_ << "typedef struct " << named_interface.c_name << "_ops {\n"; |
| for (const auto& method_info : named_interface.methods) { |
| if (!method_info.request) |
| continue; |
| std::vector<Member> request; |
| GetMethodParameters(library_, method_info, &request, nullptr); |
| bool has_response = method_info.response != nullptr; |
| file_ << kIndent; |
| EmitServerMethodDecl(&file_, method_info.identifier, request, has_response); |
| file_ << ";\n"; |
| } |
| file_ << "} " << named_interface.c_name << "_ops_t;\n\n"; |
| |
| EmitServerDispatchDecl(&file_, named_interface.c_name); |
| file_ << ";\n\n"; |
| |
| for (const auto& method_info : named_interface.methods) { |
| if (!method_info.request || !method_info.response) |
| continue; |
| std::vector<Member> response; |
| GetMethodParameters(library_, method_info, nullptr, &response); |
| EmitServerReplyDecl(&file_, method_info.c_name, response); |
| file_ << ";\n"; |
| } |
| |
| EmitBlank(&file_); |
| } |
| |
| void CGenerator::ProduceInterfaceServerImplementation(const NamedInterface& named_interface) { |
| EmitServerDispatchDecl(&file_, named_interface.c_name); |
| file_ << " {\n"; |
| file_ << kIndent << "if (msg->num_bytes < sizeof(fidl_message_header_t))\n"; |
| file_ << kIndent << kIndent << "return ZX_ERR_INVALID_ARGS;\n"; |
| file_ << kIndent << "fidl_message_header_t* hdr = (fidl_message_header_t*)msg->bytes;\n"; |
| file_ << kIndent << "zx_status_t status = ZX_OK;\n"; |
| file_ << kIndent << "switch (hdr->ordinal) {\n"; |
| |
| for (const auto& method_info : named_interface.methods) { |
| if (!method_info.request) |
| continue; |
| file_ << kIndent << "case " << method_info.ordinal_name << ": {\n"; |
| file_ << kIndent << kIndent << "status = fidl_decode_msg(&" << method_info.request->coded_name << ", msg, NULL);\n"; |
| file_ << kIndent << kIndent << "if (status != ZX_OK)\n"; |
| file_ << kIndent << kIndent << kIndent << "break;\n"; |
| std::vector<Member> request; |
| GetMethodParameters(library_, method_info, &request, nullptr); |
| if (!request.empty()) |
| file_ << kIndent << kIndent << method_info.request->c_name << "* request = (" << method_info.request->c_name << "*)msg->bytes;\n"; |
| file_ << kIndent << kIndent << "status = (*ops->" << method_info.identifier << ")(ctx"; |
| for (const auto& member : request) { |
| switch (member.kind) { |
| case flat::Type::Kind::kArray: |
| case flat::Type::Kind::kHandle: |
| case flat::Type::Kind::kRequestHandle: |
| case flat::Type::Kind::kPrimitive: |
| file_ << ", request->" << member.name; |
| break; |
| case flat::Type::Kind::kVector: |
| file_ << ", (" << member.element_type << "*)request->" << member.name << ".data" |
| << ", request->" << member.name << ".count"; |
| break; |
| case flat::Type::Kind::kString: |
| file_ << ", request->" << member.name << ".data" |
| << ", request->" << member.name << ".size"; |
| break; |
| case flat::Type::Kind::kIdentifier: |
| file_ << ", &(request->" << member.name << ")"; |
| break; |
| } |
| } |
| if (method_info.response != nullptr) |
| file_ << ", txn"; |
| file_ << ");\n"; |
| file_ << kIndent << kIndent << "break;\n"; |
| file_ << kIndent << "}\n"; |
| } |
| file_ << kIndent << "default: {\n"; |
| file_ << kIndent << kIndent << "zx_handle_close_many(msg->handles, msg->num_handles);\n"; |
| file_ << kIndent << kIndent << "status = ZX_ERR_NOT_SUPPORTED;\n"; |
| file_ << kIndent << kIndent << "break;\n"; |
| file_ << kIndent << "}\n"; |
| file_ << kIndent << "}\n"; |
| file_ << kIndent << "return status;\n"; |
| file_ << "}\n\n"; |
| |
| for (const auto& method_info : named_interface.methods) { |
| if (!method_info.request || !method_info.response) |
| continue; |
| std::vector<Member> response; |
| GetMethodParameters(library_, method_info, nullptr, &response); |
| EmitServerReplyDecl(&file_, method_info.c_name, response); |
| file_ << " {\n"; |
| file_ << kIndent << "uint32_t _wr_num_bytes = sizeof(" << method_info.response->c_name << ")"; |
| EmitMeasureParams(&file_, response, "_count", "_size"); |
| file_ << ";\n"; |
| file_ << kIndent << "char _wr_bytes[_wr_num_bytes];\n"; |
| file_ << kIndent << method_info.response->c_name << "* _response = (" << method_info.response->c_name << "*)_wr_bytes;\n"; |
| file_ << kIndent << "memset(_wr_bytes, 0, sizeof(_wr_bytes));\n"; |
| file_ << kIndent << "_response->hdr.ordinal = " << method_info.ordinal << ";\n"; |
| EmitLinearizeMessage(&file_, "_response", "_wr_bytes", response); |
| file_ << kIndent << "zx_handle_t _handles[ZX_CHANNEL_MAX_MSG_HANDLES];\n"; |
| file_ << kIndent << "fidl_msg_t _msg = {\n"; |
| file_ << kIndent << kIndent << ".bytes = _wr_bytes,\n"; |
| file_ << kIndent << kIndent << ".handles = _handles,\n"; |
| file_ << kIndent << kIndent << ".num_bytes = _wr_num_bytes,\n"; |
| file_ << kIndent << kIndent << ".num_handles = ZX_CHANNEL_MAX_MSG_HANDLES,\n"; |
| file_ << kIndent << "};\n"; |
| file_ << kIndent << "zx_status_t _status = fidl_encode_msg(&" |
| << method_info.response->coded_name << ", &_msg, &_msg.num_handles, NULL);\n"; |
| file_ << kIndent << "if (_status != ZX_OK)\n"; |
| file_ << kIndent << kIndent << "return _status;\n"; |
| file_ << kIndent << "return _txn->reply(_txn, &_msg);\n"; |
| file_ << "}\n\n"; |
| } |
| } |
| |
| std::ostringstream CGenerator::ProduceHeader() { |
| GeneratePrologues(); |
| |
| std::map<const flat::Decl*, NamedConst> named_consts = |
| NameConsts(library_->const_declarations_); |
| std::map<const flat::Decl*, NamedEnum> named_enums = NameEnums(library_->enum_declarations_); |
| std::map<const flat::Decl*, NamedInterface> named_interfaces = |
| NameInterfaces(library_->interface_declarations_); |
| std::map<const flat::Decl*, NamedStruct> named_structs = |
| NameStructs(library_->struct_declarations_); |
| std::map<const flat::Decl*, NamedUnion> named_unions = |
| NameUnions(library_->union_declarations_); |
| |
| file_ << "\n// Forward declarations\n\n"; |
| |
| for (const auto* decl : library_->declaration_order_) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: { |
| auto iter = named_consts.find(decl); |
| if (iter != named_consts.end()) { |
| ProduceConstForwardDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kEnum: { |
| auto iter = named_enums.find(decl); |
| if (iter != named_enums.end()) { |
| ProduceEnumForwardDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kInterface: { |
| auto iter = named_interfaces.find(decl); |
| if (iter != named_interfaces.end()) { |
| ProduceInterfaceForwardDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kStruct: { |
| auto iter = named_structs.find(decl); |
| if (iter != named_structs.end()) { |
| ProduceStructForwardDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kUnion: { |
| auto iter = named_unions.find(decl); |
| if (iter != named_unions.end()) { |
| ProduceUnionForwardDeclaration(iter->second); |
| } |
| break; |
| } |
| default: |
| abort(); |
| } |
| } |
| |
| file_ << "\n// Extern declarations\n\n"; |
| |
| for (const auto* decl : library_->declaration_order_) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: |
| case flat::Decl::Kind::kEnum: |
| case flat::Decl::Kind::kStruct: |
| case flat::Decl::Kind::kUnion: |
| // Only messages have extern fidl_type_t declarations. |
| break; |
| case flat::Decl::Kind::kInterface: { |
| auto iter = named_interfaces.find(decl); |
| if (iter != named_interfaces.end()) { |
| ProduceInterfaceExternDeclaration(iter->second); |
| } |
| break; |
| } |
| default: |
| abort(); |
| } |
| } |
| |
| file_ << "\n// Declarations\n\n"; |
| |
| for (const auto* decl : library_->declaration_order_) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: { |
| auto iter = named_consts.find(decl); |
| if (iter != named_consts.end()) { |
| ProduceConstDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kEnum: |
| // Enums can be entirely forward declared, as they have no |
| // dependencies other than standard headers. |
| break; |
| case flat::Decl::Kind::kInterface: { |
| auto iter = named_interfaces.find(decl); |
| if (iter != named_interfaces.end()) { |
| ProduceInterfaceDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kStruct: { |
| auto iter = named_structs.find(decl); |
| if (iter != named_structs.end()) { |
| ProduceStructDeclaration(iter->second); |
| } |
| break; |
| } |
| case flat::Decl::Kind::kUnion: { |
| auto iter = named_unions.find(decl); |
| if (iter != named_unions.end()) { |
| ProduceUnionDeclaration(iter->second); |
| } |
| break; |
| } |
| default: |
| abort(); |
| } |
| } |
| |
| file_ << "\n// Simple bindings \n\n"; |
| |
| for (const auto* decl : library_->declaration_order_) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: |
| case flat::Decl::Kind::kEnum: |
| case flat::Decl::Kind::kStruct: |
| case flat::Decl::Kind::kUnion: |
| // Only interfaces have client declarations. |
| break; |
| case flat::Decl::Kind::kInterface: { |
| if (!HasSimpleLayout(decl)) |
| break; |
| auto iter = named_interfaces.find(decl); |
| if (iter != named_interfaces.end()) { |
| ProduceInterfaceClientDeclaration(iter->second); |
| ProduceInterfaceServerDeclaration(iter->second); |
| } |
| break; |
| } |
| default: |
| abort(); |
| } |
| } |
| |
| GenerateEpilogues(); |
| |
| return std::move(file_); |
| } |
| |
| std::ostringstream CGenerator::ProduceClient() { |
| EmitFileComment(&file_); |
| EmitIncludeHeader(&file_, "<lib/fidl/coding.h>"); |
| EmitIncludeHeader(&file_, "<string.h>"); |
| EmitIncludeHeader(&file_, "<zircon/syscalls.h>"); |
| EmitIncludeHeader(&file_, "<" + NameLibraryCHeader(library_->name()) + ">"); |
| EmitBlank(&file_); |
| |
| std::map<const flat::Decl*, NamedInterface> named_interfaces = |
| NameInterfaces(library_->interface_declarations_); |
| |
| for (const auto* decl : library_->declaration_order_) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: |
| case flat::Decl::Kind::kEnum: |
| case flat::Decl::Kind::kStruct: |
| case flat::Decl::Kind::kUnion: |
| // Only interfaces have client implementations. |
| break; |
| case flat::Decl::Kind::kInterface: { |
| if (!HasSimpleLayout(decl)) |
| break; |
| auto iter = named_interfaces.find(decl); |
| if (iter != named_interfaces.end()) { |
| ProduceInterfaceClientImplementation(iter->second); |
| } |
| break; |
| } |
| default: |
| abort(); |
| } |
| } |
| |
| return std::move(file_); |
| } |
| |
| std::ostringstream CGenerator::ProduceServer() { |
| EmitFileComment(&file_); |
| EmitIncludeHeader(&file_, "<lib/fidl/coding.h>"); |
| EmitIncludeHeader(&file_, "<string.h>"); |
| EmitIncludeHeader(&file_, "<zircon/syscalls.h>"); |
| EmitIncludeHeader(&file_, "<" + NameLibraryCHeader(library_->name()) + ">"); |
| EmitBlank(&file_); |
| |
| std::map<const flat::Decl*, NamedInterface> named_interfaces = |
| NameInterfaces(library_->interface_declarations_); |
| |
| for (const auto* decl : library_->declaration_order_) { |
| switch (decl->kind) { |
| case flat::Decl::Kind::kConst: |
| case flat::Decl::Kind::kEnum: |
| case flat::Decl::Kind::kStruct: |
| case flat::Decl::Kind::kUnion: |
| // Only interfaces have client implementations. |
| break; |
| case flat::Decl::Kind::kInterface: { |
| if (!HasSimpleLayout(decl)) |
| break; |
| auto iter = named_interfaces.find(decl); |
| if (iter != named_interfaces.end()) { |
| ProduceInterfaceServerImplementation(iter->second); |
| } |
| break; |
| } |
| default: |
| abort(); |
| } |
| } |
| |
| return std::move(file_); |
| } |
| |
| } // namespace fidl |
