/* 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, (opts_werror ? "error" : "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, (opts_werror ? "error" : "warning"), fmt, ap);
+ r = vcompile_warning(ctx, warntype, fmt, ap);
va_end(ap);
-
- return opts_werror;
+ return r;
}
/**********************************************************************
{
#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"
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"
}
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");
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) {
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 (!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");
}
else
{
- parseerror(parser, "unrecognized hash-keyword: `%s`", parser_tokval(parser));
+ (void)!parsewarning(parser, WARN_UNKNOWN_PRAGMAS, "ignoring #pragma %s", parser_tokval(parser));
return false;
}
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;
}
}
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 (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;
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");
/* 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) {
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)
{
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);