void
pbc_array_push_integer(pbc_array array, uint32_t low, uint32_t hi) {
pbc_var var;
var->integer.low = low;
var->integer.hi = hi;
_pbcA_push(array,var);
}
static void
push_value_array(pbc_array array, struct _field *f, struct atom * a, uint8_t *buffer) {
pbc_var v;
switch (f->type) {
case PTYPE_DOUBLE:
v->real = read_double(a);
break;
case PTYPE_FLOAT:
v->real = (double) read_float(a);
break;
case PTYPE_ENUM:
v->e.id = a->v.i.low;
v->e.name = _pbcM_ip_query(f->type_name.e->id , a->v.i.low);
break;
case PTYPE_INT64:
case PTYPE_UINT64:
case PTYPE_INT32:
case PTYPE_UINT32:
case PTYPE_FIXED32:
case PTYPE_FIXED64:
case PTYPE_SFIXED32:
case PTYPE_SFIXED64:
case PTYPE_BOOL:
v->integer = a->v.i;
break;
case PTYPE_SINT32:
v->integer = a->v.i;
varint_dezigzag32(&(v->integer));
break;
case PTYPE_SINT64:
v->integer = a->v.i;
varint_dezigzag64(&(v->integer));
break;
case PTYPE_STRING:
read_string_var(v,a,f,buffer);
break;
case PTYPE_BYTES:
v->s.str = (const char *)(buffer + a->v.s.start);
v->s.len = a->v.s.end - a->v.s.start;
break;
case PTYPE_MESSAGE: {
struct pbc_rmessage message;
_pbc_rmessage_new(&message, f->type_name.m ,
buffer + a->v.s.start ,
a->v.s.end - a->v.s.start);
if (message.msg == NULL)
return;
v->p[0] = message.msg;
v->p[1] = message.index;
break;
}
default:
return;
}
_pbcA_push(array,v);
}
static int
unpack_array(int ptype, char *buffer, struct atom * a, pbc_array _array) {
pbc_var var;
int r = unpack_field(CTYPE_VAR, ptype, buffer, a , var);
if (r !=0 )
return r;
_pbcA_push(_array , var);
return 0;
}
void
_pbcP_push_message(struct pbc_env * p, const char *name, struct _field *f , pbc_array queue) {
struct _message * m = _pbcM_sp_query(p->msgs, name);
if (m==NULL) {
m = malloc(sizeof(*m));
m->def = NULL;
m->key = name;
m->id = NULL;
m->name = _pbcM_sp_new();
_pbcM_sp_insert(p->msgs, name, m);
}
struct _field * field = malloc(sizeof(*field));
memcpy(field,f,sizeof(*f));
_pbcM_sp_insert(m->name, field->name, field);
pbc_var atom;
atom->m.buffer = field;
if (f->type == PTYPE_MESSAGE || f->type == PTYPE_ENUM) {
_pbcA_push(queue, atom);
}
}
void
pbc_array_push_real(pbc_array array, double v) {
pbc_var var;
var->real = v;
_pbcA_push(array,var);
}
void
pbc_array_push_slice(pbc_array array, struct pbc_slice *s) {
pbc_var var;
var->m = *s;
_pbcA_push(array,var);
}
