struct _message *
_pbcP_init_message(struct pbc_env * p, const char *name) {
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();
m->env = p;
_pbcM_sp_insert(p->msgs, name, m);
return m;
}
if (m->id) {
// extend message, delete old id map.
_pbcM_ip_delete(m->id);
}
struct _iter iter = { 0, NULL };
_pbcM_sp_foreach_ud(m->name, _count, &iter);
iter.table = malloc(iter.count * sizeof(struct map_kv));
iter.count = 0;
_pbcM_sp_foreach_ud(m->name, _set_table, &iter);
m->id = _pbcM_ip_new(iter.table , iter.count);
free(iter.table);
return m;
}
static void
set_field_one(struct pbc_env *p, struct _field *f) {
const char * type_name = f->type_name.n;
if (f->type == PTYPE_MESSAGE) {
f->type_name.m = _pbcM_sp_query(p->msgs, type_name);
// printf("MESSAGE: %s %p\n",type_name, f->type_name.m);
} else if (f->type == PTYPE_ENUM) {
f->type_name.e = _pbcM_sp_query(p->enums, type_name);
// printf("ENUM: %s %p ",type_name, f->type_name.e);
const char * str = f->default_v->s.str;
if (str) {
f->default_v->e.id = _pbcM_si_query(f->type_name.e->name, str);
f->default_v->e.name = _pbcM_ip_query(f->type_name.e->id, f->default_v->e.id);
// printf("[%s %d]\n",str,f->default_v->e.id);
} else {
memcpy(f->default_v, f->type_name.e->default_v, sizeof(pbc_var));
// printf("(%s %d)\n",f->default_v->e.name,f->default_v->e.id);
}
}
}
static int
_check_file_name(struct pbc_env * p , struct pbc_rmessage * file, const char ** fname) {
const char * filename = pbc_rmessage_string(file, "name", 0, NULL);
// printf("reg :%s\n",filename);
if (_pbcM_sp_query(p->files, filename)) {
return CHECK_FILE_EXIST;
}
int sz = pbc_rmessage_size(file, "dependency");
int i;
for (i=0;i<sz;i++) {
const char *dname = pbc_rmessage_string(file,"dependency",i,NULL);
// printf("dependency :%s\n",dname);
if (_pbcM_sp_query(p->files, dname) == NULL) {
return CHECK_FILE_DEPENDENCY;
}
}
*fname = filename;
return CHECK_FILE_OK;
}
int
_pbcP_message_default(struct _message * m, const char * name, pbc_var defv) {
struct _field * f= _pbcM_sp_query(m->name, name);
if (f==NULL) {
// invalid key
defv->p[0] = NULL;
defv->p[1] = NULL;
return -1;
}
*defv = *(f->default_v);
return f->type;
}
int
pbc_type(struct pbc_env * p, const char * type_name , const char * key , const char ** type) {
struct _message *m = _pbcP_get_message(p, type_name);
if (m==NULL) {
return 0;
}
if (key == NULL) {
return PBC_NOEXIST;
}
struct _field * field = (struct _field *)_pbcM_sp_query(m->name, key);
return _pbcP_type(field, type);
}
struct pbc_pattern *
pbc_pattern_new(struct pbc_env * env , const char * message, const char * format, ... ) {
struct _message *m = _pbcP_get_message(env, message);
if (m==NULL) {
return NULL;
}
int len = strlen(format);
char temp[len+1];
int n = _scan_pattern(format, temp);
struct pbc_pattern * pat = _pbcP_new(n);
int i;
va_list ap;
va_start(ap , format);
const char *ptr = temp;
for (i=0;i<n;i++) {
struct _pattern_field * f = &(pat->f[i]);
struct _field * field = _pbcM_sp_query(m->name, ptr);
if (field == NULL)
goto _error;
f->id = field->id;
f->ptype = field->type;
*f->defv = *field->default_v;
f->offset = va_arg(ap, int);
ptr += strlen(ptr) + 1;
f->ctype = _ctype(ptr);
if (f->ctype < 0)
goto _error;
if (f->ctype == CTYPE_ARRAY && field->label == LABEL_PACKED) {
f->ctype = CTYPE_PACKED;
}
if (_check_ctype(field, f))
goto _error;
ptr += strlen(ptr) + 1;
}
va_end(ap);
pat->count = n;
qsort(pat->f , n , sizeof(struct _pattern_field), _comp_field);
return pat;
_error:
free(pat);
return NULL;
}
static void
set_field_one(struct pbc_env *p, struct _field *f) {
const char * type_name = f->type_name.n;
if (f->type == PTYPE_MESSAGE) {
f->type_name.m = (struct _message *)_pbcM_sp_query(p->msgs, type_name);
// printf("MESSAGE: %s %p\n",type_name, f->type_name.m);
} else if (f->type == PTYPE_ENUM) {
f->type_name.e = (struct _enum *)_pbcM_sp_query(p->enums, type_name);
// printf("ENUM: %s %p ",type_name, f->type_name.e);
const char * str = f->default_v->s.str;
if (str && str[0]) {
int err = _pbcM_si_query(f->type_name.e->name, str , &(f->default_v->e.id));
if (err < 0)
goto _default;
f->default_v->e.name = (const char *)_pbcM_ip_query(f->type_name.e->id, f->default_v->e.id);
// printf("[%s %d]\n",str,f->default_v->e.id);
} else {
_default:
memcpy(f->default_v, f->type_name.e->default_v, sizeof(pbc_var));
// printf("(%s %d)\n",f->default_v->e.name,f->default_v->e.id);
}
}
}
struct _enum *
_pbcP_push_enum(struct pbc_env * p, const char *name, struct map_kv *table, int sz) {
void * check = _pbcM_sp_query(p->enums, name);
if (check)
return NULL;
struct _enum * v = malloc(sizeof(*v));
v->key = name;
v->id = _pbcM_ip_new(table,sz);
v->name = _pbcM_si_new(table,sz);
v->default_v->e.id = table[0].id;
v->default_v->e.name = table[0].pointer;
_pbcM_sp_insert(p->enums, name , v);
return v;
}
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);
}
}
struct _message *
_pbcP_init_message(struct pbc_env * p, const char *name) {
struct _message * m = _pbcM_sp_query(p->msgs, name);
if (m == NULL) {
return NULL;
}
if (m->id) {
return NULL;
}
struct _iter iter = { 0, NULL };
_pbcM_sp_foreach_ud(m->name, _count, &iter);
iter.table = malloc(iter.count * sizeof(struct map_kv));
iter.count = 0;
_pbcM_sp_foreach_ud(m->name, _set_table, &iter);
m->id = _pbcM_ip_new(iter.table , iter.count);
free(iter.table);
return m;
}
struct _message *
_pbcP_get_message(struct pbc_env * p , const char *name) {
return _pbcM_sp_query(p->msgs, name);
}
