| // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors |
| // Licensed under the MIT License: |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the "Software"), to deal |
| // in the Software without restriction, including without limitation the rights |
| // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| // copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| // THE SOFTWARE. |
| |
| // This program is a code generator plugin for `capnp compile` which writes the schema back to |
| // stdout in roughly capnpc format. |
| |
| #ifndef _GNU_SOURCE |
| #define _GNU_SOURCE |
| #endif |
| |
| #include <capnp/schema.capnp.h> |
| #include "../serialize.h" |
| #include <kj/debug.h> |
| #include <kj/io.h> |
| #include <kj/string-tree.h> |
| #include <kj/vector.h> |
| #include "../schema-loader.h" |
| #include "../dynamic.h" |
| #include <kj/miniposix.h> |
| #include <unordered_map> |
| #include <kj/main.h> |
| #include <algorithm> |
| #include <map> |
| #include <capnp/stream.capnp.h> |
| |
| #if HAVE_CONFIG_H |
| #include "config.h" |
| #endif |
| |
| #ifndef VERSION |
| #define VERSION "(unknown)" |
| #endif |
| |
| namespace capnp { |
| namespace { |
| |
| bool hasDiscriminantValue(const schema::Field::Reader& reader) { |
| return reader.getDiscriminantValue() != schema::Field::NO_DISCRIMINANT; |
| } |
| |
| struct Indent { |
| uint amount; |
| Indent() = default; |
| inline Indent(int amount): amount(amount) {} |
| |
| Indent next() { |
| return Indent(amount + 2); |
| } |
| |
| struct Iterator { |
| uint i; |
| Iterator() = default; |
| inline Iterator(uint i): i(i) {} |
| inline char operator*() const { return ' '; } |
| inline Iterator& operator++() { ++i; return *this; } |
| inline Iterator operator++(int) { Iterator result = *this; ++i; return result; } |
| inline bool operator==(const Iterator& other) const { return i == other.i; } |
| inline bool operator!=(const Iterator& other) const { return i != other.i; } |
| }; |
| |
| inline size_t size() const { return amount; } |
| |
| inline Iterator begin() const { return Iterator(0); } |
| inline Iterator end() const { return Iterator(amount); } |
| }; |
| |
| inline Indent KJ_STRINGIFY(const Indent& indent) { |
| return indent; |
| } |
| |
| // ======================================================================================= |
| |
| class CapnpcCapnpMain { |
| public: |
| CapnpcCapnpMain(kj::ProcessContext& context): context(context) {} |
| |
| kj::MainFunc getMain() { |
| return kj::MainBuilder(context, "Cap'n Proto loopback plugin version " VERSION, |
| "This is a Cap'n Proto compiler plugin which \"de-compiles\" the schema back into " |
| "Cap'n Proto schema language format, with comments showing the offsets chosen by the " |
| "compiler. This is meant to be run using the Cap'n Proto compiler, e.g.:\n" |
| " capnp compile -ocapnp foo.capnp") |
| .callAfterParsing(KJ_BIND_METHOD(*this, run)) |
| .build(); |
| } |
| |
| private: |
| kj::ProcessContext& context; |
| SchemaLoader schemaLoader; |
| |
| Text::Reader getUnqualifiedName(Schema schema) { |
| auto proto = schema.getProto(); |
| KJ_CONTEXT(proto.getDisplayName()); |
| auto parent = schemaLoader.get(proto.getScopeId()); |
| for (auto nested: parent.getProto().getNestedNodes()) { |
| if (nested.getId() == proto.getId()) { |
| return nested.getName(); |
| } |
| } |
| KJ_FAIL_REQUIRE("A schema Node's supposed scope did not contain the node as a NestedNode."); |
| return "(?)"; |
| } |
| |
| kj::StringTree nodeName(Schema target, Schema scope, schema::Brand::Reader brand, |
| kj::Maybe<InterfaceSchema::Method> method) { |
| kj::Vector<Schema> targetPath; |
| kj::Vector<Schema> scopeParts; |
| |
| targetPath.add(target); |
| |
| std::map<uint64_t, List<schema::Brand::Binding>::Reader> scopeBindings; |
| for (auto scopeBrand: brand.getScopes()) { |
| switch (scopeBrand.which()) { |
| case schema::Brand::Scope::BIND: |
| scopeBindings[scopeBrand.getScopeId()] = scopeBrand.getBind(); |
| break; |
| case schema::Brand::Scope::INHERIT: |
| // TODO(someday): We need to pay attention to INHERIT and be sure to explicitly override |
| // any bindings that are not inherited. This requires a way to determine which of our |
| // parent scopes have a non-empty parameter list. |
| break; |
| } |
| } |
| |
| { |
| Schema parent = target; |
| while (parent.getProto().getScopeId() != 0) { |
| parent = schemaLoader.get(parent.getProto().getScopeId()); |
| targetPath.add(parent); |
| } |
| } |
| |
| { |
| Schema parent = scope; |
| scopeParts.add(parent); |
| while (parent.getProto().getScopeId() != 0) { |
| parent = schemaLoader.get(parent.getProto().getScopeId()); |
| scopeParts.add(parent); |
| } |
| } |
| |
| // Remove common scope (unless it has been reparameterized). |
| // TODO(someday): This is broken in that we aren't checking for shadowing. |
| while (!scopeParts.empty() && targetPath.size() > 1 && |
| scopeParts.back() == targetPath.back() && |
| scopeBindings.count(scopeParts.back().getProto().getId()) == 0) { |
| scopeParts.removeLast(); |
| targetPath.removeLast(); |
| } |
| |
| auto parts = kj::heapArrayBuilder<kj::StringTree>(targetPath.size()); |
| while (!targetPath.empty()) { |
| auto part = targetPath.back(); |
| auto proto = part.getProto(); |
| kj::StringTree partStr; |
| if (proto.getScopeId() == 0) { |
| partStr = kj::strTree("import \"/", proto.getDisplayName(), '\"'); |
| } else { |
| partStr = kj::strTree(getUnqualifiedName(part)); |
| } |
| |
| auto iter = scopeBindings.find(proto.getId()); |
| if (iter != scopeBindings.end()) { |
| auto bindings = KJ_MAP(binding, iter->second) { |
| switch (binding.which()) { |
| case schema::Brand::Binding::UNBOUND: |
| return kj::strTree("AnyPointer"); |
| case schema::Brand::Binding::TYPE: |
| return genType(binding.getType(), scope, method); |
| } |
| return kj::strTree("<unknown binding>"); |
| }; |
| partStr = kj::strTree(kj::mv(partStr), "(", kj::StringTree(kj::mv(bindings), ", "), ")"); |
| } |
| |
| parts.add(kj::mv(partStr)); |
| targetPath.removeLast(); |
| } |
| |
| return kj::StringTree(parts.finish(), "."); |
| } |
| |
| kj::StringTree genType(schema::Type::Reader type, Schema scope, |
| kj::Maybe<InterfaceSchema::Method> method) { |
| switch (type.which()) { |
| case schema::Type::VOID: return kj::strTree("Void"); |
| case schema::Type::BOOL: return kj::strTree("Bool"); |
| case schema::Type::INT8: return kj::strTree("Int8"); |
| case schema::Type::INT16: return kj::strTree("Int16"); |
| case schema::Type::INT32: return kj::strTree("Int32"); |
| case schema::Type::INT64: return kj::strTree("Int64"); |
| case schema::Type::UINT8: return kj::strTree("UInt8"); |
| case schema::Type::UINT16: return kj::strTree("UInt16"); |
| case schema::Type::UINT32: return kj::strTree("UInt32"); |
| case schema::Type::UINT64: return kj::strTree("UInt64"); |
| case schema::Type::FLOAT32: return kj::strTree("Float32"); |
| case schema::Type::FLOAT64: return kj::strTree("Float64"); |
| case schema::Type::TEXT: return kj::strTree("Text"); |
| case schema::Type::DATA: return kj::strTree("Data"); |
| case schema::Type::LIST: |
| return kj::strTree("List(", genType(type.getList().getElementType(), scope, method), ")"); |
| case schema::Type::ENUM: |
| return nodeName(schemaLoader.get(type.getEnum().getTypeId()), scope, |
| type.getEnum().getBrand(), method); |
| case schema::Type::STRUCT: |
| return nodeName(schemaLoader.get(type.getStruct().getTypeId()), scope, |
| type.getStruct().getBrand(), method); |
| case schema::Type::INTERFACE: |
| return nodeName(schemaLoader.get(type.getInterface().getTypeId()), scope, |
| type.getInterface().getBrand(), method); |
| case schema::Type::ANY_POINTER: { |
| auto anyPointer = type.getAnyPointer(); |
| switch (anyPointer.which()) { |
| case schema::Type::AnyPointer::UNCONSTRAINED: |
| switch (anyPointer.getUnconstrained().which()) { |
| case schema::Type::AnyPointer::Unconstrained::ANY_KIND: |
| return kj::strTree("AnyPointer"); |
| case schema::Type::AnyPointer::Unconstrained::STRUCT: |
| return kj::strTree("AnyStruct"); |
| case schema::Type::AnyPointer::Unconstrained::LIST: |
| return kj::strTree("AnyList"); |
| case schema::Type::AnyPointer::Unconstrained::CAPABILITY: |
| return kj::strTree("Capability"); |
| } |
| KJ_UNREACHABLE; |
| case schema::Type::AnyPointer::PARAMETER: { |
| auto param = anyPointer.getParameter(); |
| auto scopeProto = scope.getProto(); |
| auto targetScopeId = param.getScopeId(); |
| while (scopeProto.getId() != targetScopeId) { |
| scopeProto = schemaLoader.get(param.getScopeId()).getProto(); |
| } |
| auto params = scopeProto.getParameters(); |
| KJ_REQUIRE(param.getParameterIndex() < params.size()); |
| return kj::strTree(params[param.getParameterIndex()].getName()); |
| } |
| case schema::Type::AnyPointer::IMPLICIT_METHOD_PARAMETER: { |
| auto params = KJ_REQUIRE_NONNULL(method).getProto().getImplicitParameters(); |
| uint index = anyPointer.getImplicitMethodParameter().getParameterIndex(); |
| KJ_REQUIRE(index < params.size()); |
| return kj::strTree(params[index].getName()); |
| } |
| } |
| KJ_UNREACHABLE; |
| } |
| } |
| return kj::strTree(); |
| } |
| |
| int typeSizeBits(schema::Type::Reader type) { |
| switch (type.which()) { |
| case schema::Type::VOID: return 0; |
| case schema::Type::BOOL: return 1; |
| case schema::Type::INT8: return 8; |
| case schema::Type::INT16: return 16; |
| case schema::Type::INT32: return 32; |
| case schema::Type::INT64: return 64; |
| case schema::Type::UINT8: return 8; |
| case schema::Type::UINT16: return 16; |
| case schema::Type::UINT32: return 32; |
| case schema::Type::UINT64: return 64; |
| case schema::Type::FLOAT32: return 32; |
| case schema::Type::FLOAT64: return 64; |
| case schema::Type::TEXT: return -1; |
| case schema::Type::DATA: return -1; |
| case schema::Type::LIST: return -1; |
| case schema::Type::ENUM: return 16; |
| case schema::Type::STRUCT: return -1; |
| case schema::Type::INTERFACE: return -1; |
| case schema::Type::ANY_POINTER: return -1; |
| } |
| return 0; |
| } |
| |
| bool isEmptyValue(schema::Value::Reader value) { |
| switch (value.which()) { |
| case schema::Value::VOID: return true; |
| case schema::Value::BOOL: return value.getBool() == false; |
| case schema::Value::INT8: return value.getInt8() == 0; |
| case schema::Value::INT16: return value.getInt16() == 0; |
| case schema::Value::INT32: return value.getInt32() == 0; |
| case schema::Value::INT64: return value.getInt64() == 0; |
| case schema::Value::UINT8: return value.getUint8() == 0; |
| case schema::Value::UINT16: return value.getUint16() == 0; |
| case schema::Value::UINT32: return value.getUint32() == 0; |
| case schema::Value::UINT64: return value.getUint64() == 0; |
| case schema::Value::FLOAT32: return value.getFloat32() == 0; |
| case schema::Value::FLOAT64: return value.getFloat64() == 0; |
| case schema::Value::TEXT: return !value.hasText(); |
| case schema::Value::DATA: return !value.hasData(); |
| case schema::Value::LIST: return !value.hasList(); |
| case schema::Value::ENUM: return value.getEnum() == 0; |
| case schema::Value::STRUCT: return !value.hasStruct(); |
| case schema::Value::INTERFACE: return true; |
| case schema::Value::ANY_POINTER: return true; |
| } |
| return true; |
| } |
| |
| kj::StringTree genValue(Type type, schema::Value::Reader value) { |
| switch (value.which()) { |
| case schema::Value::VOID: return kj::strTree("void"); |
| case schema::Value::BOOL: |
| return kj::strTree(value.getBool() ? "true" : "false"); |
| case schema::Value::INT8: return kj::strTree((int)value.getInt8()); |
| case schema::Value::INT16: return kj::strTree(value.getInt16()); |
| case schema::Value::INT32: return kj::strTree(value.getInt32()); |
| case schema::Value::INT64: return kj::strTree(value.getInt64()); |
| case schema::Value::UINT8: return kj::strTree((uint)value.getUint8()); |
| case schema::Value::UINT16: return kj::strTree(value.getUint16()); |
| case schema::Value::UINT32: return kj::strTree(value.getUint32()); |
| case schema::Value::UINT64: return kj::strTree(value.getUint64()); |
| case schema::Value::FLOAT32: return kj::strTree(value.getFloat32()); |
| case schema::Value::FLOAT64: return kj::strTree(value.getFloat64()); |
| case schema::Value::TEXT: |
| return kj::strTree(DynamicValue::Reader(value.getText())); |
| case schema::Value::DATA: |
| return kj::strTree(DynamicValue::Reader(value.getData())); |
| case schema::Value::LIST: { |
| auto listValue = value.getList().getAs<DynamicList>(type.asList()); |
| return kj::strTree(listValue); |
| } |
| case schema::Value::ENUM: { |
| auto enumNode = type.asEnum().getProto(); |
| auto enumerants = enumNode.getEnum().getEnumerants(); |
| KJ_REQUIRE(value.getEnum() < enumerants.size(), |
| "Enum value out-of-range.", value.getEnum(), enumNode.getDisplayName()); |
| return kj::strTree(enumerants[value.getEnum()].getName()); |
| } |
| case schema::Value::STRUCT: { |
| KJ_REQUIRE(type.which() == schema::Type::STRUCT, "type/value mismatch"); |
| auto structValue = value.getStruct().getAs<DynamicStruct>(type.asStruct()); |
| return kj::strTree(structValue); |
| } |
| case schema::Value::INTERFACE: { |
| return kj::strTree(""); |
| } |
| case schema::Value::ANY_POINTER: { |
| return kj::strTree(""); |
| } |
| } |
| return kj::strTree(""); |
| } |
| |
| kj::StringTree genGenericParams(List<schema::Node::Parameter>::Reader params, Schema scope) { |
| if (params.size() == 0) { |
| return kj::strTree(); |
| } |
| |
| return kj::strTree(" (", kj::StringTree( |
| KJ_MAP(param, params) { return kj::strTree(param.getName()); }, ", "), ')'); |
| } |
| kj::StringTree genGenericParams(Schema schema) { |
| auto proto = schema.getProto(); |
| return genGenericParams(proto.getParameters(), schemaLoader.get(proto.getScopeId())); |
| } |
| |
| kj::StringTree genAnnotation(schema::Annotation::Reader annotation, |
| Schema scope, |
| const char* prefix = " ", const char* suffix = "") { |
| auto decl = schemaLoader.get(annotation.getId(), annotation.getBrand(), scope); |
| auto proto = decl.getProto(); |
| KJ_REQUIRE(proto.isAnnotation()); |
| auto annDecl = proto.getAnnotation(); |
| |
| auto value = genValue(schemaLoader.getType(annDecl.getType(), decl), |
| annotation.getValue()).flatten(); |
| if (value.startsWith("(")) { |
| return kj::strTree(prefix, "$", nodeName(decl, scope, annotation.getBrand(), nullptr), |
| value, suffix); |
| } else { |
| return kj::strTree(prefix, "$", nodeName(decl, scope, annotation.getBrand(), nullptr), |
| "(", value, ")", suffix); |
| } |
| } |
| |
| kj::StringTree genAnnotations(List<schema::Annotation>::Reader list, Schema scope) { |
| return kj::strTree(KJ_MAP(ann, list) { return genAnnotation(ann, scope); }); |
| } |
| kj::StringTree genAnnotations(Schema schema) { |
| auto proto = schema.getProto(); |
| return genAnnotations(proto.getAnnotations(), schemaLoader.get(proto.getScopeId())); |
| } |
| |
| const char* elementSizeName(schema::ElementSize size) { |
| switch (size) { |
| case schema::ElementSize::EMPTY: return "void"; |
| case schema::ElementSize::BIT: return "1-bit"; |
| case schema::ElementSize::BYTE: return "8-bit"; |
| case schema::ElementSize::TWO_BYTES: return "16-bit"; |
| case schema::ElementSize::FOUR_BYTES: return "32-bit"; |
| case schema::ElementSize::EIGHT_BYTES: return "64-bit"; |
| case schema::ElementSize::POINTER: return "pointer"; |
| case schema::ElementSize::INLINE_COMPOSITE: return "inline composite"; |
| } |
| return ""; |
| } |
| |
| struct OrderByCodeOrder { |
| template <typename T> |
| inline bool operator()(const T& a, const T& b) const { |
| return a.getProto().getCodeOrder() < b.getProto().getCodeOrder(); |
| } |
| }; |
| |
| template <typename MemberList> |
| kj::Array<decltype(kj::instance<MemberList>()[0])> sortByCodeOrder(MemberList&& list) { |
| auto sorted = KJ_MAP(item, list) { return item; }; |
| std::sort(sorted.begin(), sorted.end(), OrderByCodeOrder()); |
| return kj::mv(sorted); |
| } |
| |
| kj::Array<kj::StringTree> genStructFields(StructSchema schema, Indent indent) { |
| // Slightly hacky: We want to print in code order, but we also need to print the union in one |
| // chunk. Its fields should be together in code order anyway, but it's easier to simply |
| // output the whole union in place of the first union field, and then output nothing for the |
| // subsequent fields. |
| |
| bool seenUnion = false; |
| return KJ_MAP(field, sortByCodeOrder(schema.getFields())) { |
| if (hasDiscriminantValue(field.getProto())) { |
| if (seenUnion) { |
| return kj::strTree(); |
| } else { |
| seenUnion = true; |
| uint offset = schema.getProto().getStruct().getDiscriminantOffset(); |
| |
| // GCC 4.7.3 crashes if you inline unionFields. |
| auto unionFields = sortByCodeOrder(schema.getUnionFields()); |
| return kj::strTree( |
| indent, "union { # tag bits [", offset * 16, ", ", offset * 16 + 16, ")\n", |
| KJ_MAP(uField, unionFields) { |
| return genStructField(uField, schema, indent.next()); |
| }, |
| indent, "}\n"); |
| } |
| } else { |
| return genStructField(field, schema, indent); |
| } |
| }; |
| } |
| |
| kj::StringTree genStructField(StructSchema::Field field, Schema scope, Indent indent) { |
| auto proto = field.getProto(); |
| switch (proto.which()) { |
| case schema::Field::SLOT: { |
| auto slot = proto.getSlot(); |
| int size = typeSizeBits(slot.getType()); |
| return kj::strTree( |
| indent, proto.getName(), " @", proto.getOrdinal().getExplicit(), |
| " :", genType(slot.getType(), scope, nullptr), |
| isEmptyValue(slot.getDefaultValue()) ? kj::strTree("") : |
| kj::strTree(" = ", genValue(field.getType(), slot.getDefaultValue())), |
| genAnnotations(proto.getAnnotations(), scope), |
| "; # ", size == -1 ? kj::strTree("ptr[", slot.getOffset(), "]") |
| : kj::strTree("bits[", slot.getOffset() * size, ", ", |
| (slot.getOffset() + 1) * size, ")"), |
| hasDiscriminantValue(proto) |
| ? kj::strTree(", union tag = ", proto.getDiscriminantValue()) : kj::strTree(), |
| "\n"); |
| } |
| case schema::Field::GROUP: { |
| auto group = field.getType().asStruct(); |
| return kj::strTree( |
| indent, proto.getName(), |
| " :group", genAnnotations(proto.getAnnotations(), scope), " {", |
| hasDiscriminantValue(proto) |
| ? kj::strTree(" # union tag = ", proto.getDiscriminantValue()) : kj::strTree(), |
| "\n", |
| genStructFields(group, indent.next()), |
| indent, "}\n"); |
| } |
| } |
| return kj::strTree(); |
| } |
| |
| kj::StringTree genParamList(InterfaceSchema interface, StructSchema schema, |
| schema::Brand::Reader brand, InterfaceSchema::Method method) { |
| if (schema.getProto().getId() == typeId<StreamResult>()) { |
| return kj::strTree("stream"); |
| } else if (schema.getProto().getScopeId() == 0) { |
| // A named parameter list. |
| return kj::strTree("(", kj::StringTree( |
| KJ_MAP(field, schema.getFields()) { |
| auto proto = field.getProto(); |
| auto slot = proto.getSlot(); |
| |
| return kj::strTree( |
| proto.getName(), " :", genType(slot.getType(), interface, nullptr), |
| isEmptyValue(slot.getDefaultValue()) ? kj::strTree("") : |
| kj::strTree(" = ", genValue(field.getType(), slot.getDefaultValue())), |
| genAnnotations(proto.getAnnotations(), interface)); |
| }, ", "), ")"); |
| } else { |
| return nodeName(schema, interface, brand, method); |
| } |
| } |
| |
| kj::StringTree genSuperclasses(InterfaceSchema interface) { |
| auto superclasses = interface.getProto().getInterface().getSuperclasses(); |
| if (superclasses.size() == 0) { |
| return kj::strTree(); |
| } else { |
| return kj::strTree(" superclasses(", kj::StringTree( |
| KJ_MAP(superclass, superclasses) { |
| return nodeName(schemaLoader.get(superclass.getId()), interface, |
| superclass.getBrand(), nullptr); |
| }, ", "), ")"); |
| } |
| } |
| |
| kj::StringTree genDecl(Schema schema, Text::Reader name, uint64_t scopeId, Indent indent) { |
| auto proto = schema.getProto(); |
| if (proto.getScopeId() != scopeId) { |
| // This appears to be an alias for something declared elsewhere. |
| KJ_FAIL_REQUIRE("Aliases not implemented."); |
| } |
| |
| switch (proto.which()) { |
| case schema::Node::FILE: |
| KJ_FAIL_REQUIRE("Encountered nested file node."); |
| break; |
| case schema::Node::STRUCT: { |
| auto structProto = proto.getStruct(); |
| return kj::strTree( |
| indent, "struct ", name, |
| " @0x", kj::hex(proto.getId()), genGenericParams(schema), |
| genAnnotations(schema), " { # ", |
| structProto.getDataWordCount() * 8, " bytes, ", |
| structProto.getPointerCount(), " ptrs", |
| structProto.getPreferredListEncoding() == schema::ElementSize::INLINE_COMPOSITE |
| ? kj::strTree() |
| : kj::strTree(", packed as ", |
| elementSizeName(structProto.getPreferredListEncoding())), |
| "\n", |
| genStructFields(schema.asStruct(), indent.next()), |
| genNestedDecls(schema, indent.next()), |
| indent, "}\n"); |
| } |
| case schema::Node::ENUM: { |
| return kj::strTree( |
| indent, "enum ", name, " @0x", kj::hex(proto.getId()), genAnnotations(schema), " {\n", |
| KJ_MAP(enumerant, sortByCodeOrder(schema.asEnum().getEnumerants())) { |
| return kj::strTree(indent.next(), enumerant.getProto().getName(), " @", |
| enumerant.getIndex(), |
| genAnnotations(enumerant.getProto().getAnnotations(), schema), |
| ";\n"); |
| }, |
| genNestedDecls(schema, indent.next()), |
| indent, "}\n"); |
| } |
| case schema::Node::INTERFACE: { |
| auto interface = schema.asInterface(); |
| return kj::strTree( |
| indent, "interface ", name, " @0x", kj::hex(proto.getId()), genGenericParams(schema), |
| genSuperclasses(interface), |
| genAnnotations(schema), " {\n", |
| KJ_MAP(method, sortByCodeOrder(interface.getMethods())) { |
| auto methodProto = method.getProto(); |
| |
| auto implicits = methodProto.getImplicitParameters(); |
| kj::StringTree implicitsStr; |
| if (implicits.size() > 0) { |
| implicitsStr = kj::strTree( |
| "[", kj::StringTree(KJ_MAP(implicit, implicits) { |
| return kj::strTree(implicit.getName()); |
| }, ", "), "] "); |
| } |
| |
| auto params = schemaLoader.get(methodProto.getParamStructType()).asStruct(); |
| auto results = schemaLoader.get(methodProto.getResultStructType()).asStruct(); |
| return kj::strTree( |
| indent.next(), methodProto.getName(), |
| " @", method.getIndex(), " ", kj::mv(implicitsStr), |
| genParamList(interface, params, methodProto.getParamBrand(), method), " -> ", |
| genParamList(interface, results, methodProto.getResultBrand(), method), |
| genAnnotations(methodProto.getAnnotations(), interface), ";\n"); |
| }, |
| genNestedDecls(schema, indent.next()), |
| indent, "}\n"); |
| } |
| case schema::Node::CONST: { |
| auto constProto = proto.getConst(); |
| return kj::strTree( |
| indent, "const ", name, " @0x", kj::hex(proto.getId()), " :", |
| genType(constProto.getType(), schema, nullptr), " = ", |
| genValue(schema.asConst().getType(), constProto.getValue()), |
| genAnnotations(schema), ";\n"); |
| } |
| case schema::Node::ANNOTATION: { |
| auto annotationProto = proto.getAnnotation(); |
| |
| kj::Vector<kj::String> targets(8); |
| bool targetsAll = true; |
| |
| auto dynamic = toDynamic(annotationProto); |
| for (auto field: dynamic.getSchema().getFields()) { |
| auto fieldName = field.getProto().getName(); |
| if (fieldName.startsWith("targets")) { |
| if (dynamic.get(field).as<bool>()) { |
| auto target = kj::str(fieldName.slice(strlen("targets"))); |
| target[0] = target[0] - 'A' + 'a'; |
| targets.add(kj::mv(target)); |
| } else { |
| targetsAll = false; |
| } |
| } |
| } |
| |
| if (targetsAll) { |
| targets = kj::Vector<kj::String>(1); |
| targets.add(kj::heapString("*")); |
| } |
| |
| return kj::strTree( |
| indent, "annotation ", name, " @0x", kj::hex(proto.getId()), |
| " (", strArray(targets, ", "), ") :", |
| genType(annotationProto.getType(), schema, nullptr), genAnnotations(schema), ";\n"); |
| } |
| } |
| |
| return kj::strTree(); |
| } |
| |
| kj::StringTree genNestedDecls(Schema schema, Indent indent) { |
| uint64_t id = schema.getProto().getId(); |
| return kj::strTree(KJ_MAP(nested, schema.getProto().getNestedNodes()) { |
| return genDecl(schemaLoader.get(nested.getId()), nested.getName(), id, indent); |
| }); |
| } |
| |
| kj::StringTree genFile(Schema file) { |
| auto proto = file.getProto(); |
| KJ_REQUIRE(proto.isFile(), "Expected a file node.", (uint)proto.which()); |
| |
| return kj::strTree( |
| "# ", proto.getDisplayName(), "\n", |
| "@0x", kj::hex(proto.getId()), ";\n", |
| KJ_MAP(ann, proto.getAnnotations()) { return genAnnotation(ann, file, "", ";\n"); }, |
| genNestedDecls(file, Indent(0))); |
| } |
| |
| kj::MainBuilder::Validity run() { |
| ReaderOptions options; |
| options.traversalLimitInWords = 1 << 30; // Don't limit. |
| StreamFdMessageReader reader(STDIN_FILENO, options); |
| auto request = reader.getRoot<schema::CodeGeneratorRequest>(); |
| |
| for (auto node: request.getNodes()) { |
| schemaLoader.load(node); |
| } |
| |
| kj::FdOutputStream rawOut(STDOUT_FILENO); |
| kj::BufferedOutputStreamWrapper out(rawOut); |
| |
| for (auto requestedFile: request.getRequestedFiles()) { |
| genFile(schemaLoader.get(requestedFile.getId())).visit( |
| [&](kj::ArrayPtr<const char> text) { |
| out.write(text.begin(), text.size()); |
| }); |
| } |
| |
| return true; |
| } |
| }; |
| |
| } // namespace |
| } // namespace capnp |
| |
| KJ_MAIN(capnp::CapnpcCapnpMain); |
