extern void make_fake_action(void) { int i; char action_sub[MAX_IDENTIFIER_LENGTH+4]; get_next_token(); if (token_type != SYMBOL_TT) { ebf_error("new fake action name", token_text); panic_mode_error_recovery(); return; } sprintf(action_sub, "%s__A", token_text); i = symbol_index(action_sub, -1); if (!(sflags[i] & UNKNOWN_SFLAG)) { ebf_error("new fake action name", token_text); panic_mode_error_recovery(); return; } assign_symbol(i, ((grammar_version_number==1)?256:4096)+no_fake_actions++, FAKE_ACTION_T); new_action(token_text, i); if (debugfile_switch) { write_debug_byte(FAKE_ACTION_DBR); write_debug_byte(svals[i]/256); write_debug_byte(svals[i]%256); write_debug_string(token_text); } return; }
extern assembly_operand action_of_name(char *name) { /* Returns the action number of the given name, creating it as a new action name if it isn't already known as such. */ char action_sub[MAX_IDENTIFIER_LENGTH+4]; int j; assembly_operand AO; sprintf(action_sub, "%s__A", name); j = symbol_index(action_sub, -1); if (stypes[j] == FAKE_ACTION_T) { AO.value = svals[j]; AO.marker = 0; if (!glulx_mode) AO.type = LONG_CONSTANT_OT; else set_constant_ot(&AO); sflags[j] |= USED_SFLAG; return AO; } if (sflags[j] & UNKNOWN_SFLAG) { if (no_actions>=MAX_ACTIONS) memoryerror("MAX_ACTIONS",MAX_ACTIONS); new_action(name, no_actions); action_symbol[no_actions] = j; assign_symbol(j, no_actions++, CONSTANT_T); sflags[j] |= ACTION_SFLAG; } sflags[j] |= USED_SFLAG; AO.value = svals[j]; AO.marker = ACTION_MV; if (!glulx_mode) { AO.type = (module_switch)?LONG_CONSTANT_OT:SHORT_CONSTANT_OT; if (svals[j] >= 256) AO.type = LONG_CONSTANT_OT; } else { AO.type = CONSTANT_OT; } return AO; }
extern void make_fake_action(void) { int i; char action_sub[MAX_IDENTIFIER_LENGTH+4]; debug_location_beginning beginning_debug_location = get_token_location_beginning(); get_next_token(); if (token_type != SYMBOL_TT) { discard_token_location(beginning_debug_location); ebf_error("new fake action name", token_text); panic_mode_error_recovery(); return; } sprintf(action_sub, "%s__A", token_text); i = symbol_index(action_sub, -1); if (!(sflags[i] & UNKNOWN_SFLAG)) { discard_token_location(beginning_debug_location); ebf_error("new fake action name", token_text); panic_mode_error_recovery(); return; } assign_symbol(i, ((grammar_version_number==1)?256:4096)+no_fake_actions++, FAKE_ACTION_T); new_action(token_text, i); if (debugfile_switch) { debug_file_printf("<fake-action>"); debug_file_printf("<identifier>##%s</identifier>", token_text); debug_file_printf("<value>%d</value>", svals[i]); get_next_token(); write_debug_locations (get_token_location_end(beginning_debug_location)); put_token_back(); debug_file_printf("</fake-action>"); } return; }
extern int parse_directive(int internal_flag) { /* Internal_flag is FALSE if the directive is encountered normally, TRUE if encountered with a # prefix inside a routine or object definition. Returns: TRUE if program continues, FALSE if end of file reached. */ int routine_symbol, rep_symbol; int is_renamed; begin_syntax_line(FALSE); get_next_token(); if (token_type == EOF_TT) return(FALSE); if ((token_type == SEP_TT) && (token_value == HASH_SEP)) get_next_token(); if ((token_type == SEP_TT) && (token_value == OPEN_SQUARE_SEP)) { if (internal_flag) { error("It is illegal to nest routines using '#['"); return(TRUE); } directives.enabled = FALSE; directive_keywords.enabled = FALSE; segment_markers.enabled = FALSE; /* The upcoming symbol is a definition; don't count it as a top-level reference *to* the function. */ df_dont_note_global_symbols = TRUE; get_next_token(); df_dont_note_global_symbols = FALSE; if ((token_type != SYMBOL_TT) || ((!(sflags[token_value] & UNKNOWN_SFLAG)) && (!(sflags[token_value] & REPLACE_SFLAG)))) { ebf_error("routine name", token_text); return(FALSE); } routine_symbol = token_value; rep_symbol = routine_symbol; is_renamed = find_symbol_replacement(&rep_symbol); if ((sflags[routine_symbol] & REPLACE_SFLAG) && !is_renamed && (is_systemfile())) { /* The function is definitely being replaced (system_file always loses priority in a replacement) but is not being renamed to something else. Skip its definition entirely. */ dont_enter_into_symbol_table = TRUE; do { get_next_token(); } while (!((token_type == EOF_TT) || ((token_type==SEP_TT) && (token_value==CLOSE_SQUARE_SEP)))); dont_enter_into_symbol_table = FALSE; if (token_type == EOF_TT) return FALSE; } else { /* Parse the function definition and assign its symbol. */ assign_symbol(routine_symbol, parse_routine(lexical_source, FALSE, (char *) symbs[routine_symbol], FALSE, routine_symbol), ROUTINE_T); slines[routine_symbol] = routine_starts_line; } if (is_renamed) { /* This function was subject to a "Replace X Y" directive. The first time we see a definition for symbol X, we copy it to Y -- that's the "original" form of the function. */ if (svals[rep_symbol] == 0) { assign_symbol(rep_symbol, svals[routine_symbol], ROUTINE_T); } } get_next_token(); if ((token_type != SEP_TT) || (token_value != SEMICOLON_SEP)) { ebf_error("';' after ']'", token_text); put_token_back(); } return TRUE; } if ((token_type == SYMBOL_TT) && (stypes[token_value] == CLASS_T)) { if (internal_flag) { error("It is illegal to nest an object in a routine using '#classname'"); return(TRUE); } sflags[token_value] |= USED_SFLAG; make_object(FALSE, NULL, -1, -1, svals[token_value]); return TRUE; } if (token_type != DIRECTIVE_TT) { /* If we're internal, we expect only a directive here. If we're top-level, the possibilities are broader. */ if (internal_flag) ebf_error("directive", token_text); else ebf_error("directive, '[' or class name", token_text); panic_mode_error_recovery(); return TRUE; } return !(parse_given_directive(internal_flag)); }