+static ast_expression* parser_expression(parser_t *parser, bool stopatcomma)
+{
+ ast_expression *e = parser_expression_leave(parser, stopatcomma);
+ if (!e)
+ return NULL;
+ if (!parser_next(parser)) {
+ ast_delete(e);
+ return NULL;
+ }
+ return e;
+}
+
+static bool parser_parse_if(parser_t *parser, ast_block *block, ast_expression **out)
+{
+ ast_ifthen *ifthen;
+ ast_expression *cond, *ontrue, *onfalse = NULL;
+
+ lex_ctx ctx = parser_ctx(parser);
+
+ /* skip the 'if' and check for opening paren */
+ if (!parser_next(parser) || parser->tok != '(') {
+ parseerror(parser, "expected 'if' condition in parenthesis");
+ return false;
+ }
+ /* parse into the expression */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected 'if' condition after opening paren");
+ return false;
+ }
+ /* parse the condition */
+ cond = parser_expression_leave(parser, false);
+ if (!cond)
+ return false;
+ /* closing paren */
+ if (parser->tok != ')') {
+ parseerror(parser, "expected closing paren after 'if' condition");
+ ast_delete(cond);
+ return false;
+ }
+ /* parse into the 'then' branch */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected statement for on-true branch of 'if'");
+ ast_delete(cond);
+ return false;
+ }
+ ontrue = parser_parse_statement_or_block(parser);
+ if (!ontrue) {
+ ast_delete(cond);
+ return false;
+ }
+ /* check for an else */
+ if (!strcmp(parser_tokval(parser), "else")) {
+ /* parse into the 'else' branch */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected on-false branch after 'else'");
+ ast_delete(ontrue);
+ ast_delete(cond);
+ return false;
+ }
+ onfalse = parser_parse_statement_or_block(parser);
+ if (!onfalse) {
+ ast_delete(ontrue);
+ ast_delete(cond);
+ return false;
+ }
+ }
+
+ ifthen = ast_ifthen_new(ctx, cond, ontrue, onfalse);
+ *out = (ast_expression*)ifthen;
+ return true;
+}
+
+static bool parser_parse_while(parser_t *parser, ast_block *block, ast_expression **out)
+{
+ ast_loop *aloop;
+ ast_expression *cond, *ontrue;
+
+ lex_ctx ctx = parser_ctx(parser);
+
+ /* skip the 'while' and check for opening paren */
+ if (!parser_next(parser) || parser->tok != '(') {
+ parseerror(parser, "expected 'while' condition in parenthesis");
+ return false;
+ }
+ /* parse into the expression */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected 'while' condition after opening paren");
+ return false;
+ }
+ /* parse the condition */
+ cond = parser_expression_leave(parser, false);
+ if (!cond)
+ return false;
+ /* closing paren */
+ if (parser->tok != ')') {
+ parseerror(parser, "expected closing paren after 'while' condition");
+ ast_delete(cond);
+ return false;
+ }
+ /* parse into the 'then' branch */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected while-loop body");
+ ast_delete(cond);
+ return false;
+ }
+ ontrue = parser_parse_statement_or_block(parser);
+ if (!ontrue) {
+ ast_delete(cond);
+ return false;
+ }
+
+ aloop = ast_loop_new(ctx, NULL, cond, NULL, NULL, ontrue);
+ *out = (ast_expression*)aloop;
+ return true;
+}
+
+static bool parser_parse_dowhile(parser_t *parser, ast_block *block, ast_expression **out)
+{
+ ast_loop *aloop;
+ ast_expression *cond, *ontrue;
+
+ lex_ctx ctx = parser_ctx(parser);
+
+ /* skip the 'do' and get the body */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected loop body");
+ return false;
+ }
+ ontrue = parser_parse_statement_or_block(parser);
+ if (!ontrue)
+ return false;
+
+ /* expect the "while" */
+ if (parser->tok != TOKEN_KEYWORD ||
+ strcmp(parser_tokval(parser), "while"))
+ {
+ parseerror(parser, "expected 'while' and condition");
+ ast_delete(ontrue);
+ return false;
+ }
+
+ /* skip the 'while' and check for opening paren */
+ if (!parser_next(parser) || parser->tok != '(') {
+ parseerror(parser, "expected 'while' condition in parenthesis");
+ ast_delete(ontrue);
+ return false;
+ }
+ /* parse into the expression */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected 'while' condition after opening paren");
+ ast_delete(ontrue);
+ return false;
+ }
+ /* parse the condition */
+ cond = parser_expression_leave(parser, false);
+ if (!cond)
+ return false;
+ /* closing paren */
+ if (parser->tok != ')') {
+ parseerror(parser, "expected closing paren after 'while' condition");
+ ast_delete(ontrue);
+ ast_delete(cond);
+ return false;
+ }
+ /* parse on */
+ if (!parser_next(parser) || parser->tok != ';') {
+ parseerror(parser, "expected semicolon after condition");
+ ast_delete(ontrue);
+ ast_delete(cond);
+ return false;
+ }
+
+ if (!parser_next(parser)) {
+ parseerror(parser, "parse error");
+ ast_delete(ontrue);
+ ast_delete(cond);
+ return false;
+ }
+
+ aloop = ast_loop_new(ctx, NULL, NULL, cond, NULL, ontrue);
+ *out = (ast_expression*)aloop;
+ return true;
+}
+
+static bool parser_parse_for(parser_t *parser, ast_block *block, ast_expression **out)
+{
+ ast_loop *aloop;
+ ast_expression *initexpr, *cond, *increment, *ontrue;
+ size_t oldblocklocal;
+
+ lex_ctx ctx = parser_ctx(parser);
+
+ oldblocklocal = parser->blocklocal;
+ parser->blocklocal = parser->locals_count;
+
+ initexpr = NULL;
+ cond = NULL;
+ increment = NULL;
+ ontrue = NULL;
+
+ /* skip the 'while' and check for opening paren */
+ if (!parser_next(parser) || parser->tok != '(') {
+ parseerror(parser, "expected 'for' expressions in parenthesis");
+ goto onerr;
+ }
+ /* parse into the expression */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected 'for' initializer after opening paren");
+ goto onerr;
+ }
+
+ if (parser->tok == TOKEN_TYPENAME) {
+ if (opts_standard != COMPILER_GMQCC) {
+ if (parsewarning(parser, WARN_EXTENSIONS,
+ "current standard does not allow variable declarations in for-loop initializers"))
+ goto onerr;
+ }
+
+ parseerror(parser, "TODO: assignment of new variables to be non-const");
+ goto onerr;
+ if (!parser_variable(parser, block))
+ goto onerr;
+ }
+ else if (parser->tok != ';')
+ {
+ initexpr = parser_expression_leave(parser, false);
+ if (!initexpr)
+ goto onerr;
+ }
+
+ /* move on to condition */
+ if (parser->tok != ';') {
+ parseerror(parser, "expected semicolon after for-loop initializer");
+ goto onerr;
+ }
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected for-loop condition");
+ goto onerr;
+ }
+
+ /* parse the condition */
+ if (parser->tok != ';') {
+ cond = parser_expression_leave(parser, false);
+ if (!cond)
+ goto onerr;
+ }
+
+ /* move on to incrementor */
+ if (parser->tok != ';') {
+ parseerror(parser, "expected semicolon after for-loop initializer");
+ goto onerr;
+ }
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected for-loop condition");
+ goto onerr;
+ }
+
+ /* parse the incrementor */
+ if (parser->tok != ')') {
+ increment = parser_expression_leave(parser, false);
+ if (!increment)
+ goto onerr;
+ }
+
+ /* closing paren */
+ if (parser->tok != ')') {
+ parseerror(parser, "expected closing paren after 'for-loop' incrementor");
+ goto onerr;
+ }
+ /* parse into the 'then' branch */
+ if (!parser_next(parser)) {
+ parseerror(parser, "expected for-loop body");
+ goto onerr;
+ }
+ ontrue = parser_parse_statement_or_block(parser);
+ if (!ontrue) {
+ goto onerr;
+ }
+
+ aloop = ast_loop_new(ctx, initexpr, cond, NULL, increment, ontrue);
+ *out = (ast_expression*)aloop;
+
+ while (parser->locals_count > parser->blocklocal)
+ parser_pop_local(parser);
+ parser->blocklocal = oldblocklocal;
+ return true;
+onerr:
+ if (initexpr) ast_delete(initexpr);
+ if (cond) ast_delete(cond);
+ if (increment) ast_delete(increment);
+ while (parser->locals_count > parser->blocklocal)
+ parser_pop_local(parser);
+ parser->blocklocal = oldblocklocal;
+ return false;
+}
+
+static bool parser_parse_statement(parser_t *parser, ast_block *block, ast_expression **out)