ast_err
Msgtest_read(ast_runtime* rt, Msgtest** msgtest_vp)
{
ast_err status = AST_NOERR;
uint32_t wiretype, fieldno;
Msgtest* msgtest_v;
msgtest_v = (Msgtest*)ast_alloc(rt,sizeof(Msgtest));
if(msgtest_v == NULL) return AST_ENOMEM;
while(status == AST_NOERR) {
status = ast_read_tag(rt,&wiretype,&fieldno);
if(status == AST_EOF) {status = AST_NOERR; break;}
if(status != AST_NOERR) break;
switch (fieldno) {
case 1: {
size_t size;
if(wiretype != ast_counted) {status=AST_EFAIL; goto done;}
status = ast_read_size(rt,&size);
if(status != AST_NOERR) {ACATCH(status); goto done;}
ast_mark(rt,size);
status = Submsg_read(rt,&msgtest_v->rmsg);
if(status != AST_NOERR) {ACATCH(status); goto done;}
ast_unmark(rt);
} break;
case 2: {
size_t size;
if(wiretype != ast_counted) {status=AST_EFAIL; goto done;}
status = ast_read_size(rt,&size);
if(status != AST_NOERR) {ACATCH(status); goto done;}
ast_mark(rt,size);
msgtest_v->omsg.defined = 1;
msgtest_v->omsg.value = NULL;
status = Submsg_read(rt,&msgtest_v->omsg.value);
if(status != AST_NOERR) {ACATCH(status); goto done;}
ast_unmark(rt);
} break;
case 3: {
size_t size;
Submsg* tmp;
if(wiretype != ast_counted) {status=AST_EFAIL; goto done;}
status = ast_read_size(rt,&size);
if(status != AST_NOERR) {ACATCH(status); goto done;}
ast_mark(rt,size);
status = Submsg_read(rt,&tmp);
if(status != AST_NOERR) {ACATCH(status); goto done;}
status = ast_repeat_append(rt,ast_message,&msgtest_v->pmsg,&tmp);
if(status != AST_NOERR) {ACATCH(status); goto done;}
ast_unmark(rt);
} break;
default:
status = ast_skip_field(rt,wiretype,fieldno);
if(status != AST_NOERR) {ACATCH(status); goto done;}
}; /*switch*/
};/*while*/
if(status != AST_NOERR) {ACATCH(status); goto done;}
if(msgtest_vp) *msgtest_vp = msgtest_v;
done:
return status;
} /*Msgtest_read*/
ast_err
Submsg_read(ast_runtime* rt, Submsg** submsg_vp)
{
ast_err status = AST_NOERR;
uint32_t wiretype, fieldno;
Submsg* submsg_v;
submsg_v = (Submsg*)ast_alloc(rt,sizeof(Submsg));
if(submsg_v == NULL) return AST_ENOMEM;
while(status == AST_NOERR) {
status = ast_read_tag(rt,&wiretype,&fieldno);
if(status == AST_EOF) {status = AST_NOERR; break;}
if(status != AST_NOERR) break;
switch (fieldno) {
case 1: {
status = ast_read_primitive(rt,ast_int32,1,&submsg_v->f_int32);
} break;
default:
status = ast_skip_field(rt,wiretype,fieldno);
if(status != AST_NOERR) {ACATCH(status); goto done;}
}; /*switch*/
};/*while*/
if(status != AST_NOERR) {ACATCH(status); goto done;}
if(submsg_vp) *submsg_vp = submsg_v;
done:
return status;
} /*Submsg_read*/
ast_err
BytesRequired_read(ast_runtime* rt, BytesRequired** bytesrequired_vp)
{
ast_err status = AST_NOERR;
uint32_t wiretype, fieldno;
BytesRequired* bytesrequired_v;
bytesrequired_v = (BytesRequired*)ast_alloc(rt,sizeof(BytesRequired));
if(bytesrequired_v == NULL) return AST_ENOMEM;
while(status == AST_NOERR) {
status = ast_read_tag(rt,&wiretype,&fieldno);
if(status == AST_EOF) {status = AST_NOERR; break;}
if(status != AST_NOERR) break;
switch (fieldno) {
case 1: {
status = ast_read_primitive(rt,ast_string,1,&bytesrequired_v->f_string);
} break;
case 2: {
status = ast_read_primitive(rt,ast_bytes,2,&bytesrequired_v->f_bytes);
} break;
default:
status = ast_skip_field(rt,wiretype,fieldno);
if(status != AST_NOERR) {goto done;}
}; /*switch*/
};/*while*/
if(status != AST_NOERR) {goto done;}
if(bytesrequired_vp) *bytesrequired_vp = bytesrequired_v;
done:
return status;
} /*BytesRequired_read*/
static Enumtest*
create_enumtest(ast_runtime* rt)
{
Enumtest* input = (Enumtest*)ast_alloc(rt,sizeof(Enumtest));
input->renum = ECON1;
input->oenum.defined = 1;
input->oenum.value = ECON2;
input->penum.count = 2;
input->penum.values = (Testenum*)ast_alloc(rt,input->penum.count*sizeof(Testenum));
input->penum.values[0] = ECON3;
input->penum.values[1] = ECON4;
input->ppenum.count = 4;
input->ppenum.values = (Testenum*)ast_alloc(rt,input->ppenum.count*sizeof(Testenum));
input->ppenum.values[0] = ECON3;
input->ppenum.values[1] = ECON4;
input->ppenum.values[1] = ECON5;
input->ppenum.values[1] = ECON6;
#ifdef IGNORE
#endif
return input;
}
NODE *ast_create(NODE_TYPE type, ...)
{
static struct constructor constructor[] =
{
{ast_array_size, ast_array_init},
{ast_binary_size, ast_binary_init},
{ast_block_size, ast_block_init},
{ast_call_size, ast_call_init},
{ast_conditional_size, ast_conditional_init},
{ast_constant_size, ast_constant_init},
{ast_declare_size, ast_declare_init},
{ast_for_size, ast_for_init},
{ast_formal_size, ast_formal_init},
{ast_function_size, ast_function_init},
{ast_group_size, ast_group_init},
{ast_identifier_size, ast_identifier_init},
{ast_list_size, ast_list_init},
{ast_postfix_size, ast_postfix_init},
{ast_prefix_size, ast_prefix_init},
{ast_read_size, ast_read_init},
{ast_return_size, ast_return_init},
{ast_string_literal_size, ast_string_literal_init},
{ast_while_size, ast_while_init},
{ast_write_size, ast_write_init}
};
va_list args;
NODE *result = ast_alloc(type);
size_t size = constructor[type].size();
result->slots = my_malloc(size);
SET_METHOD(result, generate_lval_ir, ast_default_generate_lval_ir);
SET_METHOD(result, generate_param_ir, ast_default_generate_param_ir);
SET_METHOD(result, find_literals, ast_default_find_literals);
SET_METHOD(result, get_symbol, ast_default_get_symbol);
SET_METHOD(result, add_symbols, ast_default_add_symbols);
SET_METHOD(result, check_functions, ast_default_check_functions);
SET_METHOD(result, ir_type, ast_default_ir_type);
SET_METHOD(result, ir_value, ast_default_ir_value);
SET_METHOD(result, is_lvalue, ast_default_is_lvalue);
va_start(args, type);
constructor[type].init(result, args);
va_end(args);
return result;
}
int
t_read(ast_runtime* rt, t** t_vp)
{
int status = AST_NOERR;
uint32_t wiretype, fieldno;
int i = 0;
size_t count;
t* t_v;
t_v = (t*)ast_alloc(sizeof(t));
if(t_v == NULL) return AST_ENOMEM;
while(status == AST_NOERR)
ast_read_tag(rt,&wiretype,&fieldno)
switch (fieldno) {
case 1: {
status = ast_read(rt,ast_int32,&t_v->f1_f);
} break;
case 2: {
t_v->f2_f.exists = 1;
t_v->f2_f.value = 0;
status = ast_read(rt,ast_float,&t_v->f2_f.value);
} break;
case 3: {
t_v->f3_f.count = 0;
t_v->f3_f.values = NULL;
status = ast_read_count(rt,&t_v->f3_f.count);
if(!status) {goto done;}
for(i=0;i<t_v->f3_f.count;i++) {
int tmp;
status = ast_read(rt,ast_sint32,&tmp);
status = ast_append(rt,ast_sint32,&t_v->f3_f,&tmp);
if(!status) {goto done;}
} /*for*/;
} break;
case 4: {
status = m2_read(rt,&t_v->f4_f);
if(!status) {goto done;}
} break;
default:
status = ast_skip_field(rt,wiretype,fieldno);
}; /*switch*/
};/*while*/
ast_err
BytesOptional_read(ast_runtime* rt, BytesOptional** bytesoptional_vp)
{
ast_err status = AST_NOERR;
uint32_t wiretype, fieldno;
BytesOptional* bytesoptional_v;
bytesoptional_v = (BytesOptional*)ast_alloc(rt,sizeof(BytesOptional));
if(bytesoptional_v == NULL) return AST_ENOMEM;
while(status == AST_NOERR) {
status = ast_read_tag(rt,&wiretype,&fieldno);
if(status == AST_EOF) {status = AST_NOERR; break;}
if(status != AST_NOERR) break;
switch (fieldno) {
case 1: {
bytesoptional_v->f_string.defined = 1;
bytesoptional_v->f_string.value = NULL;
status = ast_read_primitive(rt,ast_string,1,&bytesoptional_v->f_string.value);
} break;
case 2: {
bytesoptional_v->f_bytes.defined = 1;
bytesoptional_v->f_bytes.value.nbytes = 0;
bytesoptional_v->f_bytes.value.bytes = NULL;
status = ast_read_primitive(rt,ast_bytes,2,&bytesoptional_v->f_bytes.value);
} break;
default:
status = ast_skip_field(rt,wiretype,fieldno);
if(status != AST_NOERR) {goto done;}
}; /*switch*/
};/*while*/
if(!bytesoptional_v->f_string.defined) {
bytesoptional_v->f_string.value = "hello";
}
if(!bytesoptional_v->f_bytes.defined) {
bytesoptional_v->f_bytes.value.nbytes = 0;
bytesoptional_v->f_bytes.value.bytes = NULL;
}
if(status != AST_NOERR) {goto done;}
if(bytesoptional_vp) *bytesoptional_vp = bytesoptional_v;
done:
return status;
} /*BytesOptional_read*/
/* limit reads to next n bytes */
static int
ast_byteio_mark(ast_runtime* rt, size_t count)
{
struct _ast_bytestream* stream = NULL;
struct _ast_stack* node = NULL;
if(rt == NULL || rt->uid != BYTEIO_UID || rt->mode != AST_READ)
return AST_EFAIL;
stream = (struct _ast_bytestream*)rt->stream;
node = ast_alloc(rt,sizeof(struct _ast_stack));
if(node == NULL) return AST_ENOMEM;
*node = stream->stack;
stream->stack.stack = node;
stream->stack.maxpos = stream->pos+count;
/* stream maxpos must be <= alloc */
if(stream->stack.maxpos > stream->alloc)
assert(0);
/* stream->stack.maxpos = stream->alloc; */
return AST_NOERR;
}
void* ast_alloc_with_type(context_t *ctx, size_t sz, ast_node_type_t type) {
ast_node_t *node = ast_alloc(ctx, sz);
node->type = type;
return node;
}
