* anything else: type error
*/
qcint memberof;
+
+ /* Keep track of our ternary vs parenthesis nesting state.
+ * If we reach a 'comma' operator in a ternary without a paren,
+ * we shall trigger -Wternary-precedence.
+ */
+ enum { POT_PAREN, POT_TERNARY1, POT_TERNARY2 } *pot;
+
+ /* pragma flags */
+ bool noref;
} parser_t;
static void parser_enterblock(parser_t *parser);
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);
}
va_start(ap, fmt);
- con_vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, "warning", fmt, ap);
+ con_vprintmsg(lvl, parser->lex->tok.ctx.file, parser->lex->tok.ctx.line, (opts_werror ? "error" : "warning"), fmt, ap);
va_end(ap);
return opts_werror;
lvl = LVL_ERROR;
va_start(ap, fmt);
- con_vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap);
+ con_vprintmsg(lvl, ctx.file, ctx.line, (opts_werror ? "error" : "warning"), fmt, ap);
va_end(ap);
return opts_werror;
break;
case opid2('?',':'):
+ if (vec_last(parser->pot) != POT_TERNARY2) {
+ parseerror(parser, "mismatched parenthesis/ternary");
+ return false;
+ }
+ vec_pop(parser->pot);
if (exprs[1]->expression.vtype != exprs[2]->expression.vtype) {
ast_type_to_string(exprs[1], ty1, sizeof(ty1));
ast_type_to_string(exprs[2], ty2, sizeof(ty2));
if (sy->ops[vec_size(sy->ops)-1].paren == SY_PAREN_TERNARY) {
if (functions_only)
return false;
+ if (vec_last(parser->pot) != POT_TERNARY1) {
+ parseerror(parser, "mismatched colon in ternary expression (missing closing paren?)");
+ return false;
+ }
+ vec_last(parser->pot) = POT_TERNARY2;
/* pop off the parenthesis */
vec_shrinkby(sy->ops, 1);
return true;
/* closing an opening paren */
if (!parser_close_paren(parser, &sy, false))
goto onerr;
+ if (vec_last(parser->pot) != POT_PAREN) {
+ parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
+ goto onerr;
+ }
+ vec_pop(parser->pot);
} else {
DEBUGSHUNTDO(con_out("do[nop] )\n"));
--parens;
/* allowed for function calls */
if (!parser_close_paren(parser, &sy, true))
goto onerr;
+ if (vec_last(parser->pot) != POT_PAREN) {
+ parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
+ goto onerr;
+ }
+ vec_pop(parser->pot);
}
wantop = true;
}
break;
if (!parser_close_paren(parser, &sy, false))
goto onerr;
+ if (vec_last(parser->pot) != POT_PAREN) {
+ parseerror(parser, "mismatched parentheses (closing paren during ternary expression?)");
+ goto onerr;
+ }
+ vec_pop(parser->pot);
wantop = true;
}
else if (parser->tok != TOKEN_OPERATOR) {
break;
}
+ if (op->id == opid1(',')) {
+ if (vec_size(parser->pot) && vec_last(parser->pot) == POT_TERNARY2) {
+ (void)!parsewarning(parser, WARN_TERNARY_PRECEDENCE, "suggesting parenthesis around ternary expression");
+ }
+ }
+
if (vec_size(sy.ops) && !vec_last(sy.ops).paren)
olast = &operators[vec_last(sy.ops).etype-1];
if (wantop) {
size_t sycount = vec_size(sy.out);
DEBUGSHUNTDO(con_out("push [op] (\n"));
- ++parens;
+ ++parens; vec_push(parser->pot, POT_PAREN);
/* we expected an operator, this is the function-call operator */
vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_FUNC, sycount-1));
} else {
- ++parens;
+ ++parens; vec_push(parser->pot, POT_PAREN);
vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_EXPR, 0));
DEBUGSHUNTDO(con_out("push [nop] (\n"));
}
parseerror(parser, "unexpected array subscript");
goto onerr;
}
- ++parens;
+ ++parens; vec_push(parser->pot, POT_PAREN);
/* push both the operator and the paren, this makes life easier */
vec_push(sy.ops, syop(parser_ctx(parser), op));
vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0));
vec_push(sy.ops, syop(parser_ctx(parser), op));
vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0));
wantop = false;
- --ternaries;
+ ++ternaries;
+ vec_push(parser->pot, POT_TERNARY1);
} else if (op->id == opid2(':','?')) {
+ if (!vec_size(parser->pot)) {
+ parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
+ goto onerr;
+ }
+ if (vec_last(parser->pot) != POT_TERNARY1) {
+ parseerror(parser, "unexpected colon outside ternary expression (missing parenthesis?)");
+ goto onerr;
+ }
if (!parser_close_paren(parser, &sy, false))
goto onerr;
vec_push(sy.ops, syop(parser_ctx(parser), op));
wantop = false;
- ++ternaries;
+ --ternaries;
} else {
DEBUGSHUNTDO(con_out("push operator %s\n", op->op));
vec_push(sy.ops, syop(parser_ctx(parser), op));
vec_free(sy.out);
vec_free(sy.ops);
DEBUGSHUNTDO(con_out("shunt done\n"));
+ if (vec_size(parser->pot)) {
+ parseerror(parser, "internal error: vec_size(parser->pot) = %lu", (unsigned long)vec_size(parser->pot));
+ return NULL;
+ }
+ vec_free(parser->pot);
return expr;
onerr:
"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 != ';')
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");
- ast_delete(switchnode);
- return false;
- }
- if (!parse_variable(parser, block, false, CV_VAR, NULL)) {
+ if (cvq == CV_WRONG) {
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;
}
return true;
}
+static bool parse_skipwhite(parser_t *parser)
+{
+ do {
+ if (!parser_next(parser))
+ return false;
+ } while (parser->tok == TOKEN_WHITE && parser->tok < TOKEN_ERROR);
+ return parser->tok < TOKEN_ERROR;
+}
+
+static bool parse_eol(parser_t *parser)
+{
+ if (!parse_skipwhite(parser))
+ return false;
+ return parser->tok == TOKEN_EOL;
+}
+
+static bool parse_pragma_do(parser_t *parser)
+{
+ if (!parser_next(parser) ||
+ parser->tok != TOKEN_IDENT ||
+ strcmp(parser_tokval(parser), "pragma"))
+ {
+ parseerror(parser, "expected `pragma` keyword after `#`, got `%s`", parser_tokval(parser));
+ return false;
+ }
+ if (!parse_skipwhite(parser) || parser->tok != TOKEN_IDENT) {
+ parseerror(parser, "expected pragma, got `%s`", parser_tokval(parser));
+ return false;
+ }
+
+ if (!strcmp(parser_tokval(parser), "noref")) {
+ if (!parse_skipwhite(parser) || parser->tok != TOKEN_INTCONST) {
+ parseerror(parser, "`noref` pragma requires an argument: 0 or 1");
+ return false;
+ }
+ parser->noref = !!parser_token(parser)->constval.i;
+ if (!parse_eol(parser)) {
+ parseerror(parser, "parse error after `noref` pragma");
+ return false;
+ }
+ }
+ else
+ {
+ parseerror(parser, "unrecognized hash-keyword: `%s`", parser_tokval(parser));
+ return false;
+ }
+
+ return true;
+}
+
+static bool parse_pragma(parser_t *parser)
+{
+ bool rv;
+ parser->lex->flags.preprocessing = true;
+ parser->lex->flags.mergelines = true;
+ rv = parse_pragma_do(parser);
+ if (parser->tok != TOKEN_EOL) {
+ parseerror(parser, "junk after pragma");
+ rv = false;
+ }
+ parser->lex->flags.preprocessing = false;
+ parser->lex->flags.mergelines = false;
+ if (!parser_next(parser)) {
+ parseerror(parser, "parse error after pragma");
+ rv = false;
+ }
+ return rv;
+}
+
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)
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;
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;
}
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;
}
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;
parseerror(parser, "unrecognized keyword `%s`", parser_tokval(parser));
return false;
}
+ else if (parser->tok == '#')
+ {
+ return parse_pragma(parser);
+ }
else if (parser->tok == '$')
{
if (!parser_next(parser)) {
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);
if (!ast_istype(parser->globals[i], ast_value))
continue;
asvalue = (ast_value*)(parser->globals[i]);
- if (asvalue->setter) {
- if (!ast_global_codegen(asvalue->setter, ir, false) ||
- !ast_function_codegen(asvalue->setter->constval.vfunc, ir) ||
- !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func))
- {
- printf("failed to generate setter for %s\n", asvalue->name);
- ir_builder_delete(ir);
- return false;
- }
- }
- if (asvalue->getter) {
- if (!ast_global_codegen(asvalue->getter, ir, false) ||
- !ast_function_codegen(asvalue->getter->constval.vfunc, ir) ||
- !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func))
- {
- printf("failed to generate getter for %s\n", asvalue->name);
- ir_builder_delete(ir);
- return false;
- }
+ if (!ast_generate_accessors(asvalue, ir)) {
+ ir_builder_delete(ir);
+ return false;
}
}
for (i = 0; i < vec_size(parser->fields); ++i) {
continue;
if (asvalue->expression.vtype != TYPE_ARRAY)
continue;
- if (asvalue->setter) {
- if (!ast_global_codegen(asvalue->setter, ir, false) ||
- !ast_function_codegen(asvalue->setter->constval.vfunc, ir) ||
- !ir_function_finalize(asvalue->setter->constval.vfunc->ir_func))
- {
- printf("failed to generate setter for %s\n", asvalue->name);
- ir_builder_delete(ir);
- return false;
- }
- }
- if (asvalue->getter) {
- if (!ast_global_codegen(asvalue->getter, ir, false) ||
- !ast_function_codegen(asvalue->getter->constval.vfunc, ir) ||
- !ir_function_finalize(asvalue->getter->constval.vfunc->ir_func))
- {
- printf("failed to generate getter for %s\n", asvalue->name);
- ir_builder_delete(ir);
- return false;
- }
+ if (!ast_generate_accessors(asvalue, ir)) {
+ ir_builder_delete(ir);
+ return false;
}
}
for (i = 0; i < vec_size(parser->functions); ++i) {
projects / xonotic / gmqcc.git / blobdiff