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

bootstrap complete - use generated schema.capnp.(c|h)

Browse source
This commit is contained in:
James McKaskill 2013-05-08 22:49:14 -04:00
parent 8db142a9a0
commit e1860e2b4b
2 changed files with 448 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

552
compiler/schema.capnp.c
View file

@ -1,101 +1,5 @@
#include "schema.capnp.h"
void get_Node(struct Node *s, Node_list l, int i) {
Node_ptr p = {capn_getp(l.p, i)};
read_Node(s, p);
}
void get_Node_NestedNode(struct Node_NestedNode *s, Node_NestedNode_list l, int i) {
Node_NestedNode_ptr p = {capn_getp(l.p, i)};
read_Node_NestedNode(s, p);
}
void get_Type(struct Type *s, Type_list l, int i) {
Type_ptr p = {capn_getp(l.p, i)};
read_Type(s, p);
}
void get_Value(struct Value *s, Value_list l, int i) {
Value_ptr p = {capn_getp(l.p, i)};
read_Value(s, p);
}
void get_Annotation(struct Annotation *s, Annotation_list l, int i) {
Annotation_ptr p = {capn_getp(l.p, i)};
read_Annotation(s, p);
}
void get_FileNode(struct FileNode *s, FileNode_list l, int i) {
FileNode_ptr p = {capn_getp(l.p, i)};
read_FileNode(s, p);
}
void get_FileNode_Import(struct FileNode_Import *s, FileNode_Import_list l, int i) {
FileNode_Import_ptr p = {capn_getp(l.p, i)};
read_FileNode_Import(s, p);
}
void get_StructNode(struct StructNode *s, StructNode_list l, int i) {
StructNode_ptr p = {capn_getp(l.p, i)};
read_StructNode(s, p);
}
void get_StructNode_Member(struct StructNode_Member *s, StructNode_Member_list l, int i) {
StructNode_Member_ptr p = {capn_getp(l.p, i)};
read_StructNode_Member(s, p);
}
void get_StructNode_Field(struct StructNode_Field *s, StructNode_Field_list l, int i) {
StructNode_Field_ptr p = {capn_getp(l.p, i)};
read_StructNode_Field(s, p);
}
void get_StructNode_Union(struct StructNode_Union *s, StructNode_Union_list l, int i) {
StructNode_Union_ptr p = {capn_getp(l.p, i)};
read_StructNode_Union(s, p);
}
void get_EnumNode(struct EnumNode *s, EnumNode_list l, int i) {
EnumNode_ptr p = {capn_getp(l.p, i)};
read_EnumNode(s, p);
}
void get_EnumNode_Enumerant(struct EnumNode_Enumerant *s, EnumNode_Enumerant_list l, int i) {
EnumNode_Enumerant_ptr p = {capn_getp(l.p, i)};
read_EnumNode_Enumerant(s, p);
}
void get_InterfaceNode(struct InterfaceNode *s, InterfaceNode_list l, int i) {
InterfaceNode_ptr p = {capn_getp(l.p, i)};
read_InterfaceNode(s, p);
}
void get_InterfaceNode_Method(struct InterfaceNode_Method *s, InterfaceNode_Method_list l, int i) {
InterfaceNode_Method_ptr p = {capn_getp(l.p, i)};
read_InterfaceNode_Method(s, p);
}
void get_InterfaceNode_Method_Param(struct InterfaceNode_Method_Param *s, InterfaceNode_Method_Param_list l, int i) {
InterfaceNode_Method_Param_ptr p = {capn_getp(l.p, i)};
read_InterfaceNode_Method_Param(s, p);
}
void get_ConstNode(struct ConstNode *s, ConstNode_list l, int i) {
ConstNode_ptr p = {capn_getp(l.p, i)};
read_ConstNode(s, p);
}
void get_AnnotationNode(struct AnnotationNode *s, AnnotationNode_list l, int i) {
AnnotationNode_ptr p = {capn_getp(l.p, i)};
read_AnnotationNode(s, p);
}
void get_CodeGeneratorRequest(struct CodeGeneratorRequest *s, CodeGeneratorRequest_list l, int i) {
CodeGeneratorRequest_ptr p = {capn_getp(l.p, i)};
read_CodeGeneratorRequest(s, p);
}
/* AUTO GENERATED DO NOT EDIT*/
void read_Node(struct Node *s, Node_ptr p) {
s->id = capn_read64(p.p, 0);
@ -103,89 +7,165 @@ void read_Node(struct Node *s, Node_ptr p) {
s->scopeId = capn_read64(p.p, 8);
s->nestedNodes.p = capn_getp(p.p, 1);
s->annotations.p = capn_getp(p.p, 2);
s->body_tag = capn_read16(p.p, 16);
s->body_tag = (enum Node_body) capn_read16(p.p, 16);
switch (s->body_tag) {
case Node_fileNode:
s->body.fileNode.p = capn_getp(p.p, 3);
break;
case Node_structNode:
s->body.structNode.p = capn_getp(p.p, 3);
break;
case Node_enumNode:
s->body.enumNode.p = capn_getp(p.p, 3);
break;
case Node_interfaceNode:
s->body.interfaceNode.p = capn_getp(p.p, 3);
break;
case Node_constNode:
s->body.constNode.p = capn_getp(p.p, 3);
break;
case Node_annotationNode:
s->body.annotationNode.p = capn_getp(p.p, 3);
break;
default:
}
}
int write_Node(const struct Node *s, Node_ptr p) {
int err = 0;
err = err || capn_write64(p.p, 0, s->id);
err = err || capn_set_text(p.p, 0, s->displayName);
err = err || capn_write64(p.p, 8, s->scopeId);
err = err || capn_setp(p.p, 1, s->nestedNodes.p);
err = err || capn_setp(p.p, 2, s->annotations.p);
err = err || capn_write16(p.p, 16, s->body_tag);
switch (s->body_tag) {
case Node_fileNode:
case Node_structNode:
case Node_enumNode:
case Node_interfaceNode:
case Node_constNode:
case Node_annotationNode:
err = err || capn_setp(p.p, 3, s->body.annotationNode.p);
break;
}
return err;
}
void get_Node(struct Node *s, Node_list l, int i) {
Node_ptr p = {capn_getp(l.p, i)};
read_Node(s, p);
}
int set_Node(const struct Node *s, Node_list l, int i) {
Node_ptr p = {capn_getp(l.p, i)};
return write_Node(s, p);
}
void read_Node_NestedNode(struct Node_NestedNode *s, Node_NestedNode_ptr p) {
s->name = capn_get_text(p.p, 0);
s->id = capn_read64(p.p, 0);
}
int write_Node_NestedNode(const struct Node_NestedNode *s, Node_NestedNode_ptr p) {
int err = 0;
err = err || capn_set_text(p.p, 0, s->name);
err = err || capn_write64(p.p, 0, s->id);
return err;
}
void get_Node_NestedNode(struct Node_NestedNode *s, Node_NestedNode_list l, int i) {
Node_NestedNode_ptr p = {capn_getp(l.p, i)};
read_Node_NestedNode(s, p);
}
int set_Node_NestedNode(const struct Node_NestedNode *s, Node_NestedNode_list l, int i) {
Node_NestedNode_ptr p = {capn_getp(l.p, i)};
return write_Node_NestedNode(s, p);
}
void read_Type(struct Type *s, Type_ptr p) {
s->body_tag = capn_read16(p.p, 0);
s->body_tag = (enum Type_body) capn_read16(p.p, 0);
switch (s->body_tag) {
case Type_listType:
s->body.listType.p = capn_getp(p.p, 0);
case Type_voidType:
case Type_boolType:
case Type_int8Type:
case Type_int16Type:
case Type_int32Type:
case Type_int64Type:
case Type_uint8Type:
case Type_uint16Type:
case Type_uint32Type:
case Type_uint64Type:
case Type_float32Type:
case Type_float64Type:
case Type_textType:
case Type_dataType:
case Type_objectType:
break;
case Type_enumType:
s->body.enumType = capn_read64(p.p, 8);
break;
case Type_structType:
s->body.structType = capn_read64(p.p, 8);
break;
case Type_interfaceType:
s->body.interfaceType = capn_read64(p.p, 8);
break;
default:
case Type_listType:
s->body.listType.p = capn_getp(p.p, 0);
break;
}
}
int write_Type(const struct Type *s, Type_ptr p) {
int err = 0;
err = err || capn_write16(p.p, 0, s->body_tag);
switch (s->body_tag) {
case Type_voidType:
case Type_boolType:
case Type_int8Type:
case Type_int16Type:
case Type_int32Type:
case Type_int64Type:
case Type_uint8Type:
case Type_uint16Type:
case Type_uint32Type:
case Type_uint64Type:
case Type_float32Type:
case Type_float64Type:
case Type_textType:
case Type_dataType:
case Type_objectType:
break;
case Type_enumType:
case Type_structType:
case Type_interfaceType:
err = err || capn_write64(p.p, 8, s->body.interfaceType);
break;
case Type_listType:
err = err || capn_setp(p.p, 0, s->body.listType.p);
break;
}
return err;
}
void get_Type(struct Type *s, Type_list l, int i) {
Type_ptr p = {capn_getp(l.p, i)};
read_Type(s, p);
}
int set_Type(const struct Type *s, Type_list l, int i) {
Type_ptr p = {capn_getp(l.p, i)};
return write_Type(s, p);
}
void read_Value(struct Value *s, Value_ptr p) {
s->body_tag = capn_read16(p.p, 0);
s->body_tag = (enum Value_body) capn_read16(p.p, 0);
switch (s->body_tag) {
case Value_voidValue:
case Value_interfaceValue:
break;
case Value_boolValue:
s->body.boolValue = (capn_read8(p.p, 8) & 1) != 0;
break;
case Value_int8Value:
s->body.int8Value = (int8_t) capn_read8(p.p, 8);
break;
case Value_int16Value:
s->body.int16Value = (int16_t) capn_read16(p.p, 8);
break;
case Value_int32Value:
s->body.int32Value = (int32_t) capn_read32(p.p, 8);
break;
case Value_int64Value:
s->body.int64Value = (int64_t) capn_read64(p.p, 8);
break;
case Value_uint8Value:
s->body.uint8Value = capn_read8(p.p, 8);
break;
case Value_int16Value:
case Value_uint16Value:
s->body.uint16Value = capn_read16(p.p, 8);
case Value_enumValue:
s->body.enumValue = capn_read16(p.p, 8);
break;
case Value_int32Value:
case Value_uint32Value:
s->body.uint32Value = capn_read32(p.p, 8);
break;
case Value_uint64Value:
s->body.uint64Value = capn_read64(p.p, 8);
break;
case Value_float32Value:
s->body.float32Value = capn_read_float(p.p, 8, 0.0f);
break;
case Value_int64Value:
case Value_uint64Value:
case Value_float64Value:
s->body.float64Value = capn_read_double(p.p, 8, 0.0);
break;
@ -196,35 +176,119 @@ void read_Value(struct Value *s, Value_ptr p) {
s->body.dataValue = capn_get_data(p.p, 0);
break;
case Value_listValue:
s->body.listValue = capn_getp(p.p, 0);
break;
case Value_enumValue:
s->body.enumValue = capn_read16(p.p, 8);
break;
case Value_structValue:
s->body.structValue = capn_getp(p.p, 0);
break;
case Value_objectValue:
s->body.objectValue = capn_getp(p.p, 0);
break;
default:
}
}
int write_Value(const struct Value *s, Value_ptr p) {
int err = 0;
err = err || capn_write16(p.p, 0, s->body_tag);
switch (s->body_tag) {
case Value_voidValue:
case Value_interfaceValue:
break;
case Value_boolValue:
err = err || capn_write1(p.p, 64, s->body.boolValue);
break;
case Value_int8Value:
case Value_uint8Value:
err = err || capn_write8(p.p, 8, s->body.uint8Value);
break;
case Value_int16Value:
case Value_uint16Value:
case Value_enumValue:
err = err || capn_write16(p.p, 8, s->body.enumValue);
break;
case Value_int32Value:
case Value_uint32Value:
case Value_float32Value:
err = err || capn_write_float(p.p, 8, s->body.float32Value, 0.0f);
break;
case Value_int64Value:
case Value_uint64Value:
case Value_float64Value:
err = err || capn_write_double(p.p, 4, s->body.float64Value, 0.0);
break;
case Value_textValue:
err = err || capn_set_text(p.p, 0, s->body.textValue);
break;
case Value_dataValue:
err = err || capn_set_data(p.p, 0, s->body.dataValue);
break;
case Value_listValue:
case Value_structValue:
case Value_objectValue:
err = err || capn_setp(p.p, 0, s->body.objectValue);
break;
}
return err;
}
void get_Value(struct Value *s, Value_list l, int i) {
Value_ptr p = {capn_getp(l.p, i)};
read_Value(s, p);
}
int set_Value(const struct Value *s, Value_list l, int i) {
Value_ptr p = {capn_getp(l.p, i)};
return write_Value(s, p);
}
void read_Annotation(struct Annotation *s, Annotation_ptr p) {
s->id = capn_read64(p.p, 0);
s->value.p = capn_getp(p.p, 0);
}
int write_Annotation(const struct Annotation *s, Annotation_ptr p) {
int err = 0;
err = err || capn_write64(p.p, 0, s->id);
err = err || capn_setp(p.p, 0, s->value.p);
return err;
}
void get_Annotation(struct Annotation *s, Annotation_list l, int i) {
Annotation_ptr p = {capn_getp(l.p, i)};
read_Annotation(s, p);
}
int set_Annotation(const struct Annotation *s, Annotation_list l, int i) {
Annotation_ptr p = {capn_getp(l.p, i)};
return write_Annotation(s, p);
}
void read_FileNode(struct FileNode *s, FileNode_ptr p) {
s->imports.p = capn_getp(p.p, 0);
}
int write_FileNode(const struct FileNode *s, FileNode_ptr p) {
int err = 0;
err = err || capn_setp(p.p, 0, s->imports.p);
return err;
}
void get_FileNode(struct FileNode *s, FileNode_list l, int i) {
FileNode_ptr p = {capn_getp(l.p, i)};
read_FileNode(s, p);
}
int set_FileNode(const struct FileNode *s, FileNode_list l, int i) {
FileNode_ptr p = {capn_getp(l.p, i)};
return write_FileNode(s, p);
}
void read_FileNode_Import(struct FileNode_Import *s, FileNode_Import_ptr p) {
s->id = capn_read64(p.p, 0);
s->name = capn_get_text(p.p, 0);
}
int write_FileNode_Import(const struct FileNode_Import *s, FileNode_Import_ptr p) {
int err = 0;
err = err || capn_write64(p.p, 0, s->id);
err = err || capn_set_text(p.p, 0, s->name);
return err;
}
void get_FileNode_Import(struct FileNode_Import *s, FileNode_Import_list l, int i) {
FileNode_Import_ptr p = {capn_getp(l.p, i)};
read_FileNode_Import(s, p);
}
int set_FileNode_Import(const struct FileNode_Import *s, FileNode_Import_list l, int i) {
FileNode_Import_ptr p = {capn_getp(l.p, i)};
return write_FileNode_Import(s, p);
}
void read_StructNode(struct StructNode *s, StructNode_ptr p) {
s->dataSectionWordSize = capn_read16(p.p, 0);
@ -232,6 +296,22 @@ void read_StructNode(struct StructNode *s, StructNode_ptr p) {
s->preferredListEncoding = (enum ElementSize) capn_read16(p.p, 4);
s->members.p = capn_getp(p.p, 0);
}
int write_StructNode(const struct StructNode *s, StructNode_ptr p) {
int err = 0;
err = err || capn_write16(p.p, 0, s->dataSectionWordSize);
err = err || capn_write16(p.p, 2, s->pointerSectionSize);
err = err || capn_write16(p.p, 4, (uint16_t) s->preferredListEncoding);
err = err || capn_setp(p.p, 0, s->members.p);
return err;
}
void get_StructNode(struct StructNode *s, StructNode_list l, int i) {
StructNode_ptr p = {capn_getp(l.p, i)};
read_StructNode(s, p);
}
int set_StructNode(const struct StructNode *s, StructNode_list l, int i) {
StructNode_ptr p = {capn_getp(l.p, i)};
return write_StructNode(s, p);
}
void read_StructNode_Member(struct StructNode_Member *s, StructNode_Member_ptr p) {
s->name = capn_get_text(p.p, 0);
@ -239,16 +319,37 @@ void read_StructNode_Member(struct StructNode_Member *s, StructNode_Member_ptr p
s->codeOrder = capn_read16(p.p, 2);
s->annotations.p = capn_getp(p.p, 1);
s->body_tag = (enum StructNode_Member_body) capn_read16(p.p, 4);
switch (s->body_tag) {
case StructNode_Member_fieldMember:
s->body.fieldMember.p = capn_getp(p.p, 2);
break;
case StructNode_Member_unionMember:
s->body.unionMember.p = capn_getp(p.p, 2);
break;
default:
}
}
int write_StructNode_Member(const struct StructNode_Member *s, StructNode_Member_ptr p) {
int err = 0;
err = err || capn_set_text(p.p, 0, s->name);
err = err || capn_write16(p.p, 0, s->ordinal);
err = err || capn_write16(p.p, 2, s->codeOrder);
err = err || capn_setp(p.p, 1, s->annotations.p);
err = err || capn_write16(p.p, 4, s->body_tag);
switch (s->body_tag) {
case StructNode_Member_fieldMember:
case StructNode_Member_unionMember:
err = err || capn_setp(p.p, 2, s->body.unionMember.p);
break;
}
return err;
}
void get_StructNode_Member(struct StructNode_Member *s, StructNode_Member_list l, int i) {
StructNode_Member_ptr p = {capn_getp(l.p, i)};
read_StructNode_Member(s, p);
}
int set_StructNode_Member(const struct StructNode_Member *s, StructNode_Member_list l, int i) {
StructNode_Member_ptr p = {capn_getp(l.p, i)};
return write_StructNode_Member(s, p);
}
void read_StructNode_Field(struct StructNode_Field *s, StructNode_Field_ptr p) {
@ -256,25 +357,95 @@ void read_StructNode_Field(struct StructNode_Field *s, StructNode_Field_ptr p) {
s->type.p = capn_getp(p.p, 0);
s->defaultValue.p = capn_getp(p.p, 1);
}
int write_StructNode_Field(const struct StructNode_Field *s, StructNode_Field_ptr p) {
int err = 0;
err = err || capn_write32(p.p, 0, s->offset);
err = err || capn_setp(p.p, 0, s->type.p);
err = err || capn_setp(p.p, 1, s->defaultValue.p);
return err;
}
void get_StructNode_Field(struct StructNode_Field *s, StructNode_Field_list l, int i) {
StructNode_Field_ptr p = {capn_getp(l.p, i)};
read_StructNode_Field(s, p);
}
int set_StructNode_Field(const struct StructNode_Field *s, StructNode_Field_list l, int i) {
StructNode_Field_ptr p = {capn_getp(l.p, i)};
return write_StructNode_Field(s, p);
}
void read_StructNode_Union(struct StructNode_Union *s, StructNode_Union_ptr p) {
s->discriminantOffset = capn_read32(p.p, 0);
s->members.p = capn_getp(p.p, 0);
}
int write_StructNode_Union(const struct StructNode_Union *s, StructNode_Union_ptr p) {
int err = 0;
err = err || capn_write32(p.p, 0, s->discriminantOffset);
err = err || capn_setp(p.p, 0, s->members.p);
return err;
}
void get_StructNode_Union(struct StructNode_Union *s, StructNode_Union_list l, int i) {
StructNode_Union_ptr p = {capn_getp(l.p, i)};
read_StructNode_Union(s, p);
}
int set_StructNode_Union(const struct StructNode_Union *s, StructNode_Union_list l, int i) {
StructNode_Union_ptr p = {capn_getp(l.p, i)};
return write_StructNode_Union(s, p);
}
void read_EnumNode(struct EnumNode *s, EnumNode_ptr p) {
s->enumerants.p = capn_getp(p.p, 0);
}
int write_EnumNode(const struct EnumNode *s, EnumNode_ptr p) {
int err = 0;
err = err || capn_setp(p.p, 0, s->enumerants.p);
return err;
}
void get_EnumNode(struct EnumNode *s, EnumNode_list l, int i) {
EnumNode_ptr p = {capn_getp(l.p, i)};
read_EnumNode(s, p);
}
int set_EnumNode(const struct EnumNode *s, EnumNode_list l, int i) {
EnumNode_ptr p = {capn_getp(l.p, i)};
return write_EnumNode(s, p);
}
void read_EnumNode_Enumerant(struct EnumNode_Enumerant *s, EnumNode_Enumerant_ptr p) {
s->name = capn_get_text(p.p, 0);
s->codeOrder = capn_read16(p.p, 0);
s->annotations.p = capn_getp(p.p, 1);
}
int write_EnumNode_Enumerant(const struct EnumNode_Enumerant *s, EnumNode_Enumerant_ptr p) {
int err = 0;
err = err || capn_set_text(p.p, 0, s->name);
err = err || capn_write16(p.p, 0, s->codeOrder);
err = err || capn_setp(p.p, 1, s->annotations.p);
return err;
}
void get_EnumNode_Enumerant(struct EnumNode_Enumerant *s, EnumNode_Enumerant_list l, int i) {
EnumNode_Enumerant_ptr p = {capn_getp(l.p, i)};
read_EnumNode_Enumerant(s, p);
}
int set_EnumNode_Enumerant(const struct EnumNode_Enumerant *s, EnumNode_Enumerant_list l, int i) {
EnumNode_Enumerant_ptr p = {capn_getp(l.p, i)};
return write_EnumNode_Enumerant(s, p);
}
void read_InterfaceNode(struct InterfaceNode *s, InterfaceNode_ptr p) {
s->methods.p = capn_getp(p.p, 0);
}
int write_InterfaceNode(const struct InterfaceNode *s, InterfaceNode_ptr p) {
int err = 0;
err = err || capn_setp(p.p, 0, s->methods.p);
return err;
}
void get_InterfaceNode(struct InterfaceNode *s, InterfaceNode_list l, int i) {
InterfaceNode_ptr p = {capn_getp(l.p, i)};
read_InterfaceNode(s, p);
}
int set_InterfaceNode(const struct InterfaceNode *s, InterfaceNode_list l, int i) {
InterfaceNode_ptr p = {capn_getp(l.p, i)};
return write_InterfaceNode(s, p);
}
void read_InterfaceNode_Method(struct InterfaceNode_Method *s, InterfaceNode_Method_ptr p) {
s->name = capn_get_text(p.p, 0);
@ -284,6 +455,24 @@ void read_InterfaceNode_Method(struct InterfaceNode_Method *s, InterfaceNode_Met
s->returnType.p = capn_getp(p.p, 2);
s->annotations.p = capn_getp(p.p, 3);
}
int write_InterfaceNode_Method(const struct InterfaceNode_Method *s, InterfaceNode_Method_ptr p) {
int err = 0;
err = err || capn_set_text(p.p, 0, s->name);
err = err || capn_write16(p.p, 0, s->codeOrder);
err = err || capn_setp(p.p, 1, s->params.p);
err = err || capn_write16(p.p, 2, s->requiredParamCount);
err = err || capn_setp(p.p, 2, s->returnType.p);
err = err || capn_setp(p.p, 3, s->annotations.p);
return err;
}
void get_InterfaceNode_Method(struct InterfaceNode_Method *s, InterfaceNode_Method_list l, int i) {
InterfaceNode_Method_ptr p = {capn_getp(l.p, i)};
read_InterfaceNode_Method(s, p);
}
int set_InterfaceNode_Method(const struct InterfaceNode_Method *s, InterfaceNode_Method_list l, int i) {
InterfaceNode_Method_ptr p = {capn_getp(l.p, i)};
return write_InterfaceNode_Method(s, p);
}
void read_InterfaceNode_Method_Param(struct InterfaceNode_Method_Param *s, InterfaceNode_Method_Param_ptr p) {
s->name = capn_get_text(p.p, 0);
@ -291,16 +480,46 @@ void read_InterfaceNode_Method_Param(struct InterfaceNode_Method_Param *s, Inter
s->defaultValue.p = capn_getp(p.p, 2);
s->annotations.p = capn_getp(p.p, 3);
}
int write_InterfaceNode_Method_Param(const struct InterfaceNode_Method_Param *s, InterfaceNode_Method_Param_ptr p) {
int err = 0;
err = err || capn_set_text(p.p, 0, s->name);
err = err || capn_setp(p.p, 1, s->type.p);
err = err || capn_setp(p.p, 2, s->defaultValue.p);
err = err || capn_setp(p.p, 3, s->annotations.p);
return err;
}
void get_InterfaceNode_Method_Param(struct InterfaceNode_Method_Param *s, InterfaceNode_Method_Param_list l, int i) {
InterfaceNode_Method_Param_ptr p = {capn_getp(l.p, i)};
read_InterfaceNode_Method_Param(s, p);
}
int set_InterfaceNode_Method_Param(const struct InterfaceNode_Method_Param *s, InterfaceNode_Method_Param_list l, int i) {
InterfaceNode_Method_Param_ptr p = {capn_getp(l.p, i)};
return write_InterfaceNode_Method_Param(s, p);
}
void read_ConstNode(struct ConstNode *s, ConstNode_ptr p) {
s->type.p = capn_getp(p.p, 0);
s->value.p = capn_getp(p.p, 1);
}
int write_ConstNode(const struct ConstNode *s, ConstNode_ptr p) {
int err = 0;
err = err || capn_setp(p.p, 0, s->type.p);
err = err || capn_setp(p.p, 1, s->value.p);
return err;
}
void get_ConstNode(struct ConstNode *s, ConstNode_list l, int i) {
ConstNode_ptr p = {capn_getp(l.p, i)};
read_ConstNode(s, p);
}
int set_ConstNode(const struct ConstNode *s, ConstNode_list l, int i) {
ConstNode_ptr p = {capn_getp(l.p, i)};
return write_ConstNode(s, p);
}
void read_AnnotationNode(struct AnnotationNode *s, AnnotationNode_ptr p) {
s->type.p = capn_getp(p.p, 0);
s->targetsFile = (capn_read8(p.p, 0) & 1) != 0;
s->targetsConst = (capn_read8(p.p, 0) & 3) != 0;
s->targetsConst = (capn_read8(p.p, 0) & 2) != 0;
s->targetsEnum = (capn_read8(p.p, 0) & 4) != 0;
s->targetsEnumerant = (capn_read8(p.p, 0) & 8) != 0;
s->targetsStruct = (capn_read8(p.p, 0) & 16) != 0;
@ -311,9 +530,46 @@ void read_AnnotationNode(struct AnnotationNode *s, AnnotationNode_ptr p) {
s->targetsParam = (capn_read8(p.p, 1) & 2) != 0;
s->targetsAnnotation = (capn_read8(p.p, 1) & 4) != 0;
}
int write_AnnotationNode(const struct AnnotationNode *s, AnnotationNode_ptr p) {
int err = 0;
err = err || capn_setp(p.p, 0, s->type.p);
err = err || capn_write1(p.p, 0, s->targetsFile);
err = err || capn_write1(p.p, 1, s->targetsConst);
err = err || capn_write1(p.p, 2, s->targetsEnum);
err = err || capn_write1(p.p, 3, s->targetsEnumerant);
err = err || capn_write1(p.p, 4, s->targetsStruct);
err = err || capn_write1(p.p, 5, s->targetsField);
err = err || capn_write1(p.p, 6, s->targetsUnion);
err = err || capn_write1(p.p, 7, s->targetsInterface);
err = err || capn_write1(p.p, 8, s->targetsMethod);
err = err || capn_write1(p.p, 9, s->targetsParam);
err = err || capn_write1(p.p, 10, s->targetsAnnotation);
return err;
}
void get_AnnotationNode(struct AnnotationNode *s, AnnotationNode_list l, int i) {
AnnotationNode_ptr p = {capn_getp(l.p, i)};
read_AnnotationNode(s, p);
}
int set_AnnotationNode(const struct AnnotationNode *s, AnnotationNode_list l, int i) {
AnnotationNode_ptr p = {capn_getp(l.p, i)};
return write_AnnotationNode(s, p);
}
void read_CodeGeneratorRequest(struct CodeGeneratorRequest *s, CodeGeneratorRequest_ptr p) {
s->nodes.p = capn_getp(p.p, 0);
s->requestedFiles.p = capn_getp(p.p, 1);
}
int write_CodeGeneratorRequest(const struct CodeGeneratorRequest *s, CodeGeneratorRequest_ptr p) {
int err = 0;
err = err || capn_setp(p.p, 0, s->nodes.p);
err = err || capn_setp(p.p, 1, s->requestedFiles.p);
return err;
}
void get_CodeGeneratorRequest(struct CodeGeneratorRequest *s, CodeGeneratorRequest_list l, int i) {
CodeGeneratorRequest_ptr p = {capn_getp(l.p, i)};
read_CodeGeneratorRequest(s, p);
}
int set_CodeGeneratorRequest(const struct CodeGeneratorRequest *s, CodeGeneratorRequest_list l, int i) {
CodeGeneratorRequest_ptr p = {capn_getp(l.p, i)};
return write_CodeGeneratorRequest(s, p);
}

46
compiler/schema.capnp.h
View file

@ -1,4 +1,6 @@
/* vim: set sw=8 ts=8 sts=8 noet: */
#ifndef CAPN_b471df2f45ca32c7
#define CAPN_b471df2f45ca32c7
/* AUTO GENERATED DO NOT EDIT*/
#include <capn.h>
#ifdef __cplusplus
@ -85,6 +87,26 @@ void read_ConstNode(struct ConstNode*, ConstNode_ptr);
void read_AnnotationNode(struct AnnotationNode*, AnnotationNode_ptr);
void read_CodeGeneratorRequest(struct CodeGeneratorRequest*, CodeGeneratorRequest_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 get_Node(struct Node*, Node_list, int i);
void get_Node_NestedNode(struct Node_NestedNode*, Node_NestedNode_list, int i);
void get_Type(struct Type*, Type_list, int i);
@ -105,6 +127,26 @@ 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);
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);
enum Node_body {
Node_fileNode = 0,
Node_structNode = 1,
@ -331,4 +373,4 @@ struct CodeGeneratorRequest {
#ifdef __cplusplus
}
#endif
#endif