static void
_register(struct pbc_env *p, struct pbc_rmessage * file, struct _stringpool *pool) {
int package_sz;
const char *package = pbc_rmessage_string(file, "package", 0, &package_sz);
pbc_array queue;
_pbcA_open(queue);
int enum_count = pbc_rmessage_size(file, "enum_type");
int i;
for (i=0;i<enum_count;i++) {
struct pbc_rmessage * enum_type = pbc_rmessage_message(file, "enum_type", i);
_register_enum(p, pool , enum_type, package, package_sz);
}
int message_count = pbc_rmessage_size(file, "message_type");
for (i=0;i<message_count;i++) {
struct pbc_rmessage * message_type = pbc_rmessage_message(file, "message_type", i);
_register_message(p, pool, message_type, package, package_sz, queue);
}
_register_extension(p, pool, package, package_sz, file , queue);
_pbcB_register_fields(p, queue);
_pbcA_close(queue);
}
static struct pbc_wmessage *
_wmessage_new(struct _message *msg) {
struct pbc_wmessage * m = malloc(sizeof(*m));
m->type = msg;
m->buffer = malloc(WMESSAGE_SIZE);
m->ptr = m->buffer;
m->endptr = m->buffer + WMESSAGE_SIZE;
_pbcA_open(m->sub);
m->packed = NULL;
return m;
}
static int
register_internal(struct pbc_env * p, void *buffer, int size) {
struct pbc_pattern * FIELD_T = _pbcP_new(8);
F(0,name,string);
F(1,id,int32);
F(2,label,int32);
F(3,type,int32);
F(4,type_name,string);
F(5,default_integer,int32);
F(6,default_string,string);
F(7,default_real,double);
struct pbc_pattern * FILE_T = _pbcP_new(10);
D(0,name,string);
D(1,dependency,string_array);
D(2,message_name,string_array);
D(3,message_size,int32_array);
D(4,message_field,message_array);
D(5,enum_name,string_array);
D(6,enum_size,int32_array);
D(7,enum_string,string_array);
D(8,enum_id,int32_array);
int ret = 0;
struct file_t file;
int r = pbc_pattern_unpack(FILE_T, buffer, size, &file);
if (r != 0) {
ret = 1;
goto _return;
}
_pbcM_sp_insert(p->files , file.name->s.str, NULL);
pbc_array queue;
_pbcA_open(queue);
set_enums(p, &file);
set_msgs(FIELD_T, p, &file, queue);
_pbcB_register_fields(p, queue);
_pbcA_close(queue);
pbc_pattern_close_arrays(FILE_T, &file);
_return:
free(FIELD_T);
free(FILE_T);
return ret;
}
static void
_pbc_rmessage_new(struct pbc_rmessage * ret , struct _message * type , void *buffer, int size) {
pbc_ctx _ctx;
if (_pbcC_open(_ctx,buffer,size) <=0) {
memset(ret , 0, sizeof(*ret));
return;
}
struct context * ctx = (struct context *)_ctx;
ret->msg = type;
ret->index = _pbcM_sp_new();
int i;
for (i=0;i<ctx->number;i++) {
int id = ctx->a[i].id;
struct _field * f = _pbcM_ip_query(type->id , id);
if (f) {
if (f->label == LABEL_REPEATED || f->label == LABEL_PACKED) {
struct value * v;
void ** vv = _pbcM_sp_query_insert(ret->index, f->name);
if (*vv == NULL) {
v = malloc(SIZE_ARRAY);
v->type = f;
_pbcA_open(v->v.array);
*vv = v;
} else {
v= *vv;
}
if (f->label == LABEL_PACKED) {
push_value_packed(v->v.array , f , &(ctx->a[i]), buffer);
} else {
push_value_array(v->v.array , f, &(ctx->a[i]), buffer);
}
} else {
struct value * v = read_value(f, &(ctx->a[i]), buffer);
if (v) {
_pbcM_sp_insert(ret->index, f->name, v);
}
}
}
}
_pbcC_close(_ctx);
}
static void
set_default(struct pbc_pattern *pat, uint8_t * output) {
int i;
for (i=0;i<pat->count;i++) {
if (pat->f[i].ctype == CTYPE_ARRAY || pat->f[i].ctype == CTYPE_PACKED) {
struct _pbc_array *array = (struct _pbc_array *)(output + pat->f[i].offset);
_pbcA_open(array);
continue;
} else if (pat->f[i].ptype == PTYPE_MESSAGE) {
struct _pbc_ctx *ctx = (struct _pbc_ctx *)(output + pat->f[i].offset);
_pbcC_open(ctx , NULL , 0);
continue;
} else if (pat->f[i].ptype == PTYPE_ENUM) {
pbc_var defv;
defv->integer.low = pat->f[i].defv->e.id;
defv->integer.hi = 0;
set_default_v(output + pat->f[i].offset, pat->f[i].ctype, defv);
continue;
}
set_default_v(output + pat->f[i].offset, pat->f[i].ctype, pat->f[i].defv);
}
}
