+++ /dev/null
-/* ------------------------------------------------------------------------- */
-/* "states" : Statement translator */
-/* */
-/* Copyright (c) Graham Nelson 1993 - 2018 */
-/* */
-/* This file is part of Inform. */
-/* */
-/* Inform is free software: you can redistribute it and/or modify */
-/* it under the terms of the GNU General Public License as published by */
-/* the Free Software Foundation, either version 3 of the License, or */
-/* (at your option) any later version. */
-/* */
-/* Inform is distributed in the hope that it will be useful, */
-/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
-/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
-/* GNU General Public License for more details. */
-/* */
-/* You should have received a copy of the GNU General Public License */
-/* along with Inform. If not, see https://gnu.org/licenses/ */
-/* */
-/* ------------------------------------------------------------------------- */
-
-#include "header.h"
-
-static int match_colon(void)
-{ get_next_token();
- if (token_type == SEP_TT)
- { if (token_value == SEMICOLON_SEP)
- warning("Unlike C, Inform uses ':' to divide parts \
-of a 'for' loop specification: replacing ';' with ':'");
- else
- if (token_value != COLON_SEP)
- { ebf_error("':'", token_text);
- panic_mode_error_recovery();
- return(FALSE);
- }
- }
- else
- { ebf_error("':'", token_text);
- panic_mode_error_recovery();
- return(FALSE);
- }
- return(TRUE);
-}
-
-static void match_open_bracket(void)
-{ get_next_token();
- if ((token_type == SEP_TT) && (token_value == OPENB_SEP)) return;
- put_token_back();
- ebf_error("'('", token_text);
-}
-
-extern void match_close_bracket(void)
-{ get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP)) return;
- put_token_back();
- ebf_error("')'", token_text);
-}
-
-static void parse_action(void)
-{ int level = 1, args = 0, codegen_action;
- assembly_operand AO, AO2, AO3, AO4, AO5;
-
- /* An action statement has the form <ACTION NOUN SECOND, ACTOR>
- or <<ACTION NOUN SECOND, ACTOR>>. It simply compiles into a call
- to R_Process() with those four arguments. (The latter form,
- with double brackets, means "return true afterwards".)
-
- The R_Process() function should be supplied by the library,
- although a stub is defined in the veneer.
-
- The NOUN, SECOND, and ACTOR arguments are optional. If not
- supplied, R_Process() will be called with fewer arguments.
- (But if you supply ACTOR, it must be preceded by a comma.
- <ACTION, ACTOR> is equivalent to <ACTION 0 0, ACTOR>.)
-
- To complicate life, the ACTION argument may be a bare action
- name or a parenthesized expression. (So <Take> is equivalent
- to <(##Take)>.) We have to peek at the first token, checking
- whether it's an open-paren, to distinguish these cases.
-
- You may ask why the ACTOR argument is last; the "natural"
- Inform ordering would be "<floyd, take ball>". True! Sadly,
- Inform's lexer isn't smart enough to parse this consistently,
- so we can't do it.
- */
-
- dont_enter_into_symbol_table = TRUE;
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == LESS_SEP))
- { level = 2; get_next_token();
- }
- dont_enter_into_symbol_table = FALSE;
-
- /* Peek at the next token; see if it's an open-paren. */
- if ((token_type==SEP_TT) && (token_value==OPENB_SEP))
- { put_token_back();
- AO2 = parse_expression(ACTION_Q_CONTEXT);
- codegen_action = TRUE;
- }
- else
- { codegen_action = FALSE;
- AO2 = action_of_name(token_text);
- }
-
- get_next_token();
- AO3 = zero_operand;
- AO4 = zero_operand;
- AO5 = zero_operand;
- if (!((token_type == SEP_TT) && (token_value == GREATER_SEP || token_value == COMMA_SEP)))
- { put_token_back();
- args = 1;
- AO3 = parse_expression(ACTION_Q_CONTEXT);
-
- get_next_token();
- }
- if (!((token_type == SEP_TT) && (token_value == GREATER_SEP || token_value == COMMA_SEP)))
- { put_token_back();
- args = 2;
- AO4 = parse_expression(QUANTITY_CONTEXT);
- get_next_token();
- }
- if (!((token_type == SEP_TT) && (token_value == GREATER_SEP || token_value == COMMA_SEP)))
- {
- ebf_error("',' or '>'", token_text);
- }
-
- if ((token_type == SEP_TT) && (token_value == COMMA_SEP))
- {
- if (!glulx_mode && (version_number < 4))
- {
- error("<x, y> syntax is not available in Z-code V3 or earlier");
- }
- args = 3;
- AO5 = parse_expression(QUANTITY_CONTEXT);
- get_next_token();
- if (!((token_type == SEP_TT) && (token_value == GREATER_SEP)))
- {
- ebf_error("'>'", token_text);
- }
- }
-
- if (level == 2)
- { get_next_token();
- if (!((token_type == SEP_TT) && (token_value == GREATER_SEP)))
- { put_token_back();
- ebf_error("'>>'", token_text);
- }
- }
-
- if (!glulx_mode) {
-
- AO = veneer_routine(R_Process_VR);
-
- switch(args)
- { case 0:
- if (codegen_action) AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- if (version_number>=5)
- assemblez_2(call_2n_zc, AO, AO2);
- else
- if (version_number==4)
- assemblez_2_to(call_vs_zc, AO, AO2, temp_var1);
- else
- assemblez_2_to(call_zc, AO, AO2, temp_var1);
- break;
- case 1:
- AO3 = code_generate(AO3, QUANTITY_CONTEXT, -1);
- if (codegen_action) AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- if (version_number>=5)
- assemblez_3(call_vn_zc, AO, AO2, AO3);
- else
- if (version_number==4)
- assemblez_3_to(call_vs_zc, AO, AO2, AO3, temp_var1);
- else
- assemblez_3_to(call_zc, AO, AO2, AO3, temp_var1);
- break;
- case 2:
- AO4 = code_generate(AO4, QUANTITY_CONTEXT, -1);
- AO3 = code_generate(AO3, QUANTITY_CONTEXT, -1);
- if (codegen_action) AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- if (version_number>=5)
- assemblez_4(call_vn_zc, AO, AO2, AO3, AO4);
- else
- if (version_number==4)
- assemblez_4_to(call_vs_zc, AO, AO2, AO3, AO4, temp_var1);
- else
- assemblez_4(call_zc, AO, AO2, AO3, AO4);
- break;
- case 3:
- AO5 = code_generate(AO5, QUANTITY_CONTEXT, -1);
- AO4 = code_generate(AO4, QUANTITY_CONTEXT, -1);
- AO3 = code_generate(AO3, QUANTITY_CONTEXT, -1);
- if (codegen_action) AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- if (version_number>=5)
- assemblez_5(call_vn2_zc, AO, AO2, AO3, AO4, AO5);
- else
- if (version_number==4)
- assemblez_5_to(call_vs2_zc, AO, AO2, AO3, AO4, AO5, temp_var1);
- /* if V3 or earlier, we've already displayed an error */
- break;
- break;
- }
-
- if (level == 2) assemblez_0(rtrue_zc);
-
- }
- else {
-
- AO = veneer_routine(R_Process_VR);
-
- switch (args) {
-
- case 0:
- if (codegen_action)
- AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- assembleg_call_1(AO, AO2, zero_operand);
- break;
-
- case 1:
- AO3 = code_generate(AO3, QUANTITY_CONTEXT, -1);
- if (codegen_action)
- AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- assembleg_call_2(AO, AO2, AO3, zero_operand);
- break;
-
- case 2:
- AO4 = code_generate(AO4, QUANTITY_CONTEXT, -1);
- AO3 = code_generate(AO3, QUANTITY_CONTEXT, -1);
- if (codegen_action)
- AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- assembleg_call_3(AO, AO2, AO3, AO4, zero_operand);
- break;
-
- case 3:
- AO5 = code_generate(AO5, QUANTITY_CONTEXT, -1);
- if (!((AO5.type == LOCALVAR_OT) && (AO5.value == 0)))
- assembleg_store(stack_pointer, AO5);
- AO4 = code_generate(AO4, QUANTITY_CONTEXT, -1);
- if (!((AO4.type == LOCALVAR_OT) && (AO4.value == 0)))
- assembleg_store(stack_pointer, AO4);
- AO3 = code_generate(AO3, QUANTITY_CONTEXT, -1);
- if (!((AO3.type == LOCALVAR_OT) && (AO3.value == 0)))
- assembleg_store(stack_pointer, AO3);
- if (codegen_action)
- AO2 = code_generate(AO2, QUANTITY_CONTEXT, -1);
- if (!((AO2.type == LOCALVAR_OT) && (AO2.value == 0)))
- assembleg_store(stack_pointer, AO2);
- assembleg_3(call_gc, AO, four_operand, zero_operand);
- break;
- }
-
- if (level == 2)
- assembleg_1(return_gc, one_operand);
-
- }
-}
-
-extern int parse_label(void)
-{
- get_next_token();
-
- if ((token_type == SYMBOL_TT) &&
- (stypes[token_value] == LABEL_T))
- { sflags[token_value] |= USED_SFLAG;
- return(svals[token_value]);
- }
-
- if ((token_type == SYMBOL_TT) && (sflags[token_value] & UNKNOWN_SFLAG))
- { assign_symbol(token_value, next_label, LABEL_T);
- define_symbol_label(token_value);
- next_label++;
- sflags[token_value] |= CHANGE_SFLAG + USED_SFLAG;
- return(svals[token_value]);
- }
-
- ebf_error("label name", token_text);
- return 0;
-}
-
-static void parse_print_z(int finally_return)
-{ int count = 0; assembly_operand AO;
-
- /* print <printlist> -------------------------------------------------- */
- /* print_ret <printlist> ---------------------------------------------- */
- /* <literal-string> --------------------------------------------------- */
- /* */
- /* <printlist> is a comma-separated list of items: */
- /* */
- /* <literal-string> */
- /* <other-expression> */
- /* (char) <expression> */
- /* (address) <expression> */
- /* (string) <expression> */
- /* (a) <expression> */
- /* (the) <expression> */
- /* (The) <expression> */
- /* (name) <expression> */
- /* (number) <expression> */
- /* (property) <expression> */
- /* (<routine>) <expression> */
- /* (object) <expression> (for use in low-level code only) */
- /* --------------------------------------------------------------------- */
-
- do
- { AI.text = token_text;
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) break;
- switch(token_type)
- { case DQ_TT:
- if (strlen(token_text) > 32)
- { INITAOT(&AO, LONG_CONSTANT_OT);
- AO.marker = STRING_MV;
- AO.value = compile_string(token_text, FALSE, FALSE);
- assemblez_1(print_paddr_zc, AO);
- if (finally_return)
- { get_next_token();
- if ((token_type == SEP_TT)
- && (token_value == SEMICOLON_SEP))
- { assemblez_0(new_line_zc);
- assemblez_0(rtrue_zc);
- return;
- }
- put_token_back();
- }
- break;
- }
- if (finally_return)
- { get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP))
- { assemblez_0(print_ret_zc); return;
- }
- put_token_back();
- }
- assemblez_0(print_zc);
- break;
-
- case SEP_TT:
- if (token_value == OPENB_SEP)
- { misc_keywords.enabled = TRUE;
- get_next_token();
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP))
- { assembly_operand AO1;
-
- put_token_back(); put_token_back();
- local_variables.enabled = FALSE;
- get_next_token();
- misc_keywords.enabled = FALSE;
- local_variables.enabled = TRUE;
-
- if ((token_type == STATEMENT_TT)
- &&(token_value == STRING_CODE))
- { token_type = MISC_KEYWORD_TT;
- token_value = STRING_MK;
- }
-
- switch(token_type)
- {
- case MISC_KEYWORD_TT:
- switch(token_value)
- { case CHAR_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintC_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- assemblez_1(print_char_zc, AO1);
- goto PrintTermDone;
- case ADDRESS_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintA_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- assemblez_1(print_addr_zc, AO1);
- goto PrintTermDone;
- case STRING_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintS_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- assemblez_1(print_paddr_zc, AO1);
- goto PrintTermDone;
- case OBJECT_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintO_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- assemblez_1(print_obj_zc, AO1);
- goto PrintTermDone;
- case THE_MK:
- AO = veneer_routine(DefArt_VR);
- goto PrintByRoutine;
- case AN_MK:
- case A_MK:
- AO = veneer_routine(InDefArt_VR);
- goto PrintByRoutine;
- case CAP_THE_MK:
- AO = veneer_routine(CDefArt_VR);
- goto PrintByRoutine;
- case CAP_A_MK:
- AO = veneer_routine(CInDefArt_VR);
- goto PrintByRoutine;
- case NAME_MK:
- AO = veneer_routine(PrintShortName_VR);
- goto PrintByRoutine;
- case NUMBER_MK:
- AO = veneer_routine(EnglishNumber_VR);
- goto PrintByRoutine;
- case PROPERTY_MK:
- AO = veneer_routine(Print__Pname_VR);
- goto PrintByRoutine;
- default:
- error_named("A reserved word was used as a print specification:",
- token_text);
- }
- break;
-
- case SYMBOL_TT:
- if (sflags[token_value] & UNKNOWN_SFLAG)
- { INITAOT(&AO, LONG_CONSTANT_OT);
- AO.value = token_value;
- AO.marker = SYMBOL_MV;
- }
- else
- { INITAOT(&AO, LONG_CONSTANT_OT);
- AO.value = svals[token_value];
- AO.marker = IROUTINE_MV;
- if (stypes[token_value] != ROUTINE_T)
- ebf_error("printing routine name", token_text);
- }
- sflags[token_value] |= USED_SFLAG;
-
- PrintByRoutine:
-
- get_next_token();
- if (version_number >= 5)
- assemblez_2(call_2n_zc, AO,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- else if (version_number == 4)
- assemblez_2_to(call_vs_zc, AO,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1), temp_var1);
- else
- assemblez_2_to(call_zc, AO,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1), temp_var1);
- goto PrintTermDone;
-
- default: ebf_error("print specification", token_text);
- get_next_token();
- assemblez_1(print_num_zc,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- goto PrintTermDone;
- }
- }
- put_token_back(); put_token_back(); put_token_back();
- misc_keywords.enabled = FALSE;
- assemblez_1(print_num_zc,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- break;
- }
-
- default:
- put_token_back(); misc_keywords.enabled = FALSE;
- assemblez_1(print_num_zc,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- break;
- }
-
- PrintTermDone: misc_keywords.enabled = FALSE;
-
- count++;
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) break;
- if ((token_type != SEP_TT) || (token_value != COMMA_SEP))
- { ebf_error("comma", token_text);
- panic_mode_error_recovery(); return;
- }
- else get_next_token();
- } while(TRUE);
-
- if (count == 0) ebf_error("something to print", token_text);
- if (finally_return)
- { assemblez_0(new_line_zc);
- assemblez_0(rtrue_zc);
- }
-}
-
-static void parse_print_g(int finally_return)
-{ int count = 0; assembly_operand AO, AO2;
-
- /* print <printlist> -------------------------------------------------- */
- /* print_ret <printlist> ---------------------------------------------- */
- /* <literal-string> --------------------------------------------------- */
- /* */
- /* <printlist> is a comma-separated list of items: */
- /* */
- /* <literal-string> */
- /* <other-expression> */
- /* (char) <expression> */
- /* (address) <expression> */
- /* (string) <expression> */
- /* (a) <expression> */
- /* (A) <expression> */
- /* (the) <expression> */
- /* (The) <expression> */
- /* (name) <expression> */
- /* (number) <expression> */
- /* (property) <expression> */
- /* (<routine>) <expression> */
- /* (object) <expression> (for use in low-level code only) */
- /* --------------------------------------------------------------------- */
-
- do
- {
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) break;
- switch(token_type)
- { case DQ_TT:
- /* We can't compile a string into the instruction,
- so this always goes into the string area. */
- { INITAOT(&AO, CONSTANT_OT);
- AO.marker = STRING_MV;
- AO.value = compile_string(token_text, FALSE, FALSE);
- assembleg_1(streamstr_gc, AO);
- if (finally_return)
- { get_next_token();
- if ((token_type == SEP_TT)
- && (token_value == SEMICOLON_SEP))
- { INITAOTV(&AO, BYTECONSTANT_OT, 0x0A);
- assembleg_1(streamchar_gc, AO);
- INITAOTV(&AO, BYTECONSTANT_OT, 1);
- assembleg_1(return_gc, AO);
- return;
- }
- put_token_back();
- }
- break;
- }
- break;
-
- case SEP_TT:
- if (token_value == OPENB_SEP)
- { misc_keywords.enabled = TRUE;
- get_next_token();
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP))
- { assembly_operand AO1;
- int ln, ln2;
-
- put_token_back(); put_token_back();
- local_variables.enabled = FALSE;
- get_next_token();
- misc_keywords.enabled = FALSE;
- local_variables.enabled = TRUE;
-
- if ((token_type == STATEMENT_TT)
- &&(token_value == STRING_CODE))
- { token_type = MISC_KEYWORD_TT;
- token_value = STRING_MK;
- }
-
- switch(token_type)
- {
- case MISC_KEYWORD_TT:
- switch(token_value)
- { case CHAR_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintC_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if ((AO1.type == LOCALVAR_OT) && (AO1.value == 0))
- { assembleg_2(stkpeek_gc, zero_operand,
- stack_pointer);
- }
- INITAOTV(&AO2, HALFCONSTANT_OT, 0x100);
- assembleg_2_branch(jgeu_gc, AO1, AO2,
- ln = next_label++);
- ln2 = next_label++;
- assembleg_1(streamchar_gc, AO1);
- assembleg_jump(ln2);
- assemble_label_no(ln);
- assembleg_1(streamunichar_gc, AO1);
- assemble_label_no(ln2);
- goto PrintTermDone;
- case ADDRESS_MK:
- if (runtime_error_checking_switch)
- AO = veneer_routine(RT__ChPrintA_VR);
- else
- AO = veneer_routine(Print__Addr_VR);
- goto PrintByRoutine;
- case STRING_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintS_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- assembleg_1(streamstr_gc, AO1);
- goto PrintTermDone;
- case OBJECT_MK:
- if (runtime_error_checking_switch)
- { AO = veneer_routine(RT__ChPrintO_VR);
- goto PrintByRoutine;
- }
- get_next_token();
- AO1 = code_generate(
- parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- INITAOT(&AO2, BYTECONSTANT_OT);
- AO2.value = GOBJFIELD_NAME();
- assembleg_3(aload_gc, AO1, AO2,
- stack_pointer);
- assembleg_1(streamstr_gc, stack_pointer);
- goto PrintTermDone;
- case THE_MK:
- AO = veneer_routine(DefArt_VR);
- goto PrintByRoutine;
- case AN_MK:
- case A_MK:
- AO = veneer_routine(InDefArt_VR);
- goto PrintByRoutine;
- case CAP_THE_MK:
- AO = veneer_routine(CDefArt_VR);
- goto PrintByRoutine;
- case CAP_A_MK:
- AO = veneer_routine(CInDefArt_VR);
- goto PrintByRoutine;
- case NAME_MK:
- AO = veneer_routine(PrintShortName_VR);
- goto PrintByRoutine;
- case NUMBER_MK:
- AO = veneer_routine(EnglishNumber_VR);
- goto PrintByRoutine;
- case PROPERTY_MK:
- AO = veneer_routine(Print__Pname_VR);
- goto PrintByRoutine;
- default:
- error_named("A reserved word was used as a print specification:",
- token_text);
- }
- break;
-
- case SYMBOL_TT:
- if (sflags[token_value] & UNKNOWN_SFLAG)
- { INITAOT(&AO, CONSTANT_OT);
- AO.value = token_value;
- AO.marker = SYMBOL_MV;
- }
- else
- { INITAOT(&AO, CONSTANT_OT);
- AO.value = svals[token_value];
- AO.marker = IROUTINE_MV;
- if (stypes[token_value] != ROUTINE_T)
- ebf_error("printing routine name", token_text);
- }
- sflags[token_value] |= USED_SFLAG;
-
- PrintByRoutine:
-
- get_next_token();
- INITAOT(&AO2, ZEROCONSTANT_OT);
- assembleg_call_1(AO,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1),
- AO2);
- goto PrintTermDone;
-
- default: ebf_error("print specification", token_text);
- get_next_token();
- assembleg_1(streamnum_gc,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- goto PrintTermDone;
- }
- }
- put_token_back(); put_token_back(); put_token_back();
- misc_keywords.enabled = FALSE;
- assembleg_1(streamnum_gc,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- break;
- }
-
- default:
- put_token_back(); misc_keywords.enabled = FALSE;
- assembleg_1(streamnum_gc,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- break;
- }
-
- PrintTermDone: misc_keywords.enabled = FALSE;
-
- count++;
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) break;
- if ((token_type != SEP_TT) || (token_value != COMMA_SEP))
- { ebf_error("comma", token_text);
- panic_mode_error_recovery(); return;
- }
- else get_next_token();
- } while(TRUE);
-
- if (count == 0) ebf_error("something to print", token_text);
- if (finally_return)
- {
- INITAOTV(&AO, BYTECONSTANT_OT, 0x0A);
- assembleg_1(streamchar_gc, AO);
- INITAOTV(&AO, BYTECONSTANT_OT, 1);
- assembleg_1(return_gc, AO);
- }
-}
-
-static void parse_statement_z(int break_label, int continue_label)
-{ int ln, ln2, ln3, ln4, flag;
- assembly_operand AO, AO2, AO3, AO4;
- debug_location spare_debug_location1, spare_debug_location2;
-
- ASSERT_ZCODE();
-
- if ((token_type == SEP_TT) && (token_value == PROPERTY_SEP))
- { /* That is, a full stop, signifying a label */
-
- get_next_token();
- if (token_type == SYMBOL_TT)
- {
- if (sflags[token_value] & UNKNOWN_SFLAG)
- { assign_symbol(token_value, next_label, LABEL_T);
- sflags[token_value] |= USED_SFLAG;
- assemble_label_no(next_label);
- define_symbol_label(token_value);
- next_label++;
- }
- else
- { if (stypes[token_value] != LABEL_T) goto LabelError;
- if (sflags[token_value] & CHANGE_SFLAG)
- { sflags[token_value] &= (~(CHANGE_SFLAG));
- assemble_label_no(svals[token_value]);
- define_symbol_label(token_value);
- }
- else error_named("Duplicate definition of label:", token_text);
- }
-
- get_next_token();
- if ((token_type != SEP_TT) || (token_value != SEMICOLON_SEP))
- { ebf_error("';'", token_text);
- put_token_back(); return;
- }
-
- /* Interesting point of Inform grammar: a statement can only
- consist solely of a label when it is immediately followed
- by a "}". */
-
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSE_BRACE_SEP))
- { put_token_back(); return;
- }
- statement_debug_location = get_token_location();
- parse_statement(break_label, continue_label);
- return;
- }
- LabelError: ebf_error("label name", token_text);
- }
-
- if ((token_type == SEP_TT) && (token_value == HASH_SEP))
- { parse_directive(TRUE);
- parse_statement(break_label, continue_label); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == AT_SEP))
- { parse_assembly(); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) return;
-
- if (token_type == DQ_TT)
- { parse_print_z(TRUE); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == LESS_SEP))
- { parse_action(); goto StatementTerminator; }
-
- if (token_type == EOF_TT)
- { ebf_error("statement", token_text); return; }
-
- if (token_type != STATEMENT_TT)
- { put_token_back();
- AO = parse_expression(VOID_CONTEXT);
- code_generate(AO, VOID_CONTEXT, -1);
- if (vivc_flag) { panic_mode_error_recovery(); return; }
- goto StatementTerminator;
- }
-
- statements.enabled = FALSE;
-
- switch(token_value)
- {
- /* -------------------------------------------------------------------- */
- /* box <string-1> ... <string-n> -------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case BOX_CODE:
- if (version_number == 3)
- warning("The 'box' statement has no effect in a version 3 game");
- INITAOT(&AO3, LONG_CONSTANT_OT);
- AO3.value = begin_table_array();
- AO3.marker = ARRAY_MV;
- ln = 0; ln2 = 0;
- do
- { get_next_token();
- if ((token_type==SEP_TT)&&(token_value==SEMICOLON_SEP))
- break;
- if (token_type != DQ_TT)
- ebf_error("text of box line in double-quotes",
- token_text);
- { int i, j;
- for (i=0, j=0; token_text[i] != 0; j++)
- if (token_text[i] == '@')
- { if (token_text[i+1] == '@')
- { i = i + 2;
- while (isdigit(token_text[i])) i++;
- }
- else
- { i++;
- if (token_text[i] != 0) i++;
- if (token_text[i] != 0) i++;
- }
- }
- else i++;
- if (j > ln2) ln2 = j;
- }
- put_token_back();
- array_entry(ln++,parse_expression(CONSTANT_CONTEXT));
- } while (TRUE);
- finish_array(ln);
- if (ln == 0)
- error("No lines of text given for 'box' display");
-
- if (version_number == 3) return;
-
- INITAOTV(&AO2, SHORT_CONSTANT_OT, ln2);
- INITAOTV(&AO4, VARIABLE_OT, 255);
- assemblez_3_to(call_vs_zc, veneer_routine(Box__Routine_VR),
- AO2, AO3, AO4);
- return;
-
- /* -------------------------------------------------------------------- */
- /* break -------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case BREAK_CODE:
- if (break_label == -1)
- error("'break' can only be used in a loop or 'switch' block");
- else
- assemblez_jump(break_label);
- break;
-
- /* -------------------------------------------------------------------- */
- /* continue ----------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case CONTINUE_CODE:
- if (continue_label == -1)
- error("'continue' can only be used in a loop block");
- else
- assemblez_jump(continue_label);
- break;
-
- /* -------------------------------------------------------------------- */
- /* do <codeblock> until (<condition>) --------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case DO_CODE:
- assemble_label_no(ln = next_label++);
- ln2 = next_label++; ln3 = next_label++;
- parse_code_block(ln3, ln2, 0);
- statements.enabled = TRUE;
- get_next_token();
- if ((token_type == STATEMENT_TT)
- && (token_value == UNTIL_CODE))
- { assemble_label_no(ln2);
- match_open_bracket();
- AO = parse_expression(CONDITION_CONTEXT);
- match_close_bracket();
- code_generate(AO, CONDITION_CONTEXT, ln);
- }
- else error("'do' without matching 'until'");
-
- assemble_label_no(ln3);
- break;
-
- /* -------------------------------------------------------------------- */
- /* font on/off -------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case FONT_CODE:
- misc_keywords.enabled = TRUE;
- get_next_token();
- misc_keywords.enabled = FALSE;
- if ((token_type != MISC_KEYWORD_TT)
- || ((token_value != ON_MK)
- && (token_value != OFF_MK)))
- { ebf_error("'on' or 'off'", token_text);
- panic_mode_error_recovery();
- break;
- }
-
- if (version_number >= 5)
- { /* Use the V5 @set_font opcode, setting font 4
- (for font off) or 1 (for font on). */
- INITAOT(&AO, SHORT_CONSTANT_OT);
- if (token_value == ON_MK)
- AO.value = 1;
- else
- AO.value = 4;
- assemblez_1_to(set_font_zc, AO, temp_var1);
- break;
- }
-
- /* Set the fixed-pitch header bit. */
- INITAOTV(&AO, SHORT_CONSTANT_OT, 0);
- INITAOTV(&AO2, SHORT_CONSTANT_OT, 8);
- INITAOTV(&AO3, VARIABLE_OT, 255);
- assemblez_2_to(loadw_zc, AO, AO2, AO3);
-
- if (token_value == ON_MK)
- { INITAOTV(&AO4, LONG_CONSTANT_OT, 0xfffd);
- assemblez_2_to(and_zc, AO4, AO3, AO3);
- }
- else
- { INITAOTV(&AO4, SHORT_CONSTANT_OT, 2);
- assemblez_2_to(or_zc, AO4, AO3, AO3);
- }
-
- assemblez_3(storew_zc, AO, AO2, AO3);
- break;
-
- /* -------------------------------------------------------------------- */
- /* for (<initialisation> : <continue-condition> : <updating>) --------- */
- /* -------------------------------------------------------------------- */
-
- /* Note that it's legal for any or all of the three sections of a
- 'for' specification to be empty. This 'for' implementation
- often wastes 3 bytes with a redundant branch rather than keep
- expression parse trees for long periods (as previous versions
- of Inform did, somewhat crudely by simply storing the textual
- form of a 'for' loop). It is adequate for now. */
-
- case FOR_CODE:
- match_open_bracket();
- get_next_token();
-
- /* Initialisation code */
-
- if (!((token_type==SEP_TT)&&(token_value==COLON_SEP)))
- { put_token_back();
- if (!((token_type==SEP_TT)&&(token_value==SUPERCLASS_SEP)))
- { sequence_point_follows = TRUE;
- statement_debug_location = get_token_location();
- code_generate(parse_expression(FORINIT_CONTEXT),
- VOID_CONTEXT, -1);
- }
- get_next_token();
- if ((token_type==SEP_TT)&&(token_value == SUPERCLASS_SEP))
- { get_next_token();
- if ((token_type==SEP_TT)&&(token_value == CLOSEB_SEP))
- { assemble_label_no(ln = next_label++);
- ln2 = next_label++;
- parse_code_block(ln2, ln, 0);
- sequence_point_follows = FALSE;
- if (!execution_never_reaches_here)
- assemblez_jump(ln);
- assemble_label_no(ln2);
- return;
- }
- AO.type = OMITTED_OT;
- goto ParseUpdate;
- }
- put_token_back();
- if (!match_colon()) break;
- }
-
- get_next_token();
- AO.type = OMITTED_OT;
- if (!((token_type==SEP_TT)&&(token_value==COLON_SEP)))
- { put_token_back();
- spare_debug_location1 = get_token_location();
- AO = parse_expression(CONDITION_CONTEXT);
- if (!match_colon()) break;
- }
- get_next_token();
-
- ParseUpdate:
- AO2.type = OMITTED_OT; flag = 0;
- if (!((token_type==SEP_TT)&&(token_value==CLOSEB_SEP)))
- { put_token_back();
- spare_debug_location2 = get_token_location();
- AO2 = parse_expression(VOID_CONTEXT);
- match_close_bracket();
- flag = test_for_incdec(AO2);
- }
-
- ln = next_label++;
- ln2 = next_label++;
- ln3 = next_label++;
-
- if ((AO2.type == OMITTED_OT) || (flag != 0))
- {
- assemble_label_no(ln);
- if (flag==0) assemble_label_no(ln2);
-
- /* The "finished yet?" condition */
-
- if (AO.type != OMITTED_OT)
- { sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location1;
- code_generate(AO, CONDITION_CONTEXT, ln3);
- }
-
- }
- else
- {
- /* This is the jump which could be avoided with the aid
- of long-term expression storage */
-
- sequence_point_follows = FALSE;
- assemblez_jump(ln2);
-
- /* The "update" part */
-
- assemble_label_no(ln);
- sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location2;
- code_generate(AO2, VOID_CONTEXT, -1);
-
- assemble_label_no(ln2);
-
- /* The "finished yet?" condition */
-
- if (AO.type != OMITTED_OT)
- { sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location1;
- code_generate(AO, CONDITION_CONTEXT, ln3);
- }
- }
-
- if (flag != 0)
- {
- /* In this optimised case, update code is at the end
- of the loop block, so "continue" goes there */
-
- parse_code_block(ln3, ln2, 0);
- assemble_label_no(ln2);
-
- sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location2;
- if (flag > 0)
- { INITAOTV(&AO3, SHORT_CONSTANT_OT, flag);
- if (module_switch
- && (flag>=MAX_LOCAL_VARIABLES) && (flag<LOWEST_SYSTEM_VAR_NUMBER))
- AO3.marker = VARIABLE_MV;
- assemblez_1(inc_zc, AO3);
- }
- else
- { INITAOTV(&AO3, SHORT_CONSTANT_OT, -flag);
- if ((module_switch) && (flag>=MAX_LOCAL_VARIABLES)
- && (flag<LOWEST_SYSTEM_VAR_NUMBER))
- AO3.marker = VARIABLE_MV;
- assemblez_1(dec_zc, AO3);
- }
- assemblez_jump(ln);
- }
- else
- {
- /* In the unoptimised case, update code is at the
- start of the loop block, so "continue" goes there */
-
- parse_code_block(ln3, ln, 0);
- if (!execution_never_reaches_here)
- { sequence_point_follows = FALSE;
- assemblez_jump(ln);
- }
- }
-
- assemble_label_no(ln3);
- return;
-
- /* -------------------------------------------------------------------- */
- /* give <expression> [~]attr [, [~]attr [, ...]] ---------------------- */
- /* -------------------------------------------------------------------- */
-
- case GIVE_CODE:
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if ((AO.type == VARIABLE_OT) && (AO.value == 0))
- { INITAOTV(&AO, SHORT_CONSTANT_OT, 252);
- if (version_number != 6) assemblez_1(pull_zc, AO);
- else assemblez_0_to(pull_zc, AO);
- AO.type = VARIABLE_OT;
- }
-
- do
- { get_next_token();
- if ((token_type == SEP_TT)&&(token_value == SEMICOLON_SEP))
- return;
- if ((token_type == SEP_TT)&&(token_value == ARTNOT_SEP))
- ln = clear_attr_zc;
- else
- { if ((token_type == SYMBOL_TT)
- && (stypes[token_value] != ATTRIBUTE_T))
- warning_named("This is not a declared Attribute:",
- token_text);
- ln = set_attr_zc;
- put_token_back();
- }
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if (runtime_error_checking_switch)
- { ln2 = (ln==set_attr_zc)?RT__ChG_VR:RT__ChGt_VR;
- if (version_number >= 5)
- assemblez_3(call_vn_zc, veneer_routine(ln2),
- AO, AO2);
- else
- {
- assemblez_3_to(call_zc, veneer_routine(ln2),
- AO, AO2, temp_var1);
- }
- }
- else
- assemblez_2(ln, AO, AO2);
- } while(TRUE);
-
- /* -------------------------------------------------------------------- */
- /* if (<condition>) <codeblock> [else <codeblock>] -------------------- */
- /* -------------------------------------------------------------------- */
-
- case IF_CODE:
- flag = FALSE;
- ln2 = 0;
-
- match_open_bracket();
- AO = parse_expression(CONDITION_CONTEXT);
- match_close_bracket();
-
- statements.enabled = TRUE;
- get_next_token();
- if ((token_type == STATEMENT_TT)&&(token_value == RTRUE_CODE))
- ln = -4;
- else
- if ((token_type == STATEMENT_TT)&&(token_value == RFALSE_CODE))
- ln = -3;
- else
- { put_token_back();
- ln = next_label++;
- }
-
- code_generate(AO, CONDITION_CONTEXT, ln);
-
- if (ln >= 0) parse_code_block(break_label, continue_label, 0);
- else
- { get_next_token();
- if ((token_type != SEP_TT)
- || (token_value != SEMICOLON_SEP))
- { ebf_error("';'", token_text);
- put_token_back();
- }
- }
-
- statements.enabled = TRUE;
- get_next_token();
- if ((token_type == STATEMENT_TT) && (token_value == ELSE_CODE))
- { flag = TRUE;
- if (ln >= 0)
- { ln2 = next_label++;
- if (!execution_never_reaches_here)
- { sequence_point_follows = FALSE;
- assemblez_jump(ln2);
- }
- }
- }
- else put_token_back();
-
- if (ln >= 0) assemble_label_no(ln);
-
- if (flag)
- { parse_code_block(break_label, continue_label, 0);
- if (ln >= 0) assemble_label_no(ln2);
- }
-
- return;
-
- /* -------------------------------------------------------------------- */
- /* inversion ---------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case INVERSION_CODE:
- INITAOTV(&AO, SHORT_CONSTANT_OT, 0);
- INITAOT(&AO2, SHORT_CONSTANT_OT);
-
- AO2.value = 60;
- assemblez_2_to(loadb_zc, AO, AO2, temp_var1);
- assemblez_1(print_char_zc, temp_var1);
- AO2.value = 61;
- assemblez_2_to(loadb_zc, AO, AO2, temp_var1);
- assemblez_1(print_char_zc, temp_var1);
- AO2.value = 62;
- assemblez_2_to(loadb_zc, AO, AO2, temp_var1);
- assemblez_1(print_char_zc, temp_var1);
- AO2.value = 63;
- assemblez_2_to(loadb_zc, AO, AO2, temp_var1);
- assemblez_1(print_char_zc, temp_var1);
- break;
-
- /* -------------------------------------------------------------------- */
- /* jump <label> ------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case JUMP_CODE:
- assemblez_jump(parse_label());
- break;
-
- /* -------------------------------------------------------------------- */
- /* move <expression> to <expression> ---------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case MOVE_CODE:
- misc_keywords.enabled = TRUE;
- AO = parse_expression(QUANTITY_CONTEXT);
-
- get_next_token();
- misc_keywords.enabled = FALSE;
- if ((token_type != MISC_KEYWORD_TT)
- || (token_value != TO_MK))
- { ebf_error("'to'", token_text);
- panic_mode_error_recovery();
- return;
- }
-
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- AO = code_generate(AO, QUANTITY_CONTEXT, -1);
- if ((runtime_error_checking_switch) && (veneer_mode == FALSE))
- { if (version_number >= 5)
- assemblez_3(call_vn_zc, veneer_routine(RT__ChT_VR),
- AO, AO2);
- else
- { assemblez_3_to(call_zc, veneer_routine(RT__ChT_VR),
- AO, AO2, temp_var1);
- }
- }
- else
- assemblez_2(insert_obj_zc, AO, AO2);
- break;
-
- /* -------------------------------------------------------------------- */
- /* new_line ----------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case NEW_LINE_CODE: assemblez_0(new_line_zc); break;
-
- /* -------------------------------------------------------------------- */
- /* objectloop (<initialisation>) <codeblock> -------------------------- */
- /* -------------------------------------------------------------------- */
-
- case OBJECTLOOP_CODE:
-
- match_open_bracket();
- get_next_token();
- INITAOT(&AO, VARIABLE_OT);
- if (token_type == LOCAL_VARIABLE_TT)
- AO.value = token_value;
- else
- if ((token_type == SYMBOL_TT) &&
- (stypes[token_value] == GLOBAL_VARIABLE_T))
- AO.value = svals[token_value];
- else
- { ebf_error("'objectloop' variable", token_text);
- panic_mode_error_recovery(); break;
- }
- if ((module_switch) && (AO.value >= MAX_LOCAL_VARIABLES)
- && (AO.value < LOWEST_SYSTEM_VAR_NUMBER))
- AO.marker = VARIABLE_MV;
- misc_keywords.enabled = TRUE;
- get_next_token(); flag = TRUE;
- misc_keywords.enabled = FALSE;
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP))
- flag = FALSE;
-
- ln = 0;
- if ((token_type == MISC_KEYWORD_TT)
- && (token_value == NEAR_MK)) ln = 1;
- if ((token_type == MISC_KEYWORD_TT)
- && (token_value == FROM_MK)) ln = 2;
- if ((token_type == CND_TT) && (token_value == IN_COND))
- { get_next_token();
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP))
- ln = 3;
- put_token_back();
- put_token_back();
- }
-
- if (ln > 0)
- { /* Old style (Inform 5) objectloops: note that we
- implement objectloop (a in b) in the old way since
- this runs through objects in a different order from
- the new way, and there may be existing Inform code
- relying on this. */
- assembly_operand AO4;
- INITAO(&AO4);
-
- sequence_point_follows = TRUE;
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- match_close_bracket();
- if (ln == 1)
- { INITAOTV(&AO3, VARIABLE_OT, 0);
- if (runtime_error_checking_switch)
- AO2 = check_nonzero_at_runtime(AO2, -1,
- OBJECTLOOP_RTE);
- assemblez_1_to(get_parent_zc, AO2, AO3);
- assemblez_objcode(get_child_zc, AO3, AO3, -2, TRUE);
- AO2 = AO3;
- }
- if (ln == 3)
- { INITAOTV(&AO3, VARIABLE_OT, 0);
- if (runtime_error_checking_switch)
- { AO4 = AO2;
- AO2 = check_nonzero_at_runtime(AO2, -1,
- CHILD_RTE);
- }
- assemblez_objcode(get_child_zc, AO2, AO3, -2, TRUE);
- AO2 = AO3;
- }
- assemblez_store(AO, AO2);
- assemblez_1_branch(jz_zc, AO, ln2 = next_label++, TRUE);
- assemble_label_no(ln4 = next_label++);
- parse_code_block(ln2, ln3 = next_label++, 0);
- sequence_point_follows = FALSE;
- assemble_label_no(ln3);
- if (runtime_error_checking_switch)
- { AO2 = check_nonzero_at_runtime(AO, ln2,
- OBJECTLOOP2_RTE);
- if ((ln == 3)
- && ((AO4.type != VARIABLE_OT)||(AO4.value != 0))
- && ((AO4.type != VARIABLE_OT)
- ||(AO4.value != AO.value)))
- { assembly_operand en_ao;
- INITAOTV(&en_ao, SHORT_CONSTANT_OT, OBJECTLOOP_BROKEN_RTE);
- assemblez_2_branch(jin_zc, AO, AO4,
- next_label, TRUE);
- assemblez_3(call_vn_zc, veneer_routine(RT__Err_VR),
- en_ao, AO);
- assemblez_jump(ln2);
- assemble_label_no(next_label++);
- }
- }
- else AO2 = AO;
- assemblez_objcode(get_sibling_zc, AO2, AO, ln4, TRUE);
- assemble_label_no(ln2);
- return;
- }
-
- sequence_point_follows = TRUE;
- INITAOTV(&AO2, SHORT_CONSTANT_OT, 1);
- assemblez_store(AO, AO2);
-
- assemble_label_no(ln = next_label++);
- ln2 = next_label++;
- ln3 = next_label++;
- if (flag)
- { put_token_back();
- put_token_back();
- sequence_point_follows = TRUE;
- code_generate(parse_expression(CONDITION_CONTEXT),
- CONDITION_CONTEXT, ln3);
- match_close_bracket();
- }
- parse_code_block(ln2, ln3, 0);
-
- sequence_point_follows = FALSE;
- assemble_label_no(ln3);
- assemblez_inc(AO);
- INITAOTV(&AO2, LONG_CONSTANT_OT, no_objects);
- AO2.marker = NO_OBJS_MV;
- assemblez_2_branch(jg_zc, AO, AO2, ln2, TRUE);
- assemblez_jump(ln);
- assemble_label_no(ln2);
- return;
-
- /* -------------------------------------------------------------------- */
- /* (see routine above) ------------------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case PRINT_CODE:
- get_next_token();
- parse_print_z(FALSE); return;
- case PRINT_RET_CODE:
- get_next_token();
- parse_print_z(TRUE); return;
-
- /* -------------------------------------------------------------------- */
- /* quit --------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case QUIT_CODE: assemblez_0(quit_zc); break;
-
- /* -------------------------------------------------------------------- */
- /* read <expression> <expression> [<Routine>] ------------------------- */
- /* -------------------------------------------------------------------- */
-
- case READ_CODE:
- INITAOTV(&AO, VARIABLE_OT, 252);
- assemblez_store(AO,
- code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1));
- if (version_number > 3)
- { INITAOTV(&AO3, SHORT_CONSTANT_OT, 1);
- INITAOTV(&AO4, SHORT_CONSTANT_OT, 0);
- assemblez_3(storeb_zc, AO, AO3, AO4);
- }
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
-
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP))
- put_token_back();
- else
- { if (version_number == 3)
- error(
-"In Version 3 no status-line drawing routine can be given");
- else
- { assembly_operand AO5;
- /* Move the temp4 (buffer) value to the stack,
- since the routine might alter temp4. */
- assemblez_store(stack_pointer, AO);
- AO = stack_pointer;
- put_token_back();
- AO5 = parse_expression(CONSTANT_CONTEXT);
-
- if (version_number >= 5)
- assemblez_1(call_1n_zc, AO5);
- else
- assemblez_1_to(call_zc, AO5, temp_var1);
- }
- }
-
- if (version_number > 4)
- { assemblez_2_to(aread_zc, AO, AO2, temp_var1);
- }
- else assemblez_2(sread_zc, AO, AO2);
- break;
-
- /* -------------------------------------------------------------------- */
- /* remove <expression> ------------------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case REMOVE_CODE:
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if ((runtime_error_checking_switch) && (veneer_mode == FALSE))
- { if (version_number >= 5)
- assemblez_2(call_2n_zc, veneer_routine(RT__ChR_VR),
- AO);
- else
- { assemblez_2_to(call_zc, veneer_routine(RT__ChR_VR),
- AO, temp_var1);
- }
- }
- else
- assemblez_1(remove_obj_zc, AO);
- break;
-
- /* -------------------------------------------------------------------- */
- /* restore <label> ---------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RESTORE_CODE:
- if (version_number < 5)
- assemblez_0_branch(restore_zc, parse_label(), TRUE);
- else
- { INITAOTV(&AO2, SHORT_CONSTANT_OT, 2);
- assemblez_0_to(restore_zc, temp_var1);
- assemblez_2_branch(je_zc, temp_var1, AO2, parse_label(), TRUE);
- }
- break;
-
- /* -------------------------------------------------------------------- */
- /* return [<expression>] ---------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RETURN_CODE:
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP))
- { assemblez_0(rtrue_zc); return; }
- put_token_back();
- AO = code_generate(parse_expression(RETURN_Q_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if ((AO.type == SHORT_CONSTANT_OT) && (AO.value == 0)
- && (AO.marker == 0))
- { assemblez_0(rfalse_zc); break; }
- if ((AO.type == SHORT_CONSTANT_OT) && (AO.value == 1)
- && (AO.marker == 0))
- { assemblez_0(rtrue_zc); break; }
- if ((AO.type == VARIABLE_OT) && (AO.value == 0))
- { assemblez_0(ret_popped_zc); break; }
- assemblez_1(ret_zc, AO);
- break;
-
- /* -------------------------------------------------------------------- */
- /* rfalse ------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RFALSE_CODE: assemblez_0(rfalse_zc); break;
-
- /* -------------------------------------------------------------------- */
- /* rtrue -------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RTRUE_CODE: assemblez_0(rtrue_zc); break;
-
- /* -------------------------------------------------------------------- */
- /* save <label> ------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case SAVE_CODE:
- if (version_number < 5)
- assemblez_0_branch(save_zc, parse_label(), TRUE);
- else
- { INITAOTV(&AO, VARIABLE_OT, 255);
- assemblez_0_to(save_zc, AO);
- assemblez_1_branch(jz_zc, AO, parse_label(), FALSE);
- }
- break;
-
- /* -------------------------------------------------------------------- */
- /* spaces <expression> ------------------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case SPACES_CODE:
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- INITAOTV(&AO2, VARIABLE_OT, 255);
-
- assemblez_store(AO2, AO);
-
- INITAOTV(&AO, SHORT_CONSTANT_OT, 32);
- INITAOTV(&AO3, SHORT_CONSTANT_OT, 1);
-
- assemblez_2_branch(jl_zc, AO2, AO3, ln = next_label++, TRUE);
- assemble_label_no(ln2 = next_label++);
- assemblez_1(print_char_zc, AO);
- assemblez_dec(AO2);
- assemblez_1_branch(jz_zc, AO2, ln2, FALSE);
- assemble_label_no(ln);
- break;
-
- /* -------------------------------------------------------------------- */
- /* string <expression> <literal-string> ------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case STRING_CODE:
- INITAOTV(&AO, SHORT_CONSTANT_OT, 0);
- INITAOTV(&AO2, SHORT_CONSTANT_OT, 12);
- INITAOTV(&AO3, VARIABLE_OT, 252);
- assemblez_2_to(loadw_zc, AO, AO2, AO3);
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- get_next_token();
- if (token_type == DQ_TT)
- { INITAOT(&AO4, LONG_CONSTANT_OT);
- AO4.value = compile_string(token_text, TRUE, TRUE);
- }
- else
- { put_token_back();
- AO4 = parse_expression(CONSTANT_CONTEXT);
- }
- assemblez_3(storew_zc, AO3, AO2, AO4);
- break;
-
- /* -------------------------------------------------------------------- */
- /* style roman/reverse/bold/underline/fixed --------------------------- */
- /* -------------------------------------------------------------------- */
-
- case STYLE_CODE:
- if (version_number==3)
- { error(
-"The 'style' statement cannot be used for Version 3 games");
- panic_mode_error_recovery();
- break;
- }
-
- misc_keywords.enabled = TRUE;
- get_next_token();
- misc_keywords.enabled = FALSE;
- if ((token_type != MISC_KEYWORD_TT)
- || ((token_value != ROMAN_MK)
- && (token_value != REVERSE_MK)
- && (token_value != BOLD_MK)
- && (token_value != UNDERLINE_MK)
- && (token_value != FIXED_MK)))
- { ebf_error(
-"'roman', 'bold', 'underline', 'reverse' or 'fixed'",
- token_text);
- panic_mode_error_recovery();
- break;
- }
-
- INITAOT(&AO, SHORT_CONSTANT_OT);
- switch(token_value)
- { case ROMAN_MK: AO.value = 0; break;
- case REVERSE_MK: AO.value = 1; break;
- case BOLD_MK: AO.value = 2; break;
- case UNDERLINE_MK: AO.value = 4; break;
- case FIXED_MK: AO.value = 8; break;
- }
- assemblez_1(set_text_style_zc, AO); break;
-
- /* -------------------------------------------------------------------- */
- /* switch (<expression>) <codeblock> ---------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case SWITCH_CODE:
- match_open_bracket();
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- match_close_bracket();
-
- INITAOTV(&AO2, VARIABLE_OT, 255);
- assemblez_store(AO2, AO);
-
- parse_code_block(ln = next_label++, continue_label, 1);
- assemble_label_no(ln);
- return;
-
- /* -------------------------------------------------------------------- */
- /* while (<condition>) <codeblock> ------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case WHILE_CODE:
- assemble_label_no(ln = next_label++);
- match_open_bracket();
-
- code_generate(parse_expression(CONDITION_CONTEXT),
- CONDITION_CONTEXT, ln2 = next_label++);
- match_close_bracket();
-
- parse_code_block(ln2, ln, 0);
- sequence_point_follows = FALSE;
- assemblez_jump(ln);
- assemble_label_no(ln2);
- return;
-
- /* -------------------------------------------------------------------- */
-
- case SDEFAULT_CODE:
- error("'default' without matching 'switch'"); break;
- case ELSE_CODE:
- error("'else' without matching 'if'"); break;
- case UNTIL_CODE:
- error("'until' without matching 'do'");
- panic_mode_error_recovery(); return;
- }
-
- StatementTerminator:
-
- get_next_token();
- if ((token_type != SEP_TT) || (token_value != SEMICOLON_SEP))
- { ebf_error("';'", token_text);
- put_token_back();
- }
-}
-
-static void parse_statement_g(int break_label, int continue_label)
-{ int ln, ln2, ln3, ln4, flag, onstack;
- assembly_operand AO, AO2, AO3, AO4;
- debug_location spare_debug_location1, spare_debug_location2;
-
- ASSERT_GLULX();
-
- if ((token_type == SEP_TT) && (token_value == PROPERTY_SEP))
- { /* That is, a full stop, signifying a label */
-
- get_next_token();
- if (token_type == SYMBOL_TT)
- {
- if (sflags[token_value] & UNKNOWN_SFLAG)
- { assign_symbol(token_value, next_label, LABEL_T);
- sflags[token_value] |= USED_SFLAG;
- assemble_label_no(next_label);
- define_symbol_label(token_value);
- next_label++;
- }
- else
- { if (stypes[token_value] != LABEL_T) goto LabelError;
- if (sflags[token_value] & CHANGE_SFLAG)
- { sflags[token_value] &= (~(CHANGE_SFLAG));
- assemble_label_no(svals[token_value]);
- define_symbol_label(token_value);
- }
- else error_named("Duplicate definition of label:", token_text);
- }
-
- get_next_token();
- if ((token_type != SEP_TT) || (token_value != SEMICOLON_SEP))
- { ebf_error("';'", token_text);
- put_token_back(); return;
- }
-
- /* Interesting point of Inform grammar: a statement can only
- consist solely of a label when it is immediately followed
- by a "}". */
-
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSE_BRACE_SEP))
- { put_token_back(); return;
- }
- /* The following line prevents labels from influencing the positions
- of sequence points. */
- statement_debug_location = get_token_location();
- parse_statement(break_label, continue_label);
- return;
- }
- LabelError: ebf_error("label name", token_text);
- }
-
- if ((token_type == SEP_TT) && (token_value == HASH_SEP))
- { parse_directive(TRUE);
- parse_statement(break_label, continue_label); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == AT_SEP))
- { parse_assembly(); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) return;
-
- if (token_type == DQ_TT)
- { parse_print_g(TRUE); return;
- }
-
- if ((token_type == SEP_TT) && (token_value == LESS_SEP))
- { parse_action(); goto StatementTerminator; }
-
- if (token_type == EOF_TT)
- { ebf_error("statement", token_text); return; }
-
- if (token_type != STATEMENT_TT)
- { put_token_back();
- AO = parse_expression(VOID_CONTEXT);
- code_generate(AO, VOID_CONTEXT, -1);
- if (vivc_flag) { panic_mode_error_recovery(); return; }
- goto StatementTerminator;
- }
-
- statements.enabled = FALSE;
-
- switch(token_value)
- {
-
- /* -------------------------------------------------------------------- */
- /* box <string-1> ... <string-n> -------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case BOX_CODE:
- INITAOT(&AO3, CONSTANT_OT);
- AO3.value = begin_table_array();
- AO3.marker = ARRAY_MV;
- ln = 0; ln2 = 0;
- do
- { get_next_token();
- if ((token_type==SEP_TT)&&(token_value==SEMICOLON_SEP))
- break;
- if (token_type != DQ_TT)
- ebf_error("text of box line in double-quotes",
- token_text);
- { int i, j;
- for (i=0, j=0; token_text[i] != 0; j++)
- if (token_text[i] == '@')
- { if (token_text[i+1] == '@')
- { i = i + 2;
- while (isdigit(token_text[i])) i++;
- }
- else
- { i++;
- if (token_text[i] != 0) i++;
- if (token_text[i] != 0) i++;
- }
- }
- else i++;
- if (j > ln2) ln2 = j;
- }
- put_token_back();
- array_entry(ln++,parse_expression(CONSTANT_CONTEXT));
- } while (TRUE);
- finish_array(ln);
- if (ln == 0)
- error("No lines of text given for 'box' display");
-
- INITAO(&AO2);
- AO2.value = ln2; set_constant_ot(&AO2);
- assembleg_call_2(veneer_routine(Box__Routine_VR),
- AO2, AO3, zero_operand);
- return;
-
- /* -------------------------------------------------------------------- */
- /* break -------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case BREAK_CODE:
- if (break_label == -1)
- error("'break' can only be used in a loop or 'switch' block");
- else
- assembleg_jump(break_label);
- break;
-
- /* -------------------------------------------------------------------- */
- /* continue ----------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case CONTINUE_CODE:
- if (continue_label == -1)
- error("'continue' can only be used in a loop block");
- else
- assembleg_jump(continue_label);
- break;
-
- /* -------------------------------------------------------------------- */
- /* do <codeblock> until (<condition>) --------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case DO_CODE:
- assemble_label_no(ln = next_label++);
- ln2 = next_label++; ln3 = next_label++;
- parse_code_block(ln3, ln2, 0);
- statements.enabled = TRUE;
- get_next_token();
- if ((token_type == STATEMENT_TT)
- && (token_value == UNTIL_CODE))
- { assemble_label_no(ln2);
- match_open_bracket();
- AO = parse_expression(CONDITION_CONTEXT);
- match_close_bracket();
- code_generate(AO, CONDITION_CONTEXT, ln);
- }
- else error("'do' without matching 'until'");
-
- assemble_label_no(ln3);
- break;
-
- /* -------------------------------------------------------------------- */
- /* font on/off -------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case FONT_CODE:
- misc_keywords.enabled = TRUE;
- get_next_token();
- misc_keywords.enabled = FALSE;
- if ((token_type != MISC_KEYWORD_TT)
- || ((token_value != ON_MK)
- && (token_value != OFF_MK)))
- { ebf_error("'on' or 'off'", token_text);
- panic_mode_error_recovery();
- break;
- }
-
- /* Call glk_set_style(normal or preformatted) */
- INITAO(&AO);
- AO.value = 0x0086;
- set_constant_ot(&AO);
- if (token_value == ON_MK)
- AO2 = zero_operand;
- else
- AO2 = two_operand;
- assembleg_call_2(veneer_routine(Glk__Wrap_VR),
- AO, AO2, zero_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* for (<initialisation> : <continue-condition> : <updating>) --------- */
- /* -------------------------------------------------------------------- */
-
- /* Note that it's legal for any or all of the three sections of a
- 'for' specification to be empty. This 'for' implementation
- often wastes 3 bytes with a redundant branch rather than keep
- expression parse trees for long periods (as previous versions
- of Inform did, somewhat crudely by simply storing the textual
- form of a 'for' loop). It is adequate for now. */
-
- case FOR_CODE:
- match_open_bracket();
- get_next_token();
-
- /* Initialisation code */
-
- if (!((token_type==SEP_TT)&&(token_value==COLON_SEP)))
- { put_token_back();
- if (!((token_type==SEP_TT)&&(token_value==SUPERCLASS_SEP)))
- { sequence_point_follows = TRUE;
- statement_debug_location = get_token_location();
- code_generate(parse_expression(FORINIT_CONTEXT),
- VOID_CONTEXT, -1);
- }
- get_next_token();
- if ((token_type==SEP_TT)&&(token_value == SUPERCLASS_SEP))
- { get_next_token();
- if ((token_type==SEP_TT)&&(token_value == CLOSEB_SEP))
- { assemble_label_no(ln = next_label++);
- ln2 = next_label++;
- parse_code_block(ln2, ln, 0);
- sequence_point_follows = FALSE;
- if (!execution_never_reaches_here)
- assembleg_jump(ln);
- assemble_label_no(ln2);
- return;
- }
- AO.type = OMITTED_OT;
- goto ParseUpdate;
- }
- put_token_back();
- if (!match_colon()) break;
- }
-
- get_next_token();
- AO.type = OMITTED_OT;
- if (!((token_type==SEP_TT)&&(token_value==COLON_SEP)))
- { put_token_back();
- spare_debug_location1 = get_token_location();
- AO = parse_expression(CONDITION_CONTEXT);
- if (!match_colon()) break;
- }
- get_next_token();
-
- ParseUpdate:
- AO2.type = OMITTED_OT; flag = 0;
- if (!((token_type==SEP_TT)&&(token_value==CLOSEB_SEP)))
- { put_token_back();
- spare_debug_location2 = get_token_location();
- AO2 = parse_expression(VOID_CONTEXT);
- match_close_bracket();
- flag = test_for_incdec(AO2);
- }
-
- ln = next_label++;
- ln2 = next_label++;
- ln3 = next_label++;
-
- if ((AO2.type == OMITTED_OT) || (flag != 0))
- {
- assemble_label_no(ln);
- if (flag==0) assemble_label_no(ln2);
-
- /* The "finished yet?" condition */
-
- if (AO.type != OMITTED_OT)
- { sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location1;
- code_generate(AO, CONDITION_CONTEXT, ln3);
- }
-
- }
- else
- {
- /* This is the jump which could be avoided with the aid
- of long-term expression storage */
-
- sequence_point_follows = FALSE;
- assembleg_jump(ln2);
-
- /* The "update" part */
-
- assemble_label_no(ln);
- sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location2;
- code_generate(AO2, VOID_CONTEXT, -1);
-
- assemble_label_no(ln2);
-
- /* The "finished yet?" condition */
-
- if (AO.type != OMITTED_OT)
- { sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location1;
- code_generate(AO, CONDITION_CONTEXT, ln3);
- }
- }
-
- if (flag != 0)
- {
- /* In this optimised case, update code is at the end
- of the loop block, so "continue" goes there */
-
- parse_code_block(ln3, ln2, 0);
- assemble_label_no(ln2);
-
- sequence_point_follows = TRUE;
- statement_debug_location = spare_debug_location2;
- if (flag > 0)
- { INITAO(&AO3);
- AO3.value = flag;
- if (AO3.value >= MAX_LOCAL_VARIABLES)
- AO3.type = GLOBALVAR_OT;
- else
- AO3.type = LOCALVAR_OT;
- assembleg_3(add_gc, AO3, one_operand, AO3);
- }
- else
- { INITAO(&AO3);
- AO3.value = -flag;
- if (AO3.value >= MAX_LOCAL_VARIABLES)
- AO3.type = GLOBALVAR_OT;
- else
- AO3.type = LOCALVAR_OT;
- assembleg_3(sub_gc, AO3, one_operand, AO3);
- }
- assembleg_jump(ln);
- }
- else
- {
- /* In the unoptimised case, update code is at the
- start of the loop block, so "continue" goes there */
-
- parse_code_block(ln3, ln, 0);
- if (!execution_never_reaches_here)
- { sequence_point_follows = FALSE;
- assembleg_jump(ln);
- }
- }
-
- assemble_label_no(ln3);
- return;
-
- /* -------------------------------------------------------------------- */
- /* give <expression> [~]attr [, [~]attr [, ...]] ---------------------- */
- /* -------------------------------------------------------------------- */
-
- case GIVE_CODE:
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if ((AO.type == LOCALVAR_OT) && (AO.value == 0))
- onstack = TRUE;
- else
- onstack = FALSE;
-
- do
- { get_next_token();
- if ((token_type == SEP_TT)
- && (token_value == SEMICOLON_SEP)) {
- if (onstack) {
- assembleg_2(copy_gc, stack_pointer, zero_operand);
- }
- return;
- }
- if ((token_type == SEP_TT)&&(token_value == ARTNOT_SEP))
- ln = 0;
- else
- { if ((token_type == SYMBOL_TT)
- && (stypes[token_value] != ATTRIBUTE_T))
- warning_named("This is not a declared Attribute:",
- token_text);
- ln = 1;
- put_token_back();
- }
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if (runtime_error_checking_switch && (!veneer_mode))
- { ln2 = (ln ? RT__ChG_VR : RT__ChGt_VR);
- if ((AO2.type == LOCALVAR_OT) && (AO2.value == 0)) {
- /* already on stack */
- }
- else {
- assembleg_store(stack_pointer, AO2);
- }
- if (onstack)
- assembleg_2(stkpeek_gc, one_operand, stack_pointer);
- else
- assembleg_store(stack_pointer, AO);
- assembleg_3(call_gc, veneer_routine(ln2), two_operand,
- zero_operand);
- }
- else {
- if (is_constant_ot(AO2.type) && AO2.marker == 0) {
- AO2.value += 8;
- set_constant_ot(&AO2);
- }
- else {
- INITAOTV(&AO3, BYTECONSTANT_OT, 8);
- assembleg_3(add_gc, AO2, AO3, stack_pointer);
- AO2 = stack_pointer;
- }
- if (onstack) {
- if ((AO2.type == LOCALVAR_OT) && (AO2.value == 0))
- assembleg_2(stkpeek_gc, one_operand,
- stack_pointer);
- else
- assembleg_2(stkpeek_gc, zero_operand,
- stack_pointer);
- }
- if (ln)
- AO3 = one_operand;
- else
- AO3 = zero_operand;
- assembleg_3(astorebit_gc, AO, AO2, AO3);
- }
- } while(TRUE);
-
- /* -------------------------------------------------------------------- */
- /* if (<condition>) <codeblock> [else <codeblock>] -------------------- */
- /* -------------------------------------------------------------------- */
-
- case IF_CODE:
- flag = FALSE;
- ln2 = 0;
-
- match_open_bracket();
- AO = parse_expression(CONDITION_CONTEXT);
- match_close_bracket();
-
- statements.enabled = TRUE;
- get_next_token();
- if ((token_type == STATEMENT_TT)&&(token_value == RTRUE_CODE))
- ln = -4;
- else
- if ((token_type == STATEMENT_TT)&&(token_value == RFALSE_CODE))
- ln = -3;
- else
- { put_token_back();
- ln = next_label++;
- }
-
- code_generate(AO, CONDITION_CONTEXT, ln);
-
- if (ln >= 0) parse_code_block(break_label, continue_label, 0);
- else
- { get_next_token();
- if ((token_type != SEP_TT)
- || (token_value != SEMICOLON_SEP))
- { ebf_error("';'", token_text);
- put_token_back();
- }
- }
-
- statements.enabled = TRUE;
- get_next_token();
- if ((token_type == STATEMENT_TT) && (token_value == ELSE_CODE))
- { flag = TRUE;
- if (ln >= 0)
- { ln2 = next_label++;
- if (!execution_never_reaches_here)
- { sequence_point_follows = FALSE;
- assembleg_jump(ln2);
- }
- }
- }
- else put_token_back();
-
- if (ln >= 0) assemble_label_no(ln);
-
- if (flag)
- { parse_code_block(break_label, continue_label, 0);
- if (ln >= 0) assemble_label_no(ln2);
- }
-
- return;
-
- /* -------------------------------------------------------------------- */
- /* inversion ---------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case INVERSION_CODE:
- INITAOTV(&AO2, DEREFERENCE_OT, GLULX_HEADER_SIZE+8);
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
- AO2.value = GLULX_HEADER_SIZE+9;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
- AO2.value = GLULX_HEADER_SIZE+10;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
- AO2.value = GLULX_HEADER_SIZE+11;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
-
- if (/* DISABLES CODE */ (0)) {
- INITAO(&AO);
- AO.value = '(';
- set_constant_ot(&AO);
- assembleg_1(streamchar_gc, AO);
- AO.value = 'G';
- set_constant_ot(&AO);
- assembleg_1(streamchar_gc, AO);
-
- AO2.value = GLULX_HEADER_SIZE+12;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
- AO2.value = GLULX_HEADER_SIZE+13;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
- AO2.value = GLULX_HEADER_SIZE+14;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
- AO2.value = GLULX_HEADER_SIZE+15;
- assembleg_2(copyb_gc, AO2, stack_pointer);
- assembleg_1(streamchar_gc, stack_pointer);
-
- AO.marker = 0;
- AO.value = ')';
- set_constant_ot(&AO);
- assembleg_1(streamchar_gc, AO);
- }
-
- break;
-
- /* -------------------------------------------------------------------- */
- /* jump <label> ------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case JUMP_CODE:
- assembleg_jump(parse_label());
- break;
-
- /* -------------------------------------------------------------------- */
- /* move <expression> to <expression> ---------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case MOVE_CODE:
- misc_keywords.enabled = TRUE;
- AO = parse_expression(QUANTITY_CONTEXT);
-
- get_next_token();
- misc_keywords.enabled = FALSE;
- if ((token_type != MISC_KEYWORD_TT)
- || (token_value != TO_MK))
- { ebf_error("'to'", token_text);
- panic_mode_error_recovery();
- return;
- }
-
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- AO = code_generate(AO, QUANTITY_CONTEXT, -1);
- if ((runtime_error_checking_switch) && (veneer_mode == FALSE))
- assembleg_call_2(veneer_routine(RT__ChT_VR), AO, AO2,
- zero_operand);
- else
- assembleg_call_2(veneer_routine(OB__Move_VR), AO, AO2,
- zero_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* new_line ----------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case NEW_LINE_CODE:
- INITAOTV(&AO, BYTECONSTANT_OT, 0x0A);
- assembleg_1(streamchar_gc, AO);
- break;
-
- /* -------------------------------------------------------------------- */
- /* objectloop (<initialisation>) <codeblock> -------------------------- */
- /* -------------------------------------------------------------------- */
-
- case OBJECTLOOP_CODE:
-
- match_open_bracket();
- get_next_token();
- if (token_type == LOCAL_VARIABLE_TT) {
- INITAOTV(&AO, LOCALVAR_OT, token_value);
- }
- else if ((token_type == SYMBOL_TT) &&
- (stypes[token_value] == GLOBAL_VARIABLE_T)) {
- INITAOTV(&AO, GLOBALVAR_OT, svals[token_value]);
- }
- else {
- ebf_error("'objectloop' variable", token_text);
- panic_mode_error_recovery();
- break;
- }
- misc_keywords.enabled = TRUE;
- get_next_token(); flag = TRUE;
- misc_keywords.enabled = FALSE;
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP))
- flag = FALSE;
-
- ln = 0;
- if ((token_type == MISC_KEYWORD_TT)
- && (token_value == NEAR_MK)) ln = 1;
- if ((token_type == MISC_KEYWORD_TT)
- && (token_value == FROM_MK)) ln = 2;
- if ((token_type == CND_TT) && (token_value == IN_COND))
- { get_next_token();
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == CLOSEB_SEP))
- ln = 3;
- put_token_back();
- put_token_back();
- }
-
- if (ln != 0) {
- /* Old style (Inform 5) objectloops: note that we
- implement objectloop (a in b) in the old way since
- this runs through objects in a different order from
- the new way, and there may be existing Inform code
- relying on this. */
- assembly_operand AO4, AO5;
- INITAO(&AO5);
-
- sequence_point_follows = TRUE;
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- match_close_bracket();
- if (ln == 1) {
- if (runtime_error_checking_switch)
- AO2 = check_nonzero_at_runtime(AO2, -1,
- OBJECTLOOP_RTE);
- INITAOTV(&AO4, BYTECONSTANT_OT, GOBJFIELD_PARENT());
- assembleg_3(aload_gc, AO2, AO4, stack_pointer);
- INITAOTV(&AO4, BYTECONSTANT_OT, GOBJFIELD_CHILD());
- assembleg_3(aload_gc, stack_pointer, AO4, stack_pointer);
- AO2 = stack_pointer;
- }
- else if (ln == 3) {
- if (runtime_error_checking_switch) {
- AO5 = AO2;
- AO2 = check_nonzero_at_runtime(AO2, -1,
- CHILD_RTE);
- }
- INITAOTV(&AO4, BYTECONSTANT_OT, GOBJFIELD_CHILD());
- assembleg_3(aload_gc, AO2, AO4, stack_pointer);
- AO2 = stack_pointer;
- }
- else {
- /* do nothing */
- }
- assembleg_store(AO, AO2);
- assembleg_1_branch(jz_gc, AO, ln2 = next_label++);
- assemble_label_no(ln4 = next_label++);
- parse_code_block(ln2, ln3 = next_label++, 0);
- sequence_point_follows = FALSE;
- assemble_label_no(ln3);
- if (runtime_error_checking_switch) {
- AO2 = check_nonzero_at_runtime(AO, ln2,
- OBJECTLOOP2_RTE);
- if ((ln == 3)
- && ((AO5.type != LOCALVAR_OT)||(AO5.value != 0))
- && ((AO5.type != LOCALVAR_OT)||(AO5.value != AO.value)))
- { assembly_operand en_ao;
- INITAO(&en_ao);
- en_ao.value = OBJECTLOOP_BROKEN_RTE;
- set_constant_ot(&en_ao);
- INITAOTV(&AO4, BYTECONSTANT_OT, GOBJFIELD_PARENT());
- assembleg_3(aload_gc, AO, AO4, stack_pointer);
- assembleg_2_branch(jeq_gc, stack_pointer, AO5,
- next_label);
- assembleg_call_2(veneer_routine(RT__Err_VR),
- en_ao, AO, zero_operand);
- assembleg_jump(ln2);
- assemble_label_no(next_label++);
- }
- }
- else {
- AO2 = AO;
- }
- INITAOTV(&AO4, BYTECONSTANT_OT, GOBJFIELD_SIBLING());
- assembleg_3(aload_gc, AO2, AO4, AO);
- assembleg_1_branch(jnz_gc, AO, ln4);
- assemble_label_no(ln2);
- return;
- }
-
- sequence_point_follows = TRUE;
- ln = symbol_index("Class", -1);
- INITAOT(&AO2, CONSTANT_OT);
- AO2.value = svals[ln];
- AO2.marker = OBJECT_MV;
- assembleg_store(AO, AO2);
-
- assemble_label_no(ln = next_label++);
- ln2 = next_label++;
- ln3 = next_label++;
- if (flag)
- { put_token_back();
- put_token_back();
- sequence_point_follows = TRUE;
- code_generate(parse_expression(CONDITION_CONTEXT),
- CONDITION_CONTEXT, ln3);
- match_close_bracket();
- }
- parse_code_block(ln2, ln3, 0);
-
- sequence_point_follows = FALSE;
- assemble_label_no(ln3);
- INITAOTV(&AO4, BYTECONSTANT_OT, GOBJFIELD_CHAIN());
- assembleg_3(aload_gc, AO, AO4, AO);
- assembleg_1_branch(jnz_gc, AO, ln);
- assemble_label_no(ln2);
- return;
-
- /* -------------------------------------------------------------------- */
- /* (see routine above) ------------------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case PRINT_CODE:
- get_next_token();
- parse_print_g(FALSE); return;
- case PRINT_RET_CODE:
- get_next_token();
- parse_print_g(TRUE); return;
-
- /* -------------------------------------------------------------------- */
- /* quit --------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case QUIT_CODE:
- assembleg_0(quit_gc); break;
-
- /* -------------------------------------------------------------------- */
- /* remove <expression> ------------------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case REMOVE_CODE:
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- if ((runtime_error_checking_switch) && (veneer_mode == FALSE))
- assembleg_call_1(veneer_routine(RT__ChR_VR), AO,
- zero_operand);
- else
- assembleg_call_1(veneer_routine(OB__Remove_VR), AO,
- zero_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* return [<expression>] ---------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RETURN_CODE:
- get_next_token();
- if ((token_type == SEP_TT) && (token_value == SEMICOLON_SEP)) {
- assembleg_1(return_gc, one_operand);
- return;
- }
- put_token_back();
- AO = code_generate(parse_expression(RETURN_Q_CONTEXT),
- QUANTITY_CONTEXT, -1);
- assembleg_1(return_gc, AO);
- break;
-
- /* -------------------------------------------------------------------- */
- /* rfalse ------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RFALSE_CODE:
- assembleg_1(return_gc, zero_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* rtrue -------------------------------------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case RTRUE_CODE:
- assembleg_1(return_gc, one_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* spaces <expression> ------------------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case SPACES_CODE:
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
-
- assembleg_store(temp_var1, AO);
-
- INITAO(&AO);
- AO.value = 32; set_constant_ot(&AO);
-
- assembleg_2_branch(jlt_gc, temp_var1, one_operand,
- ln = next_label++);
- assemble_label_no(ln2 = next_label++);
- assembleg_1(streamchar_gc, AO);
- assembleg_dec(temp_var1);
- assembleg_1_branch(jnz_gc, temp_var1, ln2);
- assemble_label_no(ln);
- break;
-
- /* -------------------------------------------------------------------- */
- /* string <expression> <literal-string> ------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case STRING_CODE:
- AO2 = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- get_next_token();
- if (token_type == DQ_TT)
- { INITAOT(&AO4, CONSTANT_OT);
- AO4.value = compile_string(token_text, TRUE, TRUE);
- AO4.marker = STRING_MV;
- }
- else
- { put_token_back();
- AO4 = parse_expression(CONSTANT_CONTEXT);
- }
- assembleg_call_2(veneer_routine(Dynam__String_VR),
- AO2, AO4, zero_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* style roman/reverse/bold/underline/fixed --------------------------- */
- /* -------------------------------------------------------------------- */
-
- case STYLE_CODE:
- misc_keywords.enabled = TRUE;
- get_next_token();
- misc_keywords.enabled = FALSE;
- if ((token_type != MISC_KEYWORD_TT)
- || ((token_value != ROMAN_MK)
- && (token_value != REVERSE_MK)
- && (token_value != BOLD_MK)
- && (token_value != UNDERLINE_MK)
- && (token_value != FIXED_MK)))
- { ebf_error(
-"'roman', 'bold', 'underline', 'reverse' or 'fixed'",
- token_text);
- panic_mode_error_recovery();
- break;
- }
-
- /* Call glk_set_style() */
-
- INITAO(&AO);
- AO.value = 0x0086;
- set_constant_ot(&AO);
- switch(token_value)
- { case ROMAN_MK:
- default:
- AO2 = zero_operand; /* normal */
- break;
- case REVERSE_MK:
- INITAO(&AO2);
- AO2.value = 5; /* alert */
- set_constant_ot(&AO2);
- break;
- case BOLD_MK:
- INITAO(&AO2);
- AO2.value = 4; /* subheader */
- set_constant_ot(&AO2);
- break;
- case UNDERLINE_MK:
- AO2 = one_operand; /* emphasized */
- break;
- case FIXED_MK:
- AO2 = two_operand; /* preformatted */
- break;
- }
- assembleg_call_2(veneer_routine(Glk__Wrap_VR),
- AO, AO2, zero_operand);
- break;
-
- /* -------------------------------------------------------------------- */
- /* switch (<expression>) <codeblock> ---------------------------------- */
- /* -------------------------------------------------------------------- */
-
- case SWITCH_CODE:
- match_open_bracket();
- AO = code_generate(parse_expression(QUANTITY_CONTEXT),
- QUANTITY_CONTEXT, -1);
- match_close_bracket();
-
- assembleg_store(temp_var1, AO);
-
- parse_code_block(ln = next_label++, continue_label, 1);
- assemble_label_no(ln);
- return;
-
- /* -------------------------------------------------------------------- */
- /* while (<condition>) <codeblock> ------------------------------------ */
- /* -------------------------------------------------------------------- */
-
- case WHILE_CODE:
- assemble_label_no(ln = next_label++);
- match_open_bracket();
-
- code_generate(parse_expression(CONDITION_CONTEXT),
- CONDITION_CONTEXT, ln2 = next_label++);
- match_close_bracket();
-
- parse_code_block(ln2, ln, 0);
- sequence_point_follows = FALSE;
- assembleg_jump(ln);
- assemble_label_no(ln2);
- return;
-
- /* -------------------------------------------------------------------- */
-
- case SDEFAULT_CODE:
- error("'default' without matching 'switch'"); break;
- case ELSE_CODE:
- error("'else' without matching 'if'"); break;
- case UNTIL_CODE:
- error("'until' without matching 'do'");
- panic_mode_error_recovery(); return;
-
- /* -------------------------------------------------------------------- */
-
- /* And a useful default, which will never be triggered in a complete
- Inform compiler, but which is important in development. */
-
- default:
- error("*** Statement code gen: Can't generate yet ***\n");
- panic_mode_error_recovery(); return;
- }
-
- StatementTerminator:
-
- get_next_token();
- if ((token_type != SEP_TT) || (token_value != SEMICOLON_SEP))
- { ebf_error("';'", token_text);
- put_token_back();
- }
-}
-
-extern void parse_statement(int break_label, int continue_label)
-{
- if (!glulx_mode)
- parse_statement_z(break_label, continue_label);
- else
- parse_statement_g(break_label, continue_label);
-}
-
-/* ========================================================================= */
-/* Data structure management routines */
-/* ------------------------------------------------------------------------- */
-
-extern void init_states_vars(void)
-{
-}
-
-extern void states_begin_pass(void)
-{
-}
-
-extern void states_allocate_arrays(void)
-{
-}
-
-extern void states_free_arrays(void)
-{
-}
-
-/* ========================================================================= */
projects / inform.git / blobdiff