static bool parser_leaveblock(parser_t *parser);
static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
static bool parse_typedef(parser_t *parser);
-static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef);
+static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref);
static ast_block* parse_block(parser_t *parser);
static bool parse_block_into(parser_t *parser, ast_block *block);
static bool parse_statement_or_block(parser_t *parser, ast_expression **out);
/* returns true if it counts as an error */
static bool GMQCC_WARN parsewarning(parser_t *parser, int warntype, const char *fmt, ...)
{
+ bool r;
va_list ap;
- int lvl = LVL_WARNING;
-
- if (!OPTS_WARN(warntype))
- return false;
-
- if (opts_werror) {
- parser->errors++;
- lvl = LVL_ERROR;
- }
-
va_start(ap, fmt);
- con_vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "warning", fmt, ap);
+ r = vcompile_warning(parser->lex->tok.ctx, warntype, fmt, ap);
va_end(ap);
-
- return opts_werror;
+ return r;
}
static bool GMQCC_WARN genwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
{
+ bool r;
va_list ap;
- int lvl = LVL_WARNING;
-
- if (!OPTS_WARN(warntype))
- return false;
-
- if (opts_werror)
- lvl = LVL_ERROR;
-
va_start(ap, fmt);
- con_vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap);
+ r = vcompile_warning(ctx, warntype, fmt, ap);
va_end(ap);
-
- return opts_werror;
+ return r;
}
/**********************************************************************
return true;
}
-static bool parser_sy_pop(parser_t *parser, shunt *sy)
+static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
{
const oper_info *op;
lex_ctx ctx;
{
#if 0
/* This is not broken in fteqcc anymore */
- if (opts_standard != COMPILER_GMQCC) {
+ if (opts.standard != COMPILER_GMQCC) {
/* this error doesn't need to make us bail out */
(void)!parsewarning(parser, WARN_EXTENSIONS,
"accessing array-field members of an entity without parenthesis\n"
case opid1(','):
if (blocks[0]) {
- ast_block_add_expr(blocks[0], exprs[1]);
+ if (!ast_block_add_expr(blocks[0], exprs[1]))
+ return false;
} else {
blocks[0] = ast_block_new(ctx);
- ast_block_add_expr(blocks[0], exprs[0]);
- ast_block_add_expr(blocks[0], exprs[1]);
+ if (!ast_block_add_expr(blocks[0], exprs[0]) ||
+ !ast_block_add_expr(blocks[0], exprs[1]))
+ {
+ return false;
+ }
}
if (!ast_block_set_type(blocks[0], exprs[1]))
return false;
return false;
}
#endif
- if (opts_standard == COMPILER_GMQCC)
+ if (opts.standard == COMPILER_GMQCC)
con_out("TODO: early out logic\n");
if (CanConstFold(exprs[0], exprs[1]))
out = (ast_expression*)parser_const_float(parser,
}
else
assignop = type_storep_instr[exprs[0]->expression.vtype];
- if (!ast_compare_type(field->expression.next, exprs[1])) {
+ if (assignop == AINSTR_END ||
+ !ast_compare_type(field->expression.next, exprs[1]))
+ {
ast_type_to_string(field->expression.next, ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2));
if (OPTS_FLAG(ASSIGN_FUNCTION_TYPES) &&
const char *fewmany = (vec_size(fun->expression.params) > paramcount) ? "few" : "many";
fval = (ast_istype(fun, ast_value) ? ((ast_value*)fun) : NULL);
- if (opts_standard == COMPILER_GMQCC)
+ if (opts.standard == COMPILER_GMQCC)
{
if (fval)
parseerror(parser, "too %s parameters for call to %s: expected %i, got %i\n"
/* pop off the parenthesis */
vec_shrinkby(sy->ops, 1);
/* then apply the index operator */
- if (!parser_sy_pop(parser, sy))
+ if (!parser_sy_apply_operator(parser, sy))
return false;
return true;
}
vec_shrinkby(sy->ops, 1);
return true;
}
- if (!parser_sy_pop(parser, sy))
+ if (!parser_sy_apply_operator(parser, sy))
return false;
}
return true;
}
wantop = true;
/* variable */
- if (opts_standard == COMPILER_GMQCC)
+ if (opts.standard == COMPILER_GMQCC)
{
if (parser->memberof == TYPE_ENTITY) {
/* still get vars first since there could be a fieldpointer */
vec_pop(parser->pot);
wantop = true;
}
+ else if (parser->tok == TOKEN_TYPENAME) {
+ parseerror(parser, "unexpected typename");
+ goto onerr;
+ }
else if (parser->tok != TOKEN_OPERATOR) {
if (wantop) {
parseerror(parser, "expected operator or end of statement");
(op->prec < olast->prec) ||
(op->assoc == ASSOC_LEFT && op->prec <= olast->prec) ) )
{
- if (!parser_sy_pop(parser, &sy))
+ if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
if (vec_size(sy.ops) && !vec_last(sy.ops).paren)
olast = &operators[vec_last(sy.ops).etype-1];
olast = NULL;
}
- if (op->id == opid1('.') && opts_standard == COMPILER_GMQCC) {
+ if (op->id == opid1('.') && opts.standard == COMPILER_GMQCC) {
/* for gmqcc standard: open up the namespace of the previous type */
ast_expression *prevex = vec_last(sy.out).out;
if (!prevex) {
}
while (vec_size(sy.ops)) {
- if (!parser_sy_pop(parser, &sy))
+ if (!parser_sy_apply_operator(parser, &sy))
goto onerr;
}
typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
if (typevar || parser->tok == TOKEN_TYPENAME) {
- if (opts_standard != COMPILER_GMQCC) {
+ if (opts.standard != COMPILER_GMQCC) {
if (parsewarning(parser, WARN_EXTENSIONS,
"current standard does not allow variable declarations in for-loop initializers"))
goto onerr;
}
- if (!parse_variable(parser, block, true, CV_VAR, typevar))
+ if (!parse_variable(parser, block, true, CV_VAR, typevar, false))
goto onerr;
}
else if (parser->tok != ';')
if (!parser_next(parser))
parseerror(parser, "parse error");
if (expected->expression.next->expression.vtype != TYPE_VOID) {
- if (opts_standard != COMPILER_GMQCC)
+ if (opts.standard != COMPILER_GMQCC)
(void)!parsewarning(parser, WARN_MISSING_RETURN_VALUES, "return without value");
else
parseerror(parser, "return without value");
return true;
}
+/* returns true when it was a variable qualifier, false otherwise!
+ * on error, cvq is set to CV_WRONG
+ */
+static bool parse_var_qualifiers(parser_t *parser, bool with_local, int *cvq, bool *noref)
+{
+ bool had_const = false;
+ bool had_var = false;
+ bool had_noref = false;
+
+ for (;;) {
+ if (!strcmp(parser_tokval(parser), "const"))
+ had_const = true;
+ else if (!strcmp(parser_tokval(parser), "var"))
+ had_var = true;
+ else if (with_local && !strcmp(parser_tokval(parser), "local"))
+ had_var = true;
+ else if (!strcmp(parser_tokval(parser), "noref"))
+ had_noref = true;
+ else if (!had_const && !had_var && !had_noref) {
+ return false;
+ }
+ else
+ break;
+ if (!parser_next(parser))
+ goto onerr;
+ }
+ if (had_const)
+ *cvq = CV_CONST;
+ else if (had_var)
+ *cvq = CV_VAR;
+ else
+ *cvq = CV_NONE;
+ *noref = had_noref;
+ return true;
+onerr:
+ parseerror(parser, "parse error after variable qualifier");
+ *cvq = CV_WRONG;
+ return true;
+}
+
static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **out)
{
ast_expression *operand;
ast_switch *switchnode;
ast_switch_case swcase;
+ int cvq;
+ bool noref;
+
lex_ctx ctx = parser_ctx(parser);
(void)block; /* not touching */
if (parser->tok == TOKEN_IDENT)
typevar = parser_find_typedef(parser, parser_tokval(parser), 0);
if (typevar || parser->tok == TOKEN_TYPENAME) {
- if (!parse_variable(parser, block, false, CV_NONE, typevar)) {
+ if (!parse_variable(parser, block, false, CV_NONE, typevar, false)) {
ast_delete(switchnode);
return false;
}
continue;
}
- if (!strcmp(parser_tokval(parser), "var") ||
- !strcmp(parser_tokval(parser), "local"))
+ if (parse_var_qualifiers(parser, true, &cvq, &noref))
{
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration");
+ if (cvq == CV_WRONG) {
ast_delete(switchnode);
return false;
}
- if (!parse_variable(parser, block, false, CV_VAR, NULL)) {
- ast_delete(switchnode);
- return false;
- }
- continue;
- }
- if (!strcmp(parser_tokval(parser), "const")) {
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration");
- ast_delete(switchnode);
- return false;
- }
- if (!strcmp(parser_tokval(parser), "var")) {
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration");
- ast_delete(switchnode);
- return false;
- }
- }
- if (!parse_variable(parser, block, false, CV_CONST, NULL)) {
+ if (!parse_variable(parser, block, false, cvq, NULL, noref)) {
ast_delete(switchnode);
return false;
}
}
if (!expr)
continue;
- ast_block_add_expr(caseblock, expr);
+ if (!ast_block_add_expr(caseblock, expr)) {
+ ast_delete(switchnode);
+ return false;
+ }
}
}
}
else
{
- parseerror(parser, "unrecognized hash-keyword: `%s`", parser_tokval(parser));
+ (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser));
return false;
}
static bool parse_statement(parser_t *parser, ast_block *block, ast_expression **out, bool allow_cases)
{
- int cvq;
+ bool noref;
+ int cvq = CV_NONE;
ast_value *typevar = NULL;
+
*out = NULL;
if (parser->tok == TOKEN_IDENT)
parseerror(parser, "cannot declare a variable from here");
return false;
}
- if (opts_standard == COMPILER_QCC) {
+ if (opts.standard == COMPILER_QCC) {
if (parsewarning(parser, WARN_EXTENSIONS, "missing 'local' keyword when declaring a local variable"))
return false;
}
- if (!parse_variable(parser, block, false, CV_NONE, typevar))
+ if (!parse_variable(parser, block, false, CV_NONE, typevar, false))
return false;
- *out = NULL;
return true;
}
- else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var"))
+ else if (parse_var_qualifiers(parser, !!block, &cvq, &noref))
{
- goto ident_var;
+ if (cvq == CV_WRONG)
+ return false;
+ return parse_variable(parser, block, true, cvq, NULL, noref);
}
else if (parser->tok == TOKEN_KEYWORD)
{
- if (!strcmp(parser_tokval(parser), "local") ||
- !strcmp(parser_tokval(parser), "const") ||
- !strcmp(parser_tokval(parser), "var"))
- {
-ident_var:
- if (parser_tokval(parser)[0] == 'c')
- cvq = CV_CONST;
- else if (parser_tokval(parser)[0] == 'v')
- cvq = CV_VAR;
- else
- cvq = CV_NONE;
-
- if (!block) {
- parseerror(parser, "cannot declare a local variable here");
- return false;
- }
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration");
- return false;
- }
- if (!parse_variable(parser, block, true, cvq, NULL))
- return false;
- *out = NULL;
- return true;
- }
- else if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype"))
+ if (!strcmp(parser_tokval(parser), "__builtin_debug_printtype"))
{
char ty[1024];
ast_value *tdef;
}
else if (!strcmp(parser_tokval(parser), "for"))
{
- if (opts_standard == COMPILER_QCC) {
+ if (opts.standard == COMPILER_QCC) {
if (parsewarning(parser, WARN_EXTENSIONS, "for loops are not recognized in the original Quake C standard, to enable try an alternate standard --std=?"))
return false;
}
}
if (!expr)
continue;
- ast_block_add_expr(block, expr);
+ if (!ast_block_add_expr(block, expr)) {
+ ast_delete(block);
+ block = NULL;
+ goto cleanup;
+ }
}
if (parser->tok != '}') {
if (store_think) ast_delete(store_think);
retval = false;
}
- ast_block_add_expr(block, (ast_expression*)store_frame);
- ast_block_add_expr(block, (ast_expression*)store_nextthink);
- ast_block_add_expr(block, (ast_expression*)store_think);
+ if (!ast_block_add_expr(block, (ast_expression*)store_frame) ||
+ !ast_block_add_expr(block, (ast_expression*)store_nextthink) ||
+ !ast_block_add_expr(block, (ast_expression*)store_think))
+ {
+ retval = false;
+ }
}
if (!retval) {
if (parser->tok == ';')
return parser_next(parser);
- else if (opts_standard == COMPILER_QCC)
+ else if (opts.standard == COMPILER_QCC)
parseerror(parser, "missing semicolon after function body (mandatory with -std=qcc)");
return retval;
return NULL;
}
- ast_block_add_expr(block, (ast_expression*)st);
+ if (!ast_block_add_expr(block, (ast_expression*)st)) {
+ ast_delete(block);
+ return NULL;
+ }
ret = ast_return_new(ctx, NULL);
if (!ret) {
return NULL;
}
- ast_block_add_expr(block, (ast_expression*)ret);
+ if (!ast_block_add_expr(block, (ast_expression*)ret)) {
+ ast_delete(block);
+ return NULL;
+ }
return (ast_expression*)block;
} else {
return NULL;
}
- ast_block_add_expr(block, (ast_expression*)st);
+ if (!ast_block_add_expr(block, (ast_expression*)st)) {
+ ast_delete(block);
+ return NULL;
+ }
ret = ast_return_new(ctx, NULL);
if (!ret) {
return NULL;
}
- ast_block_add_expr(block, (ast_expression*)ret);
+ if (!ast_block_add_expr(block, (ast_expression*)ret)) {
+ ast_delete(block);
+ return NULL;
+ }
return (ast_expression*)block;
} else {
goto cleanup;
}
- ast_block_add_expr(func->blocks[0], root);
array->setter = fval;
- return true;
+ return ast_block_add_expr(func->blocks[0], root);
cleanup:
if (index) ast_delete(index);
if (value) ast_delete(value);
goto cleanup;
}
- ast_block_add_expr(func->blocks[0], root);
array->setter = fval;
- return true;
+ return ast_block_add_expr(func->blocks[0], root);
cleanup:
if (entity) ast_delete(entity);
if (index) ast_delete(index);
goto cleanup;
}
- ast_block_add_expr(func->blocks[0], root);
array->getter = fval;
- return true;
+ return ast_block_add_expr(func->blocks[0], root);
cleanup:
if (index) ast_delete(index);
if (root) ast_delete(root);
vec_free(params);
/* sanity check */
- if (vec_size(params) > 8 && opts_standard == COMPILER_QCC)
+ if (vec_size(params) > 8 && opts.standard == COMPILER_QCC)
(void)!parsewarning(parser, WARN_EXTENSIONS, "more than 8 parameters are not supported by this standard");
/* parse-out */
}
/* now there may be function parens again */
- if (parser->tok == '(' && opts_standard == COMPILER_QCC)
+ if (parser->tok == '(' && opts.standard == COMPILER_QCC)
parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
if (parser->tok == '(' && wasarray)
parseerror(parser, "arrays as part of a return type is not supported");
return true;
}
-static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef)
+static bool parse_variable(parser_t *parser, ast_block *localblock, bool nofields, int qualifier, ast_value *cached_typedef, bool noref)
{
ast_value *var;
ast_value *proto;
/* Part 0: finish the type */
if (parser->tok == '(') {
- if (opts_standard == COMPILER_QCC)
+ if (opts.standard == COMPILER_QCC)
parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
var = parse_parameter_list(parser, var);
if (!var) {
}
/* for functions returning functions */
while (parser->tok == '(') {
- if (opts_standard == COMPILER_QCC)
+ if (opts.standard == COMPILER_QCC)
parseerror(parser, "C-style function syntax is not allowed in -std=qcc");
var = parse_parameter_list(parser, var);
if (!var) {
}
var->cvq = qualifier;
+ /* in a noref section we simply bump the usecount */
+ if (noref || parser->noref)
+ var->uses++;
/* Part 1:
* check for validity: (end_sys_..., multiple-definitions, prototypes, ...)
/* Deal with end_sys_ vars */
was_end = false;
if (!strcmp(var->name, "end_sys_globals")) {
+ var->uses++;
parser->crc_globals = vec_size(parser->globals);
was_end = true;
}
else if (!strcmp(var->name, "end_sys_fields")) {
+ var->uses++;
parser->crc_fields = vec_size(parser->fields);
was_end = true;
}
goto cleanup;
*/
}
- if (opts_standard == COMPILER_QCC &&
+ if (opts.standard == COMPILER_QCC &&
(old = parser_find_global(parser, var->name)))
{
parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
{
/* other globals */
if (old) {
- if (opts_standard == COMPILER_GMQCC) {
+ if (opts.standard == COMPILER_GMQCC) {
parseerror(parser, "global `%s` already declared here: %s:%i",
var->name, ast_ctx(old).file, ast_ctx(old).line);
retval = false;
var = proto;
}
}
- if (opts_standard == COMPILER_QCC &&
+ if (opts.standard == COMPILER_QCC &&
(old = parser_find_field(parser, var->name)))
{
parseerror(parser, "cannot declare a field and a global of the same name with -std=qcc");
retval = false;
goto cleanup;
}
- if (opts_standard != COMPILER_GMQCC) {
+ if (opts.standard != COMPILER_GMQCC) {
ast_delete(var);
var = NULL;
goto skipvar;
break;
}
- if (localblock && opts_standard == COMPILER_QCC) {
+ if (localblock && opts.standard == COMPILER_QCC) {
if (parsewarning(parser, WARN_LOCAL_CONSTANTS,
"initializing expression turns variable `%s` into a constant in this standard",
var->name) )
break;
}
}
- else if (opts_standard == COMPILER_QCC) {
+ else if (opts.standard == COMPILER_QCC) {
parseerror(parser, "expected '=' before function body in this standard");
}
parseerror(parser, "cannot initialize a global constant variable with a non-constant expression");
else
{
- if (opts_standard != COMPILER_GMQCC &&
+ if (opts.standard != COMPILER_GMQCC &&
!OPTS_FLAG(INITIALIZED_NONCONSTANTS) &&
qualifier != CV_VAR)
{
vec_push(sy.out, syexp(ast_ctx(var), (ast_expression*)var));
vec_push(sy.out, syexp(ast_ctx(cexp), (ast_expression*)cexp));
vec_push(sy.ops, syop(ast_ctx(var), parser->assign_op));
- if (!parser_sy_pop(parser, &sy))
+ if (!parser_sy_apply_operator(parser, &sy))
ast_unref(cexp);
else {
if (vec_size(sy.out) != 1 && vec_size(sy.ops) != 0)
parseerror(parser, "internal error: leaked operands");
- ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out);
+ if (!ast_block_add_expr(localblock, (ast_expression*)sy.out[0].out))
+ break;
}
vec_free(sy.out);
vec_free(sy.ops);
static bool parser_global_statement(parser_t *parser)
{
+ int cvq = CV_WRONG;
+ bool noref = false;
ast_value *istype = NULL;
+
if (parser->tok == TOKEN_IDENT)
istype = parser_find_typedef(parser, parser_tokval(parser), 0);
if (istype || parser->tok == TOKEN_TYPENAME || parser->tok == '.')
{
- return parse_variable(parser, NULL, false, CV_NONE, istype);
+ return parse_variable(parser, NULL, false, CV_NONE, istype, false);
}
- else if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var"))
+ else if (parse_var_qualifiers(parser, false, &cvq, &noref))
{
- if (!strcmp(parser_tokval(parser), "var")) {
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration after 'var'");
- return false;
- }
- if (parser->tok == TOKEN_KEYWORD && !strcmp(parser_tokval(parser), "const")) {
- (void)!parsewarning(parser, WARN_CONST_VAR, "ignoring `const` after 'var' qualifier");
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration after 'const var'");
- return false;
- }
- }
- return parse_variable(parser, NULL, true, CV_VAR, NULL);
- }
+ if (cvq == CV_WRONG)
+ return false;
+ return parse_variable(parser, NULL, true, cvq, NULL, noref);
}
else if (parser->tok == TOKEN_KEYWORD)
{
- if (!strcmp(parser_tokval(parser), "const")) {
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration after 'const'");
- return false;
- }
- if (parser->tok == TOKEN_IDENT && !strcmp(parser_tokval(parser), "var")) {
- (void)!parsewarning(parser, WARN_CONST_VAR, "ignoring `var` after const qualifier");
- if (!parser_next(parser)) {
- parseerror(parser, "expected variable declaration after 'const var'");
- return false;
- }
- }
- return parse_variable(parser, NULL, true, CV_CONST, NULL);
- }
- else if (!strcmp(parser_tokval(parser), "typedef")) {
+ if (!strcmp(parser_tokval(parser), "typedef")) {
if (!parser_next(parser)) {
parseerror(parser, "expected type definition after 'typedef'");
return false;
continue;
asvalue = (ast_value*)(parser->globals[i]);
if (!asvalue->uses && !asvalue->hasvalue && asvalue->expression.vtype != TYPE_FUNCTION) {
- if (strcmp(asvalue->name, "end_sys_globals") &&
- strcmp(asvalue->name, "end_sys_fields"))
- {
- retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
- "unused global: `%s`", asvalue->name);
- }
+ retval = retval && !genwarning(ast_ctx(asvalue), WARN_UNUSED_VARIABLE,
+ "unused global: `%s`", asvalue->name);
}
if (!ast_global_codegen(asvalue, ir, false)) {
con_out("failed to generate global %s\n", asvalue->name);
return false;
}
}
- if (opts_dump)
+ if (opts.dump)
ir_builder_dump(ir, con_out);
for (i = 0; i < vec_size(parser->functions); ++i) {
if (!ir_function_finalize(parser->functions[i]->ir_func)) {
}
if (retval) {
- if (opts_dumpfin)
+ if (opts.dumpfin)
ir_builder_dump(ir, con_out);
generate_checksum(parser);
projects / xonotic / gmqcc.git / blobdiff