rshen/c-capnproto
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update compiler to support groups/unions

Browse source
This commit is contained in:
James McKaskill 2013-09-12 13:49:19 -04:00
parent 7731509861
commit 9f75d0c7a6
6 changed files with 1588 additions and 1679 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Makefile
View file

@ -1,7 +1,7 @@
.PHONY: all clean test
LDFLAGS=-g -Wall -Werror -fPIC
CFLAGS=-g -Wall -Werror -fPIC -I. -Wno-unused-function -ansi -pedantic
CFLAGS=-g -Wall -Werror -fPIC -I. -Wno-unused-function
all: capn.so capnpc-c test

1161
compiler/capnpc-c.c
View file

File diff suppressed because it is too large Load diff

437
compiler/schema.capnp
View file

@ -21,9 +21,10 @@
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@0xb471df2f45ca32c7;
using Cxx = import "c++.capnp";
# WARNING: This protocol is still subject to backwards-incompatible change.
@0xa93fc509624c72d9;
$Cxx.namespace("capnp::schema");
using Id = UInt64;
# The globally-unique ID of a file, type, or annotation.
@ -37,13 +38,18 @@ struct Node {
#
# (On Zooko's triangle, this is the node's nickname.)
scopeId @2 :Id = 0;
# ID of the lexical parent node. Typically, the scope node will have a NestedNode pointing back
# at this node, but robust code should avoid relying on this. `scopeId` is zero if the node has
# no parent, which is normally only the case with files, but should be allowed for any kind of
# node (in order to make runtime type generation easier).
displayNamePrefixLength @2 :UInt32;
# If you want a shorter version of `displayName` (just naming this node, without its surrounding
# scope), chop off this many characters from the beginning of `displayName`.
nestedNodes @3 :List(NestedNode);
scopeId @3 :Id;
# ID of the lexical parent node. Typically, the scope node will have a NestedNode pointing back
# at this node, but robust code should avoid relying on this (and, in fact, group nodes are not
# listed in the outer struct's nestedNodes, since they are listed in the fields). `scopeId` is
# zero if the node has no parent, which is normally only the case with files, but should be
# allowed for any kind of node (in order to make runtime type generation easier).
nestedNodes @4 :List(NestedNode);
# List of nodes nested within this node, along with the names under which they were declared.
struct NestedNode {
@ -57,194 +63,154 @@ struct Node {
# robust code should avoid relying on this.
}
annotations @4 :List(Annotation);
annotations @5 :List(Annotation);
# Annotations applied to this node.
body @5 union {
union {
# Info specific to each kind of node.
fileNode @6 :FileNode;
structNode @7 :StructNode;
enumNode @8 :EnumNode;
interfaceNode @9 :InterfaceNode;
constNode @10 :ConstNode;
annotationNode @11 :AnnotationNode;
}
}
file @6 :Void;
struct Type {
# Represents a type expression.
struct :group {
dataWordCount @7 :UInt16;
# Size of the data section, in words.
body @0 union {
voidType @1 :Void;
boolType @2 :Void;
int8Type @3 :Void;
int16Type @4 :Void;
int32Type @5 :Void;
int64Type @6 :Void;
uint8Type @7 :Void;
uint16Type @8 :Void;
uint32Type @9 :Void;
uint64Type @10 :Void;
float32Type @11 :Void;
float64Type @12 :Void;
textType @13 :Void;
dataType @14 :Void;
pointerCount @8 :UInt16;
# Size of the pointer section, in pointers (which are one word each).
listType @15 :Type; # Value = the element type.
enumType @16 :Id;
structType @17 :Id;
interfaceType @18 :Id;
objectType @19 :Void;
}
}
struct Value {
# Represents a value, e.g. a field default value, constant value, or annotation value.
body @0 union {
# Note ordinals 1 and 10 are intentionally swapped to improve union layout.
voidValue @10 :Void;
boolValue @2 :Bool;
int8Value @3 :Int8;
int16Value @4 :Int16;
int32Value @5 :Int32;
int64Value @6 :Int64;
uint8Value @7 :UInt8;
uint16Value @8 :UInt16;
uint32Value @9 :UInt32;
uint64Value @1 :UInt64;
float32Value @11 :Float32;
float64Value @12 :Float64;
textValue @13 :Text;
dataValue @14 :Data;
listValue @15 :Object;
enumValue @16 :UInt16;
structValue @17 :Object;
interfaceValue @18 :Void;
# The only interface value that can be represented statically is "null", whose methods always
# throw exceptions.
objectValue @19 :Object;
}
}
struct Annotation {
# Describes an annotation applied to a declaration. Note AnnotationNode describes the
# annotation's declaration, while this describes a use of the annotation.
id @0 :Id;
# ID of the annotation node.
value @1 :Value;
}
struct FileNode {
imports @0 :List(Import);
struct Import {
id @0 :Id;
# ID of the imported file.
name @1 :Text;
# Name which *this* file used to refer to the foreign file. This may be a relative name.
# This information is provided because it might be useful for code generation, e.g. to generate
# #include directives in C++.
#
# (On Zooko's triangle, this is the import's petname according to the importing file.)
}
}
enum ElementSize {
# Possible element sizes for encoded lists. These correspond exactly to the possible values of
# the 3-bit element size component of a list pointer.
empty @0; # aka "void", but that's a keyword.
bit @1;
byte @2;
twoBytes @3;
fourBytes @4;
eightBytes @5;
pointer @6;
inlineComposite @7;
}
struct StructNode {
dataSectionWordSize @0 :UInt16;
pointerSectionSize @1 :UInt16;
preferredListEncoding @2 :ElementSize;
preferredListEncoding @9 :ElementSize;
# The preferred element size to use when encoding a list of this struct. If this is anything
# other than `inlineComposite` then the struct is one word or less in size and is a candidate for
# list packing optimization.
# other than `inlineComposite` then the struct is one word or less in size and is a candidate
# for list packing optimization.
members @3 :List(Member);
# Top-level fields and unions of the struct, ordered by ordinal number, except that members of
# unions are not included in this list (because they are nested inside the union declaration).
# Note that this ordering is stable as the protocol evolves -- new members can only be added to
# the end. So, when encoding a struct as tag/value pairs with numeric tags, it actually may make
# sense to use the field's position in this list rather than the original ordinal number to
# identify fields.
isGroup @10 :Bool;
# If true, then this "struct" node is actually not an independent node, but merely represents
# some named union or group within a particular parent struct. This node's scopeId refers
# to the parent struct, which may itself be a union/group in yet another struct.
#
# All group nodes share the same dataWordCount and pointerCount as the top-level
# struct, and their fields live in the same ordinal and offset spaces as all other fields in
# the struct.
#
# Note that a named union is considered a special kind of group -- in fact, a named union
# is exactly equivalent to a group that contains nothing but an unnamed union.
struct Member {
name @0 :Text;
discriminantCount @11 :UInt16;
# Number of fields in this struct which are members of an anonymous union, and thus may
# overlap. If this is non-zero, then a 16-bit discriminant is present indicating which
# of the overlapping fields is active. This can never be 1 -- if it is non-zero, it must be
# two or more.
#
# Note that the fields of an unnamed union are considered fields of the scope containing the
# union -- an unnamed union is not its own group. So, a top-level struct may contain a
# non-zero discriminant count. Named unions, on the other hand, are equivalent to groups
# containing unnamed unions. So, a named union has its own independent schema node, with
# `isGroup` = true.
ordinal @1 :UInt16;
discriminantOffset @12 :UInt32;
# If `discriminantCount` is non-zero, this is the offset of the union discriminant, in
# multiples of 16 bits.
codeOrder @2 :UInt16;
# Indicates where this member appeared in the code, relative to other members.
# Code ordering may have semantic relevance -- programmers tend to place related fields
# together. So, using code ordering makes sense in human-readable formats where ordering is
# otherwise irrelevant, like JSON. The values of codeOrder are tightly-packed, so for unions
# and non-union fields the maximum value of codeOrder is count(fields) + count(unions).
# Fields that are members of a union are only ordered relative to the other members of that
# union, so the maximum value there is count(union.fields).
fields @13 :List(Field);
# Fields defined within this scope (either the struct's top-level fields, or the fields of
# a particular group; see `isGroup`).
#
# The fields are sorted by ordinal number, but note that because groups share the same
# ordinal space, the field's index in this list is not necessarily exactly its ordinal.
# On the other hand, the field's position in this list does remain the same even as the
# protocol evolves, since it is not possible to insert or remove an earlier ordinal.
# Therefore, for most use cases, if you want to identify a field by number, it may make the
# most sense to use the field's index in this list rather than its ordinal.
}
annotations @3 :List(Annotation);
enum :group {
enumerants@14 :List(Enumerant);
# Enumerants ordered by numeric value (ordinal).
}
body @4 union {
# More member types could be added over time. Consumers should skip those that they
# don't understand.
interface :group {
methods @15 :List(Method);
# Methods ordered by ordinal.
}
fieldMember @5 :Field;
unionMember @6 :Union;
const :group {
type @16 :Type;
value @17 :Value;
}
annotation :group {
type @18 :Type;
targetsFile @19 :Bool;
targetsConst @20 :Bool;
targetsEnum @21 :Bool;
targetsEnumerant @22 :Bool;
targetsStruct @23 :Bool;
targetsField @24 :Bool;
targetsUnion @25 :Bool;
targetsGroup @26 :Bool;
targetsInterface @27 :Bool;
targetsMethod @28 :Bool;
targetsParam @29 :Bool;
targetsAnnotation @30 :Bool;
}
}
}
struct Field {
offset @0 :UInt32;
# Schema for a field of a struct.
name @0 :Text;
codeOrder @1 :UInt16;
# Indicates where this member appeared in the code, relative to other members.
# Code ordering may have semantic relevance -- programmers tend to place related fields
# together. So, using code ordering makes sense in human-readable formats where ordering is
# otherwise irrelevant, like JSON. The values of codeOrder are tightly-packed, so the maximum
# value is count(members) - 1. Fields that are members of a union are only ordered relative to
# the other members of that union, so the maximum value there is count(union.members).
annotations @2 :List(Annotation);
discriminantValue @3 :UInt16 = 0xffff;
# If the field is in a union, this is the value which the union's discriminant should take when
# the field is active. If the field is not in a union, this is 0xffff (so hasDiscriminantValue()
# returns false).
union {
slot :group {
# A regular, non-group, non-fixed-list field.
offset @4 :UInt32;
# Offset, in units of the field's size, from the beginning of the section in which the field
# resides. E.g. for a UInt32 field, multiply this by 4 to get the byte offset from the
# beginning of the data section.
type @1 :Type;
defaultValue @2 :Value;
type @5 :Type;
defaultValue @6 :Value;
}
struct Union {
discriminantOffset @0 :UInt32;
# Offset of the union's 16-bit discriminant within the struct's data section, in 16-bit units.
group :group {
# A group.
members @1 :List(Member);
# Fields of this union, ordered by ordinal. Currently all members are fields, but
# consumers should skip member types that they don't understand. The first member in this list
# gets discriminant value zero, the next gets one, and so on.
#
# TODO(soon): Discriminant zero should be reserved to mean "unset", unless the first field in
# the union actually predates the union (it was retroactively unionized), in which case it
# gets discriminant zero.
typeId @7 :Id;
# The ID of the group's node.
}
}
struct EnumNode {
enumerants @0 :List(Enumerant);
# Enumerants, in order by ordinal.
ordinal :union {
implicit @8 :Void;
explicit @9 :UInt16;
# The original ordinal number given to the field. You probably should NOT use this; if you need
# a numeric identifier for a field, use its position within the field array for its scope.
# The ordinal is given here mainly just so that the original schema text can be reproduced given
# the compiled version -- i.e. so that `capnp compile -ocapnp` can do its job.
}
}
struct Enumerant {
# Schema for member of an enum.
name @0 :Text;
codeOrder @1 :UInt16;
@ -253,13 +219,10 @@ struct EnumNode {
annotations @2 :List(Annotation);
}
}
struct InterfaceNode {
methods @0 :List(Method);
# Methods, in order by ordinal.
struct Method {
# Schema for method of an interface.
name @0 :Text;
codeOrder @1 :UInt16;
@ -283,27 +246,102 @@ struct InterfaceNode {
annotations @5 :List(Annotation);
}
struct Type {
# Represents a type expression.
union {
# The ordinals intentionally match those of Value.
void @0 :Void;
bool @1 :Void;
int8 @2 :Void;
int16 @3 :Void;
int32 @4 :Void;
int64 @5 :Void;
uint8 @6 :Void;
uint16 @7 :Void;
uint32 @8 :Void;
uint64 @9 :Void;
float32 @10 :Void;
float64 @11 :Void;
text @12 :Void;
data @13 :Void;
list :group {
elementType @14 :Type;
}
struct ConstNode {
type @0 :Type;
enum :group {
typeId @15 :Id;
}
struct :group {
typeId @16 :Id;
}
interface :group {
typeId @17 :Id;
}
object @18 :Void;
}
}
struct Value {
# Represents a value, e.g. a field default value, constant value, or annotation value.
union {
# The ordinals intentionally match those of Type.
void @0 :Void;
bool @1 :Bool;
int8 @2 :Int8;
int16 @3 :Int16;
int32 @4 :Int32;
int64 @5 :Int64;
uint8 @6 :UInt8;
uint16 @7 :UInt16;
uint32 @8 :UInt32;
uint64 @9 :UInt64;
float32 @10 :Float32;
float64 @11 :Float64;
text @12 :Text;
data @13 :Data;
list @14 :Object;
enum @15 :UInt16;
struct @16 :Object;
interface @17 :Void;
# The only interface value that can be represented statically is "null", whose methods always
# throw exceptions.
object @18 :Object;
}
}
struct Annotation {
# Describes an annotation applied to a declaration. Note AnnotationNode describes the
# annotation's declaration, while this describes a use of the annotation.
id @0 :Id;
# ID of the annotation node.
value @1 :Value;
}
struct AnnotationNode {
type @0 :Type;
enum ElementSize {
# Possible element sizes for encoded lists. These correspond exactly to the possible values of
# the 3-bit element size component of a list pointer.
targetsFile @1 :Bool;
targetsConst @2 :Bool;
targetsEnum @3 :Bool;
targetsEnumerant @4 :Bool;
targetsStruct @5 :Bool;
targetsField @6 :Bool;
targetsUnion @7 :Bool;
targetsInterface @8 :Bool;
targetsMethod @9 :Bool;
targetsParam @10 :Bool;
targetsAnnotation @11 :Bool;
empty @0; # aka "void", but that's a keyword.
bit @1;
byte @2;
twoBytes @3;
fourBytes @4;
eightBytes @5;
pointer @6;
inlineComposite @7;
}
struct CodeGeneratorRequest {
@ -311,6 +349,31 @@ struct CodeGeneratorRequest {
# All nodes parsed by the compiler, including for the files on the command line and their
# imports.
requestedFiles @1 :List(Id);
# IDs of files which were listed on the command line.
requestedFiles @1 :List(RequestedFile);
# Files which were listed on the command line.
struct RequestedFile {
id @0 :Id;
# ID of the file.
filename @1 :Text;
# Name of the file as it appeared on the command-line (minus the src-prefix). You may use
# this to decide where to write the output.
imports @2 :List(Import);
# List of all imported paths seen in this file.
struct Import {
id @0 :Id;
# ID of the imported file.
name @1 :Text;
# Name which *this* file used to refer to the foreign file. This may be a relative name.
# This information is provided because it might be useful for code generation, e.g. to
# generate #include directives in C++. We don't put this in Node.file because this
# information is only meaningful at compile time anyway.
#
# (On Zooko's triangle, this is the import's petname according to the importing file.)
}
}
}

1051
compiler/schema.capnp.c
View file

File diff suppressed because it is too large Load diff

583
compiler/schema.capnp.h
View file

@ -9,187 +9,42 @@ extern "C" {
struct Node;
struct Node_NestedNode;
struct Field;
struct Enumerant;
struct Method;
struct Method_Param;
struct Type;
struct Value;
struct Annotation;
struct FileNode;
struct FileNode_Import;
struct StructNode;
struct StructNode_Member;
struct StructNode_Field;
struct StructNode_Union;
struct EnumNode;
struct EnumNode_Enumerant;
struct InterfaceNode;
struct InterfaceNode_Method;
struct InterfaceNode_Method_Param;
struct ConstNode;
struct AnnotationNode;
struct CodeGeneratorRequest;
struct CodeGeneratorRequest_RequestedFile;
struct CodeGeneratorRequest_RequestedFile_Import;
typedef struct {capn_ptr p;} Node_ptr;
typedef struct {capn_ptr p;} Node_NestedNode_ptr;
typedef struct {capn_ptr p;} Field_ptr;
typedef struct {capn_ptr p;} Enumerant_ptr;
typedef struct {capn_ptr p;} Method_ptr;
typedef struct {capn_ptr p;} Method_Param_ptr;
typedef struct {capn_ptr p;} Type_ptr;
typedef struct {capn_ptr p;} Value_ptr;
typedef struct {capn_ptr p;} Annotation_ptr;
typedef struct {capn_ptr p;} FileNode_ptr;
typedef struct {capn_ptr p;} FileNode_Import_ptr;
typedef struct {capn_ptr p;} StructNode_ptr;
typedef struct {capn_ptr p;} StructNode_Member_ptr;
typedef struct {capn_ptr p;} StructNode_Field_ptr;
typedef struct {capn_ptr p;} StructNode_Union_ptr;
typedef struct {capn_ptr p;} EnumNode_ptr;
typedef struct {capn_ptr p;} EnumNode_Enumerant_ptr;
typedef struct {capn_ptr p;} InterfaceNode_ptr;
typedef struct {capn_ptr p;} InterfaceNode_Method_ptr;
typedef struct {capn_ptr p;} InterfaceNode_Method_Param_ptr;
typedef struct {capn_ptr p;} ConstNode_ptr;
typedef struct {capn_ptr p;} AnnotationNode_ptr;
typedef struct {capn_ptr p;} CodeGeneratorRequest_ptr;
typedef struct {capn_ptr p;} CodeGeneratorRequest_RequestedFile_ptr;
typedef struct {capn_ptr p;} CodeGeneratorRequest_RequestedFile_Import_ptr;
typedef struct {capn_ptr p;} Node_list;
typedef struct {capn_ptr p;} Node_NestedNode_list;
typedef struct {capn_ptr p;} Field_list;
typedef struct {capn_ptr p;} Enumerant_list;
typedef struct {capn_ptr p;} Method_list;
typedef struct {capn_ptr p;} Method_Param_list;
typedef struct {capn_ptr p;} Type_list;
typedef struct {capn_ptr p;} Value_list;
typedef struct {capn_ptr p;} Annotation_list;
typedef struct {capn_ptr p;} FileNode_list;
typedef struct {capn_ptr p;} FileNode_Import_list;
typedef struct {capn_ptr p;} StructNode_list;
typedef struct {capn_ptr p;} StructNode_Member_list;
typedef struct {capn_ptr p;} StructNode_Field_list;
typedef struct {capn_ptr p;} StructNode_Union_list;
typedef struct {capn_ptr p;} EnumNode_list;
typedef struct {capn_ptr p;} EnumNode_Enumerant_list;
typedef struct {capn_ptr p;} InterfaceNode_list;
typedef struct {capn_ptr p;} InterfaceNode_Method_list;
typedef struct {capn_ptr p;} InterfaceNode_Method_Param_list;
typedef struct {capn_ptr p;} ConstNode_list;
typedef struct {capn_ptr p;} AnnotationNode_list;
typedef struct {capn_ptr p;} CodeGeneratorRequest_list;
enum Node_body {
Node_fileNode = 0,
Node_structNode = 1,
Node_enumNode = 2,
Node_interfaceNode = 3,
Node_constNode = 4,
Node_annotationNode = 5
};
struct Node {
uint64_t id;
capn_text displayName;
uint64_t scopeId;
Node_NestedNode_list nestedNodes;
Annotation_list annotations;
enum Node_body body_tag;
union {
FileNode_ptr fileNode;
StructNode_ptr structNode;
EnumNode_ptr enumNode;
InterfaceNode_ptr interfaceNode;
ConstNode_ptr constNode;
AnnotationNode_ptr annotationNode;
} body;
};
struct Node_NestedNode {
capn_text name;
uint64_t id;
};
enum Type_body {
Type_voidType = 0,
Type_boolType = 1,
Type_int8Type = 2,
Type_int16Type = 3,
Type_int32Type = 4,
Type_int64Type = 5,
Type_uint8Type = 6,
Type_uint16Type = 7,
Type_uint32Type = 8,
Type_uint64Type = 9,
Type_float32Type = 10,
Type_float64Type = 11,
Type_textType = 12,
Type_dataType = 13,
Type_listType = 14,
Type_enumType = 15,
Type_structType = 16,
Type_interfaceType = 17,
Type_objectType = 18
};
struct Type {
enum Type_body body_tag;
union {
Type_ptr listType;
uint64_t enumType;
uint64_t structType;
uint64_t interfaceType;
} body;
};
enum Value_body {
Value_voidValue = 9,
Value_boolValue = 1,
Value_int8Value = 2,
Value_int16Value = 3,
Value_int32Value = 4,
Value_int64Value = 5,
Value_uint8Value = 6,
Value_uint16Value = 7,
Value_uint32Value = 8,
Value_uint64Value = 0,
Value_float32Value = 10,
Value_float64Value = 11,
Value_textValue = 12,
Value_dataValue = 13,
Value_listValue = 14,
Value_enumValue = 15,
Value_structValue = 16,
Value_interfaceValue = 17,
Value_objectValue = 18
};
struct Value {
enum Value_body body_tag;
union {
unsigned boolValue:1;
int8_t int8Value;
int16_t int16Value;
int32_t int32Value;
int64_t int64Value;
uint8_t uint8Value;
uint16_t uint16Value;
uint32_t uint32Value;
uint64_t uint64Value;
float float32Value;
double float64Value;
capn_text textValue;
capn_data dataValue;
capn_ptr listValue;
uint16_t enumValue;
capn_ptr structValue;
capn_ptr objectValue;
} body;
};
struct Annotation {
uint64_t id;
Value_ptr value;
};
struct FileNode {
FileNode_Import_list imports;
};
struct FileNode_Import {
uint64_t id;
capn_text name;
};
typedef struct {capn_ptr p;} CodeGeneratorRequest_RequestedFile_list;
typedef struct {capn_ptr p;} CodeGeneratorRequest_RequestedFile_Import_list;
enum ElementSize {
ElementSize_empty = 0,
@ -202,77 +57,49 @@ enum ElementSize {
ElementSize_inlineComposite = 7
};
struct StructNode {
uint16_t dataSectionWordSize;
uint16_t pointerSectionSize;
enum ElementSize preferredListEncoding;
StructNode_Member_list members;
enum Node_which {
Node_file = 0,
Node_struct = 1,
Node_enum = 2,
Node_interface = 3,
Node_const = 4,
Node_annotation = 5
};
enum StructNode_Member_body {
StructNode_Member_fieldMember = 0,
StructNode_Member_unionMember = 1
};
struct StructNode_Member {
capn_text name;
uint16_t ordinal;
uint16_t codeOrder;
struct Node {
uint64_t id;
capn_text displayName;
uint32_t displayNamePrefixLength;
uint64_t scopeId;
Node_NestedNode_list nestedNodes;
Annotation_list annotations;
enum StructNode_Member_body body_tag;
enum Node_which which;
union {
StructNode_Field_ptr fieldMember;
StructNode_Union_ptr unionMember;
} body;
};
struct {
uint16_t dataWordCount;
uint16_t pointerCount;
enum ElementSize preferredListEncoding;
unsigned isGroup : 1;
uint16_t discriminantCount;
uint16_t discriminantOffset;
Field_list fields;
} _struct;
struct StructNode_Field {
uint32_t offset;
Type_ptr type;
Value_ptr defaultValue;
};
struct {
Enumerant_list enumerants;
} _enum;
struct StructNode_Union {
uint32_t discriminantOffset;
StructNode_Member_list members;
};
struct {
Method_list methods;
} _interface;
struct EnumNode {
EnumNode_Enumerant_list enumerants;
};
struct EnumNode_Enumerant {
capn_text name;
uint16_t codeOrder;
Annotation_list annotations;
};
struct InterfaceNode {
InterfaceNode_Method_list methods;
};
struct InterfaceNode_Method {
capn_text name;
uint16_t codeOrder;
InterfaceNode_Method_Param_list params;
uint16_t requiredParamCount;
Type_ptr returnType;
Annotation_list annotations;
};
struct InterfaceNode_Method_Param {
capn_text name;
Type_ptr type;
Value_ptr defaultValue;
Annotation_list annotations;
};
struct ConstNode {
struct {
Type_ptr type;
Value_ptr value;
};
} _const;
struct AnnotationNode {
struct {
Type_ptr type;
unsigned targetsFile : 1;
unsigned targetsConst : 1;
@ -281,136 +108,262 @@ struct AnnotationNode {
unsigned targetsStruct : 1;
unsigned targetsField : 1;
unsigned targetsUnion : 1;
unsigned targetsGroup : 1;
unsigned targetsInterface : 1;
unsigned targetsMethod : 1;
unsigned targetsParam : 1;
unsigned targetsAnnotation : 1;
} annotation;
};
};
struct Node_NestedNode {
capn_text name;
uint64_t id;
};
enum Field_which {
Field_slot = 0,
Field_group = 1,
};
enum Field_ordinal {
Field_implicit = 8,
Field_explicit = 9,
};
struct Field {
capn_text name;
uint16_t codeOrder;
Annotation_list annotations;
uint16_t discriminantValue;
enum Field_which which;
union {
struct {
uint32_t offset;
Type_ptr type;
Value_ptr defaultValue;
} slot;
struct {
uint64_t typeId;
} group;
};
enum Field_ordinal ordinal_which;
union {
uint16_t _explicit;
} ordinal;
};
struct Enumerant {
capn_text name;
uint16_t codeOrder;
Annotation_list annotations;
};
struct Method {
capn_text name;
uint16_t codeOrder;
Method_Param_list params;
uint16_t requiredParamCount;
Type_ptr returnType;
Annotation_list annotations;
};
struct Method_Param {
capn_text name;
Type_ptr type;
Value_ptr defaultValue;
Annotation_list annotations;
};
enum Type_which {
Type_void = 0,
Type_bool = 1,
Type_int8 = 2,
Type_int16 = 3,
Type_int32 = 4,
Type_int64 = 5,
Type_uint8 = 6,
Type_uint16 = 7,
Type_uint32 = 8,
Type_uint64 = 9,
Type_float32 = 10,
Type_float64 = 11,
Type_text = 12,
Type_data = 13,
Type__list = 14,
Type_enum = 15,
Type_struct = 16,
Type_interface = 17,
Type_object = 18
};
struct Type {
enum Type_which which;
union {
struct {
Type_ptr elementType;
} list;
struct {
uint64_t typeId;
} _enum;
struct {
uint64_t typeId;
} _struct;
struct {
uint64_t typeId;
} _interface;
};
};
enum Value_which {
Value_void = 0,
Value_bool = 1,
Value_int8 = 2,
Value_int16 = 3,
Value_int32 = 4,
Value_int64 = 5,
Value_uint8 = 6,
Value_uint16 = 7,
Value_uint32 = 8,
Value_uint64 = 9,
Value_float32 = 10,
Value_float64 = 11,
Value_text = 12,
Value_data = 13,
Value__list = 14,
Value_enum = 15,
Value_struct = 16,
Value_interface = 17,
Value_object = 18
};
struct Value {
enum Value_which which;
union {
unsigned _bool : 1;
int8_t int8;
int16_t int16;
int32_t int32;
int64_t int64;
uint8_t uint8;
uint16_t uint16;
uint32_t uint32;
uint64_t uint64;
float float32;
double float64;
capn_text text;
capn_data data;
capn_ptr list;
uint16_t _enum;
capn_ptr _struct;
capn_ptr object;
};
};
struct Annotation {
uint64_t id;
Value_ptr value;
};
struct CodeGeneratorRequest {
Node_list nodes;
capn_list64 requestedFiles;
CodeGeneratorRequest_RequestedFile_list requestedFiles;
};
struct CodeGeneratorRequest_RequestedFile {
uint64_t id;
capn_text filename;
CodeGeneratorRequest_RequestedFile_Import_list imports;
};
struct CodeGeneratorRequest_RequestedFile_Import {
uint64_t id;
capn_text name;
};
Node_ptr new_Node(struct capn_segment*);
Node_NestedNode_ptr new_Node_NestedNode(struct capn_segment*);
Field_ptr new_Field(struct capn_segment*);
Enumerant_ptr new_Enumerant(struct capn_segment*);
Method_ptr new_Method(struct capn_segment*);
Method_Param_ptr new_Method_Param(struct capn_segment*);
Type_ptr new_Type(struct capn_segment*);
Value_ptr new_Value(struct capn_segment*);
Annotation_ptr new_Annotation(struct capn_segment*);
FileNode_ptr new_FileNode(struct capn_segment*);
FileNode_Import_ptr new_FileNode_Import(struct capn_segment*);
StructNode_ptr new_StructNode(struct capn_segment*);
StructNode_Member_ptr new_StructNode_Member(struct capn_segment*);
StructNode_Field_ptr new_StructNode_Field(struct capn_segment*);
StructNode_Union_ptr new_StructNode_Union(struct capn_segment*);
EnumNode_ptr new_EnumNode(struct capn_segment*);
EnumNode_Enumerant_ptr new_EnumNode_Enumerant(struct capn_segment*);
InterfaceNode_ptr new_InterfaceNode(struct capn_segment*);
InterfaceNode_Method_ptr new_InterfaceNode_Method(struct capn_segment*);
InterfaceNode_Method_Param_ptr new_InterfaceNode_Method_Param(struct capn_segment*);
ConstNode_ptr new_ConstNode(struct capn_segment*);
AnnotationNode_ptr new_AnnotationNode(struct capn_segment*);
CodeGeneratorRequest_ptr new_CodeGeneratorRequest(struct capn_segment*);
CodeGeneratorRequest_RequestedFile_ptr new_CodeGeneratorRequest_RequestedFile(struct capn_segment*);
CodeGeneratorRequest_RequestedFile_Import_ptr new_CodeGeneratorRequest_RequestedFile_Import(struct capn_segment*);
Node_list new_Node_list(struct capn_segment*, int len);
Node_NestedNode_list new_Node_NestedNode_list(struct capn_segment*, int len);
Field_list new_Field_list(struct capn_segment*, int len);
Enumerant_list new_Enumerant_list(struct capn_segment*, int len);
Method_list new_Method_list(struct capn_segment*, int len);
Method_Param_list new_Method_Param_list(struct capn_segment*, int len);
Type_list new_Type_list(struct capn_segment*, int len);
Value_list new_Value_list(struct capn_segment*, int len);
Annotation_list new_Annotation_list(struct capn_segment*, int len);
FileNode_list new_FileNode_list(struct capn_segment*, int len);
FileNode_Import_list new_FileNode_Import_list(struct capn_segment*, int len);
StructNode_list new_StructNode_list(struct capn_segment*, int len);
StructNode_Member_list new_StructNode_Member_list(struct capn_segment*, int len);
StructNode_Field_list new_StructNode_Field_list(struct capn_segment*, int len);
StructNode_Union_list new_StructNode_Union_list(struct capn_segment*, int len);
EnumNode_list new_EnumNode_list(struct capn_segment*, int len);
EnumNode_Enumerant_list new_EnumNode_Enumerant_list(struct capn_segment*, int len);
InterfaceNode_list new_InterfaceNode_list(struct capn_segment*, int len);
InterfaceNode_Method_list new_InterfaceNode_Method_list(struct capn_segment*, int len);
InterfaceNode_Method_Param_list new_InterfaceNode_Method_Param_list(struct capn_segment*, int len);
ConstNode_list new_ConstNode_list(struct capn_segment*, int len);
AnnotationNode_list new_AnnotationNode_list(struct capn_segment*, int len);
CodeGeneratorRequest_list new_CodeGeneratorRequest_list(struct capn_segment*, int len);
CodeGeneratorRequest_RequestedFile_list new_CodeGeneratorRequest_RequestedFile_list(struct capn_segment*, int len);
CodeGeneratorRequest_RequestedFile_Import_list new_CodeGeneratorRequest_RequestedFile_Import_list(struct capn_segment*, int len);
void read_Node(struct Node*, Node_ptr);
void read_Node_NestedNode(struct Node_NestedNode*, Node_NestedNode_ptr);
void read_Field(struct Field*, Field_ptr);
void read_Enumerant(struct Enumerant*, Enumerant_ptr);
void read_Method(struct Method*, Method_ptr);
void read_Method_Param(struct Method_Param*, Method_Param_ptr);
void read_Type(struct Type*, Type_ptr);
void read_Value(struct Value*, Value_ptr);
void read_Annotation(struct Annotation*, Annotation_ptr);
void read_FileNode(struct FileNode*, FileNode_ptr);
void read_FileNode_Import(struct FileNode_Import*, FileNode_Import_ptr);
void read_StructNode(struct StructNode*, StructNode_ptr);
void read_StructNode_Member(struct StructNode_Member*, StructNode_Member_ptr);
void read_StructNode_Field(struct StructNode_Field*, StructNode_Field_ptr);
void read_StructNode_Union(struct StructNode_Union*, StructNode_Union_ptr);
void read_EnumNode(struct EnumNode*, EnumNode_ptr);
void read_EnumNode_Enumerant(struct EnumNode_Enumerant*, EnumNode_Enumerant_ptr);
void read_InterfaceNode(struct InterfaceNode*, InterfaceNode_ptr);
void read_InterfaceNode_Method(struct InterfaceNode_Method*, InterfaceNode_Method_ptr);
void read_InterfaceNode_Method_Param(struct InterfaceNode_Method_Param*, InterfaceNode_Method_Param_ptr);
void read_ConstNode(struct ConstNode*, ConstNode_ptr);
void read_AnnotationNode(struct AnnotationNode*, AnnotationNode_ptr);
void read_CodeGeneratorRequest(struct CodeGeneratorRequest*, CodeGeneratorRequest_ptr);
void read_CodeGeneratorRequest_RequestedFile(struct CodeGeneratorRequest_RequestedFile*, CodeGeneratorRequest_RequestedFile_ptr);
void read_CodeGeneratorRequest_RequestedFile_Import(struct CodeGeneratorRequest_RequestedFile_Import*, CodeGeneratorRequest_RequestedFile_Import_ptr);
int write_Node(const struct Node*, Node_ptr);
int write_Node_NestedNode(const struct Node_NestedNode*, Node_NestedNode_ptr);
int write_Type(const struct Type*, Type_ptr);
int write_Value(const struct Value*, Value_ptr);
int write_Annotation(const struct Annotation*, Annotation_ptr);
int write_FileNode(const struct FileNode*, FileNode_ptr);
int write_FileNode_Import(const struct FileNode_Import*, FileNode_Import_ptr);
int write_StructNode(const struct StructNode*, StructNode_ptr);
int write_StructNode_Member(const struct StructNode_Member*, StructNode_Member_ptr);
int write_StructNode_Field(const struct StructNode_Field*, StructNode_Field_ptr);
int write_StructNode_Union(const struct StructNode_Union*, StructNode_Union_ptr);
int write_EnumNode(const struct EnumNode*, EnumNode_ptr);
int write_EnumNode_Enumerant(const struct EnumNode_Enumerant*, EnumNode_Enumerant_ptr);
int write_InterfaceNode(const struct InterfaceNode*, InterfaceNode_ptr);
int write_InterfaceNode_Method(const struct InterfaceNode_Method*, InterfaceNode_Method_ptr);
int write_InterfaceNode_Method_Param(const struct InterfaceNode_Method_Param*, InterfaceNode_Method_Param_ptr);
int write_ConstNode(const struct ConstNode*, ConstNode_ptr);
int write_AnnotationNode(const struct AnnotationNode*, AnnotationNode_ptr);
int write_CodeGeneratorRequest(const struct CodeGeneratorRequest*, CodeGeneratorRequest_ptr);
void write_Node(const struct Node*, Node_ptr);
void write_Node_NestedNode(const struct Node_NestedNode*, Node_NestedNode_ptr);
void write_Field(const struct Field*, Field_ptr);
void write_Enumerant(const struct Enumerant*, Enumerant_ptr);
void write_Method(const struct Method*, Method_ptr);
void write_Method_Param(const struct Method_Param*, Method_Param_ptr);
void write_Type(const struct Type*, Type_ptr);
void write_Value(const struct Value*, Value_ptr);
void write_Annotation(const struct Annotation*, Annotation_ptr);
void write_CodeGeneratorRequest(const struct CodeGeneratorRequest*, CodeGeneratorRequest_ptr);
void write_CodeGeneratorRequest_RequestedFile(const struct CodeGeneratorRequest_RequestedFile*, CodeGeneratorRequest_RequestedFile_ptr);
void write_CodeGeneratorRequest_RequestedFile_Import(const struct CodeGeneratorRequest_RequestedFile_Import*, CodeGeneratorRequest_RequestedFile_Import_ptr);
void get_Node(struct Node*, Node_list, int i);
void get_Node_NestedNode(struct Node_NestedNode*, Node_NestedNode_list, int i);
void get_Field(struct Field*, Field_list, int i);
void get_Enumerant(struct Enumerant*, Enumerant_list, int i);
void get_Method(struct Method*, Method_list, int i);
void get_Method_Param(struct Method_Param*, Method_Param_list, int i);
void get_Type(struct Type*, Type_list, int i);
void get_Value(struct Value*, Value_list, int i);
void get_Annotation(struct Annotation*, Annotation_list, int i);
void get_FileNode(struct FileNode*, FileNode_list, int i);
void get_FileNode_Import(struct FileNode_Import*, FileNode_Import_list, int i);
void get_StructNode(struct StructNode*, StructNode_list, int i);
void get_StructNode_Member(struct StructNode_Member*, StructNode_Member_list, int i);
void get_StructNode_Field(struct StructNode_Field*, StructNode_Field_list, int i);
void get_StructNode_Union(struct StructNode_Union*, StructNode_Union_list, int i);
void get_EnumNode(struct EnumNode*, EnumNode_list, int i);
void get_EnumNode_Enumerant(struct EnumNode_Enumerant*, EnumNode_Enumerant_list, int i);
void get_InterfaceNode(struct InterfaceNode*, InterfaceNode_list, int i);
void get_InterfaceNode_Method(struct InterfaceNode_Method*, InterfaceNode_Method_list, int i);
void get_InterfaceNode_Method_Param(struct InterfaceNode_Method_Param*, InterfaceNode_Method_Param_list, int i);
void get_ConstNode(struct ConstNode*, ConstNode_list, int i);
void get_AnnotationNode(struct AnnotationNode*, AnnotationNode_list, int i);
void get_CodeGeneratorRequest(struct CodeGeneratorRequest*, CodeGeneratorRequest_list, int i);
void get_CodeGeneratorRequest_RequestedFile(struct CodeGeneratorRequest_RequestedFile*, CodeGeneratorRequest_RequestedFile_list, int i);
void get_CodeGeneratorRequest_RequestedFile_Import(struct CodeGeneratorRequest_RequestedFile_Import*, CodeGeneratorRequest_RequestedFile_Import_list, int i);
int set_Node(const struct Node*, Node_list, int i);
int set_Node_NestedNode(const struct Node_NestedNode*, Node_NestedNode_list, int i);
int set_Type(const struct Type*, Type_list, int i);
int set_Value(const struct Value*, Value_list, int i);
int set_Annotation(const struct Annotation*, Annotation_list, int i);
int set_FileNode(const struct FileNode*, FileNode_list, int i);
int set_FileNode_Import(const struct FileNode_Import*, FileNode_Import_list, int i);
int set_StructNode(const struct StructNode*, StructNode_list, int i);
int set_StructNode_Member(const struct StructNode_Member*, StructNode_Member_list, int i);
int set_StructNode_Field(const struct StructNode_Field*, StructNode_Field_list, int i);
int set_StructNode_Union(const struct StructNode_Union*, StructNode_Union_list, int i);
int set_EnumNode(const struct EnumNode*, EnumNode_list, int i);
int set_EnumNode_Enumerant(const struct EnumNode_Enumerant*, EnumNode_Enumerant_list, int i);
int set_InterfaceNode(const struct InterfaceNode*, InterfaceNode_list, int i);
int set_InterfaceNode_Method(const struct InterfaceNode_Method*, InterfaceNode_Method_list, int i);
int set_InterfaceNode_Method_Param(const struct InterfaceNode_Method_Param*, InterfaceNode_Method_Param_list, int i);
int set_ConstNode(const struct ConstNode*, ConstNode_list, int i);
int set_AnnotationNode(const struct AnnotationNode*, AnnotationNode_list, int i);
int set_CodeGeneratorRequest(const struct CodeGeneratorRequest*, CodeGeneratorRequest_list, int i);
void set_Node(const struct Node*, Node_list, int i);
void set_Node_NestedNode(const struct Node_NestedNode*, Node_NestedNode_list, int i);
void set_Field(const struct Field*, Field_list, int i);
void set_Enumerant(const struct Enumerant*, Enumerant_list, int i);
void set_Method(const struct Method*, Method_list, int i);
void set_Method_Param(const struct Method_Param*, Method_Param_list, int i);
void set_Type(const struct Type*, Type_list, int i);
void set_Value(const struct Value*, Value_list, int i);
void set_Annotation(const struct Annotation*, Annotation_list, int i);
void set_CodeGeneratorRequest(const struct CodeGeneratorRequest*, CodeGeneratorRequest_list, int i);
void set_CodeGeneratorRequest_RequestedFile(const struct CodeGeneratorRequest_RequestedFile*, CodeGeneratorRequest_RequestedFile_list, int i);
void set_CodeGeneratorRequest_RequestedFile_Import(const struct CodeGeneratorRequest_RequestedFile_Import*, CodeGeneratorRequest_RequestedFile_Import_list, int i);
#ifdef __cplusplus
}

7
compiler/str.h
View file

@ -12,6 +12,13 @@ extern char str_static[];
void str_reserve(struct str *v, int sz);
static void str_init(struct str *v, int sz) {
v->str = str_static;
v->len = v->cap = 0;
if (sz)
str_reserve(v, sz);
}
static void str_release(struct str *v) {
if (v->cap) {
free(v->str);