Types and fields

integer fields: an integer constant expression (literals with optional unit suffixes, arithmetic operators, enum value constants) or a character literal c"x"; any other kind is an error (invalid default value on integer field). The value must fit the field type’s range; a negative value on an unsigned field is an error (invalid default value on unsigned integer field);

double fields: a floating-point or integer literal. A string default on a double field is an error (string default value on double field);

bool fields: true or false (an integer expression is also accepted; any other kind is invalid default value on bool field);

string and bytes fields: a string literal; any other kind is an error (invalid default value on string field);

enum fields: the constant name of one of the enum’s values, written with the enum’s prefix: the enum type name converted to UPPER_SNAKE_CASE (or the @prefix override), an underscore, and the value name:

enum MyEnum {
    VAL_1 = 1,
    VAL_2 = 2,
};

struct Foo {
    MyEnum foo = MY_ENUM_VAL_1;
};

struct, union, class fields: cannot have default values;

void fields: cannot have default values (default values are forbidden for void types).

Valid tags range from 1 to 32767 (0x7FFF) inclusive. Out-of-range explicit tags are errors (tag is too small (must be >= 1), tag is too large (must be < 0x8000)).

Tags are assigned implicitly by a counter starting at 1: the first field gets tag 1, the next tag 2, and so on.

An explicit tag may be given as an integer prefix N:; it sets the field’s tag to N and resets the counter so that the next untagged field gets N+1.

the type must be a struct or union — scalars, enums and classes cannot be referenced (references can only be applied to structures or unions); classes need no &, they are always held by reference;

only mandatory fields can be references: & combines with neither ? nor [] nor a default value (references can only be applied to required fields, only mandatory fields can be references). The forms Type&? and Type?& are syntax errors;

static class fields cannot be references (referenced static members are forbidden).

anything can be typedef’d: primitive types, enums, structs, unions, classes, and other typedefs (chains are allowed and attributes accumulate along the chain);

the typedef name follows type-name rules (uppercase first letter, no underscore);

using a typedef applies its kind, target type and attributes to the use site. Constraint attributes from the typedef chain and from the use site accumulate;

cardinality merge: if both the typedef and the use site specify a non-mandatory cardinality and they differ, the use is an error (cannot declare repeated optional fields) — e.g. an optional typedef used as a repeated field, or an array typedef used with ?. Otherwise the typedef’s cardinality applies;

typedef cycles are errors (recursive typedef for type 'X' in pkg 'Y');

attributes attached to a typedef must be applicable to the resolved type and cardinality (e.g. @minOccurs on a non-repeated typedef is attribute minOccurs does not apply to required typedefs; @pattern on an integer typedef is attribute pattern does not apply to integer);

a class may inherit from a typedef that resolves to a class.