blob: bfefa1fe38fec1de7f54c99a139b2d2cef2ea4d4 [file] [log] [blame]
// Copyright 2017 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 <inttypes.h>
#include <lib/fidl/coding.h>
#include <lib/fidl/internal.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <zircon/assert.h>
#include <zircon/compiler.h>
namespace {
class StringBuilder {
public:
StringBuilder(char* buffer, size_t capacity) : buffer_(buffer), capacity_(capacity) {}
size_t length() const { return length_; }
void Append(const char* data, size_t length) {
size_t remaining = capacity_ - length_;
if (length > remaining) {
length = remaining;
}
memcpy(buffer_ + length_, data, length);
length_ += length;
}
void Append(const char* data) { Append(data, strlen(data)); }
void AppendPrintf(const char* format, ...) __PRINTFLIKE(2, 3) {
va_list ap;
va_start(ap, format);
AppendVPrintf(format, ap);
va_end(ap);
}
void AppendVPrintf(const char* format, va_list ap) {
size_t remaining = capacity_ - length_;
if (remaining == 0u) {
return;
}
int count = vsnprintf(buffer_ + length_, remaining, format, ap);
if (count <= 0) {
return;
}
size_t length = static_cast<size_t>(count);
length_ += (length >= remaining ? remaining : length);
}
private:
char* buffer_;
size_t capacity_;
size_t length_ = 0u;
};
void FormatNullability(StringBuilder* str, fidl::FidlNullability nullable) {
if (nullable == fidl::kNullable) {
str->Append("?");
}
}
void FormatEnumName(StringBuilder* str, const fidl::FidlCodedEnum* coded_enum) {
if (coded_enum->name) {
str->Append(coded_enum->name);
} else {
str->Append("enum");
}
}
void FormatBitsName(StringBuilder* str, const fidl::FidlCodedBits* coded_bits) {
if (coded_bits->name) {
str->Append(coded_bits->name);
} else {
str->Append("bits");
}
}
void FormatStructName(StringBuilder* str, const fidl::FidlCodedStruct* coded_struct) {
if (coded_struct->name) {
str->Append(coded_struct->name);
} else {
str->Append("struct");
}
}
void FormatUnionName(StringBuilder* str, const fidl::FidlCodedUnion* coded_union) {
if (coded_union->name) {
str->Append(coded_union->name);
} else {
str->Append("union");
}
}
void FormatTableName(StringBuilder* str, const fidl::FidlCodedTable* coded_table) {
if (coded_table->name) {
str->Append(coded_table->name);
} else {
str->Append("table");
}
}
void FormatXUnionName(StringBuilder* str, const fidl::FidlCodedXUnion* coded_xunion) {
if (coded_xunion->name) {
str->Append(coded_xunion->name);
} else {
str->Append("xunion");
}
}
void FormatTypeName(StringBuilder* str, const fidl_type_t* type);
void FormatElementName(StringBuilder* str, const fidl_type_t* type) {
if (type) {
FormatTypeName(str, type);
} else {
// TODO(jeffbrown): Print the actual primitive type name, assuming we
// start recording that information in the tables.
str->Append("primitive");
}
}
void FormatTypeName(StringBuilder* str, const fidl_type_t* type) {
switch (type->type_tag) {
case fidl::kFidlTypeEnum:
FormatEnumName(str, &type->coded_enum);
break;
case fidl::kFidlTypeBits:
FormatBitsName(str, &type->coded_bits);
break;
case fidl::kFidlTypeStruct:
FormatStructName(str, &type->coded_struct);
break;
case fidl::kFidlTypeStructPointer:
FormatStructName(str, type->coded_struct_pointer.struct_type);
str->Append("?");
break;
case fidl::kFidlTypeUnion:
FormatUnionName(str, &type->coded_union);
break;
case fidl::kFidlTypeUnionPointer:
FormatUnionName(str, type->coded_union_pointer.union_type);
str->Append("?");
break;
case fidl::kFidlTypeArray:
str->Append("array<");
FormatElementName(str, type->coded_array.element);
str->Append(">");
str->AppendPrintf(":%" PRIu32, type->coded_array.array_size / type->coded_array.element_size);
break;
case fidl::kFidlTypeString:
str->Append("string");
if (type->coded_string.max_size != FIDL_MAX_SIZE) {
str->AppendPrintf(":%" PRIu32, type->coded_string.max_size);
}
FormatNullability(str, type->coded_string.nullable);
break;
case fidl::kFidlTypeHandle:
str->Append("handle");
if (type->coded_handle.handle_subtype) {
str->Append("<");
switch (type->coded_handle.handle_subtype) {
case fidl::kFidlHandleSubtypeHandle:
str->Append("handle");
break;
case fidl::kFidlHandleSubtypeBti:
str->Append("bti");
break;
case fidl::kFidlHandleSubtypeChannel:
str->Append("channel");
break;
case fidl::kFidlHandleSubtypeEvent:
str->Append("event");
break;
case fidl::kFidlHandleSubtypeEventpair:
str->Append("eventpair");
break;
case fidl::kFidlHandleSubtypeException:
str->Append("exception");
break;
case fidl::kFidlHandleSubtypeFifo:
str->Append("fifo");
break;
case fidl::kFidlHandleSubtypeGuest:
str->Append("guest");
break;
case fidl::kFidlHandleSubtypeInterrupt:
str->Append("interrupt");
break;
case fidl::kFidlHandleSubtypeIommu:
str->Append("iommu");
break;
case fidl::kFidlHandleSubtypeJob:
str->Append("job");
break;
case fidl::kFidlHandleSubtypeLog:
str->Append("log");
break;
case fidl::kFidlHandleSubtypePager:
str->Append("pager");
break;
case fidl::kFidlHandleSubtypePciDevice:
str->Append("pcidevice");
break;
case fidl::kFidlHandleSubtypePmt:
str->Append("pmt");
break;
case fidl::kFidlHandleSubtypePort:
str->Append("port");
break;
case fidl::kFidlHandleSubtypeProcess:
str->Append("process");
break;
case fidl::kFidlHandleSubtypeProfile:
str->Append("profile");
break;
case fidl::kFidlHandleSubtypeResource:
str->Append("resource");
break;
case fidl::kFidlHandleSubtypeSocket:
str->Append("socket");
break;
case fidl::kFidlHandleSubtypeSuspendToken:
str->Append("suspendtoken");
break;
case fidl::kFidlHandleSubtypeThread:
str->Append("thread");
break;
case fidl::kFidlHandleSubtypeTimer:
str->Append("timer");
break;
case fidl::kFidlHandleSubtypeVcpu:
str->Append("vcpu");
break;
case fidl::kFidlHandleSubtypeVmar:
str->Append("vmar");
break;
case fidl::kFidlHandleSubtypeVmo:
str->Append("vmo");
break;
default:
str->AppendPrintf("%" PRIu32, type->coded_handle.handle_subtype);
break;
}
str->Append(">");
}
FormatNullability(str, type->coded_handle.nullable);
break;
case fidl::kFidlTypeVector:
str->Append("vector<");
FormatElementName(str, type->coded_vector.element);
str->Append(">");
if (type->coded_vector.max_count != FIDL_MAX_SIZE) {
str->AppendPrintf(":%" PRIu32, type->coded_vector.max_count);
}
FormatNullability(str, type->coded_vector.nullable);
break;
case fidl::kFidlTypeTable:
FormatTableName(str, &type->coded_table);
break;
case fidl::kFidlTypeXUnion:
FormatXUnionName(str, &type->coded_xunion);
break;
case fidl::kFidlTypePrimitive:
ZX_PANIC("unrecognized tag");
break;
}
}
} // namespace
size_t fidl_format_type_name(const fidl_type_t* type, char* buffer, size_t capacity) {
if (!type || !buffer || !capacity) {
return 0u;
}
StringBuilder str(buffer, capacity);
FormatTypeName(&str, type);
return str.length();
}