{

deprecated |= attributes->deprecated;

hidden |= attributes->hidden;

{

if (v == nullptr)

yyerror("Enum is null!");

if (v->name->empty())

yyerror("Enum name is invalid!");

// Check for duplicates

auto it = std::find_if(values.begin(), values.end(), [v](auto item)->bool { return *item->name.get() == *v->name.get(); });

if (it != values.end())

yyerror("Duplicate enum name " + *v->name.get());

values.push_back(std::shared_ptr<EnumValue>(v));

{

if (v == nullptr)

yyerror("Flags is null!");

if (v->name->empty())

yyerror("Flags name is invalid!");

if (!v->value || (!v->value->constant && !v->value->reference))

yyerror("Flags value is invalid!");

// Check for duplicates

auto it = std::find_if(values.begin(), values.end(), [v](auto item)->bool { return *item->name.get() == *v->name.get(); });

if (it != values.end())

yyerror("Duplicate flags name " + *v->name.get());

values.push_back(std::shared_ptr<FlagsValue>(v));

{

if (size <= 0)

yyerror("Array size should be greater than zero!");

N = size;

{

if (f == nullptr)

yyerror("Struct field is null!");

if (f->name->empty())

yyerror("Struct field name is invalid!");

if (f->type->empty())

yyerror("Struct field type is invalid!");

// Check for duplicates

auto it = std::find_if(fields.begin(), fields.end(), [f](auto item)->bool { return *item->name.get() == *f->name.get(); });

if (it != fields.end())

yyerror("Duplicate struct field name " + *f->name.get());

fields.push_back(std::shared_ptr<StructField>(f));

{

if (r == nullptr)

yyerror("Reject is null!");

if (r->empty())

yyerror("Reject is invalid!");

// Check for duplicates

auto it = std::find_if(rejects.begin(), rejects.end(), [r](auto item)->bool { return *item.reject.get() == *r; });

if (it != rejects.end())

yyerror("Duplicate reject " + *r);

rejects.push_back({ std::shared_ptr<std::string>(r), g });

{

if (type < 0)

yyerror("Struct type should not be negative!");

if (!fixed)

{

if (type == 0)

type = ++stype;

else

stype = type;

}

{

if (st == nullptr)

yyerror("Statement is null!");

if (st->e)

AddEnum(st->e);

if (st->f)

AddFlags(st->f);

if (st->s)

AddStruct(st->s);

delete st;

{

if (e == nullptr)

yyerror("Enum is null!");

if (e->name->empty())

yyerror("Enum name is invalid!");

if (!e->body)

yyerror("Enum is empty - " + *e->name.get());

// Check for duplicates

auto it = std::find_if(enums.begin(), enums.end(), [&e](auto item)->bool { return *item->name.get() == *e->name.get(); });

if (it != enums.end())

yyerror("Duplicate enum name " + *e->name.get());

enums.push_back(e);

{

if (f == nullptr)

yyerror("Flags is null!");

if (f->name->empty())

yyerror("Flags name is invalid!");

if (!f->body)

yyerror("Flags is empty - " + *f->name.get());

// Check for duplicates

auto it = std::find_if(flags.begin(), flags.end(), [&f](auto item)->bool { return *item->name.get() == *f->name.get(); });

if (it != flags.end())

yyerror("Duplicate flags name " + *f->name.get());

flags.push_back(f);

{

if (s == nullptr)

yyerror("Struct is null!");

if (s->name->empty())

yyerror("Struct name is invalid!");

if (!s->body)

yyerror("Struct is empty - " + *s->name.get());

// Check for duplicates

auto it = std::find_if(structs.begin(), structs.end(), [&s](auto item)->bool { return *item->name.get() == *s->name.get(); });

if (it != structs.end())

yyerror("Duplicate struct name " + *s->name.get());

it = std::find_if(structs.begin(), structs.end(), [&s](auto item)->bool { return (item->type == s->type) && item->fixed && s->fixed; });

if (it != structs.end())

yyerror("Duplicate struct type " + std::to_string(s->type));

structs.push_back(s);

{

if (i == nullptr)

yyerror("Import is null!");

if (i->empty())

yyerror("Import package is invalid!");

// Check for duplicates

auto it = std::find_if(imports.begin(), imports.end(), [i](auto item)->bool { return *item.get() == *i; });

if (it != imports.end())

yyerror("Duplicate import package " + *i);

imports.push_back(std::shared_ptr<std::string>(i));

{

auto pos = v.find('.');

if (pos == v.npos)

minor = std::atoi(v.c_str());

else

{

major = std::atoi(v.substr(0, pos).c_str());

minor = std::atoi(v.substr(pos + 1).c_str());

}

{

if (offset < 0)

yyerror("Package offset should not be negative!");

{

if (body)

{

for (const auto& child_s : body->structs)

{

// Add offset to all structs in the package

if (!child_s->fixed)

child_s->type += offset;

// Find structs with id & key flags

if (child_s->body)

{

std::vector<std::shared_ptr<StructField>> fields;

for (const auto& field : child_s->body->fields)

{

if (field->id)

{

if (child_s->id)

yyerror("Struct " + *child_s->name.get() + " must have only one [id] field!");

child_s->id = true;

field->keys = true;

}

if (field->keys)

child_s->keys = true;

if (field->reseter)

field->optional = true;

fields.push_back(field);

if (field->reseter)

{

auto reseter = std::make_shared<StructField>();

reseter->name = std::make_shared<std::string>(*field->name + "Reset");

reseter->type = std::make_shared<std::string>("bool");

fields.push_back(reseter);

}

}

child_s->body->fields = fields;

}

}

}