ast_function *function;
MEM_VECTOR_MAKE(ast_value*, locals);
size_t blocklocal;
+
+ size_t errors;
} parser_t;
MEM_VEC_FUNCTIONS(parser_t, ast_value*, globals)
{
va_list ap;
+ parser->errors++;
+
if (parser)
printf("error %s:%lu: ", parser->lex->tok->ctx.file, (unsigned long)parser->lex->tok->ctx.line);
else
int paren;
size_t off;
ast_expression *out;
- ast_value *value; /* need to know if we can assign */
ast_block *block; /* for commas and function calls */
lex_ctx ctx;
} sy_elem;
sy_elem e;
e.etype = 0;
e.out = v;
- e.value = NULL;
- e.block = NULL;
- e.ctx = ctx;
- e.paren = 0;
- return e;
-}
-static sy_elem syval(lex_ctx ctx, ast_value *v) {
- sy_elem e;
- e.etype = 0;
- e.out = (ast_expression*)v;
- e.value = v;
e.block = NULL;
e.ctx = ctx;
e.paren = 0;
sy_elem e;
e.etype = 0;
e.out = (ast_expression*)v;
- e.value = NULL;
e.block = v;
e.ctx = ctx;
e.paren = 0;
sy_elem e;
e.etype = 1 + (op - operators);
e.out = NULL;
- e.value = NULL;
e.block = NULL;
e.ctx = ctx;
e.paren = 0;
e.etype = 0;
e.off = off;
e.out = NULL;
- e.value = NULL;
e.block = NULL;
e.ctx = ctx;
e.paren = p;
lex_ctx ctx;
ast_expression *out = NULL;
ast_expression *exprs[3];
- ast_value *vars[3];
ast_block *blocks[3];
size_t i;
sy->out_count -= op->operands;
for (i = 0; i < op->operands; ++i) {
exprs[i] = sy->out[sy->out_count+i].out;
- vars[i] = sy->out[sy->out_count+i].value;
blocks[i] = sy->out[sy->out_count+i].block;
}
case opid1('='):
- if (!vars[0]) {
- parseerror(parser, "Cannot assign to non-variable");
- return false;
- }
out = (ast_expression*)ast_store_new(ctx,
- type_store_instr[vars[0]->expression.vtype],
- vars[0], exprs[1]);
+ type_store_instr[exprs[0]->expression.vtype],
+ exprs[0], exprs[1]);
break;
}
return false;
}
- printf("fid = %i, out_count = %i\n", (int)fid, (int)sy->out_count);
-
if (fid+1 == sy->out_count) {
/* no arguments */
paramcount = 0;
parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
goto onerr;
}
- if (!shunt_out_add(&sy, syval(parser_ctx(parser), var))) {
+ if (!shunt_out_add(&sy, syexp(parser_ctx(parser), (ast_expression*)var))) {
parseerror(parser, "out of memory");
goto onerr;
}
{
if (!strcmp(parser_tokval(parser), "return"))
{
- ast_expression *exp;
- ast_return *ret;
+ ast_expression *exp = NULL;
+ ast_return *ret = NULL;
+ ast_value *expected = parser->function->vtype;
if (!parser_next(parser)) {
parseerror(parser, "expected return expression");
return false;
}
- exp = parser_expression(parser);
- if (!exp)
- return false;
- ret = ast_return_new(exp->expression.node.context, exp);
- if (!ret) {
- ast_delete(exp);
- return false;
- }
- if (!ast_block_exprs_add(block, (ast_expression*)ret)) {
- ast_delete(ret);
- return false;
+ if (parser->tok != ';') {
+ exp = parser_expression(parser);
+ if (!exp)
+ return false;
+
+ if (exp->expression.vtype != expected->expression.next->expression.vtype) {
+ parseerror(parser, "return with invalid expression");
+ }
+
+ ret = ast_return_new(exp->expression.node.context, exp);
+ if (!ret) {
+ ast_delete(exp);
+ return false;
+ }
+
+ if (!ast_block_exprs_add(block, (ast_expression*)ret)) {
+ ast_delete(ret);
+ return false;
+ }
+ } else if (!parser_next(parser)) {
+ parseerror(parser, "expected semicolon");
+ if (expected->expression.next->expression.vtype != TYPE_VOID) {
+ parseerror(parser, "return without value");
+ }
}
return true;
}
return true;
}
-bool parser_compile(const char *filename, const char *datfile)
-{
- size_t i;
- parser_t *parser;
- ir_builder *ir;
+static parser_t *parser;
+bool parser_init()
+{
parser = (parser_t*)mem_a(sizeof(parser_t));
if (!parser)
return false;
MEM_VECTOR_INIT(parser, globals);
MEM_VECTOR_INIT(parser, locals);
- parser->lex = lex_open(filename);
+ return true;
+}
+bool parser_compile(const char *filename)
+{
+ parser->lex = lex_open(filename);
if (!parser->lex) {
printf("failed to open file \"%s\"\n", filename);
return false;
lex_close(parser->lex);
- ir = ir_builder_new("gmqcc_out");
- if (!ir) {
- printf("failed to allocate builder\n");
- goto cleanup;
- }
+ return !parser->errors;
+}
- for (i = 0; i < parser->imm_float_count; ++i) {
- if (!ast_global_codegen(parser->imm_float[i], ir)) {
- printf("failed to generate global %s\n", parser->imm_float[i]->name);
- }
+void parser_cleanup()
+{
+ size_t i;
+ for (i = 0; i < parser->functions_count; ++i) {
+ ast_delete(parser->functions[i]);
+ }
+ for (i = 0; i < parser->imm_vector_count; ++i) {
+ ast_delete(parser->imm_vector[i]);
}
for (i = 0; i < parser->imm_string_count; ++i) {
- if (!ast_global_codegen(parser->imm_string[i], ir)) {
- printf("failed to generate global %s\n", parser->imm_string[i]->name);
- }
+ ast_delete(parser->imm_string[i]);
}
- for (i = 0; i < parser->imm_vector_count; ++i) {
- if (!ast_global_codegen(parser->imm_vector[i], ir)) {
- printf("failed to generate global %s\n", parser->imm_vector[i]->name);
- }
+ for (i = 0; i < parser->imm_float_count; ++i) {
+ ast_delete(parser->imm_float[i]);
}
for (i = 0; i < parser->globals_count; ++i) {
- if (!ast_global_codegen(parser->globals[i], ir)) {
- printf("failed to generate global %s\n", parser->globals[i]->name);
- }
+ ast_delete(parser->globals[i]);
}
- for (i = 0; i < parser->functions_count; ++i) {
- if (!ast_function_codegen(parser->functions[i], ir)) {
- printf("failed to generate function %s\n", parser->functions[i]->name);
- }
- if (!ir_function_finalize(parser->functions[i]->ir_func)) {
- printf("failed to finalize function %s\n", parser->functions[i]->name);
+ MEM_VECTOR_CLEAR(parser, globals);
+
+ mem_d(parser);
+}
+
+bool parser_finish(const char *output)
+{
+ size_t i;
+ ir_builder *ir;
+
+ if (!parser->errors)
+ {
+ ir = ir_builder_new("gmqcc_out");
+ if (!ir) {
+ printf("failed to allocate builder\n");
+ return false;
}
- }
- ir_builder_dump(ir, printf);
+ for (i = 0; i < parser->imm_float_count; ++i) {
+ if (!ast_global_codegen(parser->imm_float[i], ir)) {
+ printf("failed to generate global %s\n", parser->imm_float[i]->name);
+ ir_builder_delete(ir);
+ return false;
+ }
+ }
+ for (i = 0; i < parser->imm_string_count; ++i) {
+ if (!ast_global_codegen(parser->imm_string[i], ir)) {
+ printf("failed to generate global %s\n", parser->imm_string[i]->name);
+ ir_builder_delete(ir);
+ return false;
+ }
+ }
+ for (i = 0; i < parser->imm_vector_count; ++i) {
+ if (!ast_global_codegen(parser->imm_vector[i], ir)) {
+ printf("failed to generate global %s\n", parser->imm_vector[i]->name);
+ ir_builder_delete(ir);
+ return false;
+ }
+ }
+ for (i = 0; i < parser->globals_count; ++i) {
+ if (!ast_global_codegen(parser->globals[i], ir)) {
+ printf("failed to generate global %s\n", parser->globals[i]->name);
+ ir_builder_delete(ir);
+ return false;
+ }
+ }
+ for (i = 0; i < parser->functions_count; ++i) {
+ if (!ast_function_codegen(parser->functions[i], ir)) {
+ printf("failed to generate function %s\n", parser->functions[i]->name);
+ ir_builder_delete(ir);
+ return false;
+ }
+ if (!ir_function_finalize(parser->functions[i]->ir_func)) {
+ printf("failed to finalize function %s\n", parser->functions[i]->name);
+ ir_builder_delete(ir);
+ return false;
+ }
+ }
- if (!ir_builder_generate(ir, datfile))
- printf("*** failed to generate output file\n");
+ ir_builder_dump(ir, printf);
- ir_builder_delete(ir);
+ if (!ir_builder_generate(ir, output)) {
+ printf("*** failed to generate output file\n");
+ ir_builder_delete(ir);
+ return false;
+ }
-cleanup:
- for (i = 0; i < parser->globals_count; ++i) {
- ast_value_delete(parser->globals[i]);
+ ir_builder_delete(ir);
+ return true;
}
- MEM_VECTOR_CLEAR(parser, globals);
- mem_d(parser);
- return true;
+ printf("*** there were compile errors\n");
+ return false;
}
projects / xonotic / gmqcc.git / blobdiff