Word Unperfect - XT-Emporium

File editor

#include "wp_parser_process.h"
#include "wp_control_codes.h"
#include "wp_parser_command.h"
#include "wp_span_metrics.h"
#include "wp_layout_engine.h"
#include "wp_layout_status.h"
#include "wp_record_stream.h"
#include "wp_parser_gate.h"
#include "wp_record_merge.h"
#include "wp_parser_classify.h"
#include "wp_layout_flow.h"
#include "wp_layout_state.h"
#include "wp_layout_reconcile.h"
#include <string.h>

extern void route_far_jump_shell_segment_proxy(WpLayoutGlobals *wl);
extern uint8_t __cdecl16near scan_memory_stride_3_for_char(WpLayoutGlobals *wl);
extern void __cdecl16near route_call_shell_overlay_io_decode(WpLayoutGlobals *wl);
extern uint16_t __cdecl16near parser_merge_cursor_consume_loop_then_finalize_layout_state(WpLayoutGlobals *wl, uint16_t in_AX, uint8_t in_CF);

static bool wp_process_is_signed_direct_text(uint8_t code)
{
    /* The decompiled test is `(char)in_AX > ' '`, so high-bit codes do not
     * enter the fast printable path on hosts where plain char is unsigned. */
    return code > 0x20U && code < 0x80U;
}

static bool wp_process_is_deep_d4_subcommand(const WpRecord *rec)
{
    return rec != NULL && rec->code == 0xD4U &&
           (rec->sub_code == 0x01U || rec->sub_code == 0x03U || rec->sub_code == 0x04U);
}

static WpParserProcessFixedDispatch wp_process_dispatch_for_code(uint8_t code)
{
    if (code < 0xC0U) {
        return WP_PROCESS_FIXED_DISPATCH_TEXT_OR_SINGLE;
    }
    if (code < 0xD0U) {
        return WP_PROCESS_FIXED_DISPATCH_FIXED;
    }
    if (code == 0xDEU) {
        return WP_PROCESS_FIXED_DISPATCH_VARIABLE;
    }
    if (code < 0xDEU) {
        return WP_PROCESS_FIXED_DISPATCH_VARIABLE;
    }
    return WP_PROCESS_FIXED_DISPATCH_COMMAND;
}

static WpParserProcessRoute wp_process_route_for_dispatch(WpParserProcessFixedDispatch dispatch)
{
    switch (dispatch) {
        case WP_PROCESS_FIXED_DISPATCH_TEXT_OR_SINGLE:
            return WP_PROCESS_ROUTE_RANGE_AUX_TEXT_OR_CONTROL;
        case WP_PROCESS_FIXED_DISPATCH_FIXED:
            return WP_PROCESS_ROUTE_RANGE_AUX_FIXED_PACKET;
        case WP_PROCESS_FIXED_DISPATCH_VARIABLE:
            return WP_PROCESS_ROUTE_RANGE_AUX_VARIABLE_PACKET;
        case WP_PROCESS_FIXED_DISPATCH_COMMAND:
            return WP_PROCESS_ROUTE_COMMAND_VARIANT_FALLBACK;
        case WP_PROCESS_FIXED_DISPATCH_NONE:
        default:
            return WP_PROCESS_ROUTE_NONE;
    }
}

static void wp_parser_process_count_record_status(const WpRecord *rec,
                                                  WpParserProcessStats *stats)
{
    if (rec == NULL || stats == NULL) {
        return;
    }
    if (!rec->is_complete && !rec->trailer_present) {
        stats->incomplete_records++;
    }
    if (rec->trailer_present && !rec->trailer_matches) {
        stats->mismatched_trailers++;
    }
}

void wp_parser_process_stats_clear(WpParserProcessStats *stats)
{
    if (stats != NULL) {
        memset(stats, 0, sizeof(*stats));
    }
}

const char *wp_parser_process_route_name(WpParserProcessRoute route)
{
    switch (route) {
        case WP_PROCESS_ROUTE_DIRECT_TEXT_APPEND:
            return "direct text append";
        case WP_PROCESS_ROUTE_DIRECT_C0_EXTENDED_APPEND:
            return "direct C0 extended append";
        case WP_PROCESS_ROUTE_EMIT_OR_MEASURE_WINDOW:
            return "emit/measure line window";
        case WP_PROCESS_ROUTE_RECORD_FLAGS_MERGE:
            return "record flags merge";
        case WP_PROCESS_ROUTE_BOOTSTRAP_SECONDARY_LINE:
            return "bootstrap secondary line";
        case WP_PROCESS_ROUTE_DEEP_LAYOUT_RECORD:
            return "deep layout record";
        case WP_PROCESS_ROUTE_RANGE_AUX_TEXT_OR_CONTROL:
            return "range aux text/control";
        case WP_PROCESS_ROUTE_RANGE_AUX_FIXED_PACKET:
            return "range aux fixed packet";
        case WP_PROCESS_ROUTE_RANGE_AUX_VARIABLE_PACKET:
            return "range aux variable packet";
        case WP_PROCESS_ROUTE_MEASURE_DIRTY_RECONCILE:
            return "measure dirty reconcile";
        case WP_PROCESS_ROUTE_EMIT_SCRATCH_PACK:
            return "emit scratch pack";
        case WP_PROCESS_ROUTE_SPAN_TABLE_SELECT:
            return "span table select";
        case WP_PROCESS_ROUTE_COMMAND_VARIANT_FALLBACK:
            return "command variant fallback";
        case WP_PROCESS_ROUTE_REPLAY_DEPTH_INVOKE:
            return "replay depth invoke";
        case WP_PROCESS_ROUTE_NONE:
        default:
            return "none";
    }
}

const char *wp_parser_process_dispatch_name(WpParserProcessFixedDispatch dispatch)
{
    switch (dispatch) {
        case WP_PROCESS_FIXED_DISPATCH_TEXT_OR_SINGLE:
            return "0x7994 text/single handler";
        case WP_PROCESS_FIXED_DISPATCH_FIXED:
            return "0x7A3D fixed-packet handler";
        case WP_PROCESS_FIXED_DISPATCH_VARIABLE:
            return "0x7A5F variable-packet handler";
        case WP_PROCESS_FIXED_DISPATCH_COMMAND:
            return "0x2F40 command parser";
        case WP_PROCESS_FIXED_DISPATCH_NONE:
        default:
            return "none";
    }
}

bool wp_parser_process_plan_record(WpLayoutGlobals *runtime,
                                   const WpRecord *rec,
                                   WpParserProcessStep *out_step)
{
    WpParserProcessStep step;
    bool emit_blocks_fast_path;

    if (out_step != NULL) {
        memset(out_step, 0, sizeof(*out_step));
    }
    if (runtime == NULL || rec == NULL || out_step == NULL) {
        return false;
    }

    memset(&step, 0, sizeof(step));
    step.code = rec->code;
    step.sub_code = rec->sub_code;
    step.record_type = rec->type;

    step.prelude_reprocess_gate = (runtime->runtime_flags & 0x24U) != 0U;
    step.postprocess_stream_bump = runtime->postprocess_mode > 0;

    emit_blocks_fast_path = (runtime->emit_flags & 0x16U) != 0U;
    if (!emit_blocks_fast_path) {
        if (wp_process_is_signed_direct_text(rec->code)) {
            step.route = WP_PROCESS_ROUTE_DIRECT_TEXT_APPEND;
            step.packet_copy_bytes = 1U;
            *out_step = step;
            return true;
        }
        if (rec->code == 0xC0U) {
            step.route = WP_PROCESS_ROUTE_DIRECT_C0_EXTENDED_APPEND;
            step.c0_word_token = true;
            step.packet_copy_bytes = rec->length;
            *out_step = step;
            return true;
        }
    } else if ((runtime->emit_flags & 0x04U) != 0U) {
        if (runtime->record_extension_needs_flush != 0) {
            step.route = WP_PROCESS_ROUTE_RECORD_FLAGS_MERGE;
        } else {
            step.route = WP_PROCESS_ROUTE_EMIT_OR_MEASURE_WINDOW;
        }
        step.token_prepended = true;
        *out_step = step;
        return true;
    } else if ((runtime->emit_flags & 0x10U) != 0U) {
        step.route = WP_PROCESS_ROUTE_BOOTSTRAP_SECONDARY_LINE;
        step.token_prepended = true;
        *out_step = step;
        return true;
    }

    step.token_prepended = true;
    if (rec->code == 0xD4U) {
        step.d4_word_prepend = true;
    }

    if (wp_process_is_deep_d4_subcommand(rec)) {
        step.route = WP_PROCESS_ROUTE_DEEP_LAYOUT_RECORD;
        step.d4_deep_subcommand = true;
        step.psp_depth_pulse = true;
        step.measured_span_reset_hint = (runtime->measured_span_flags & 0x01U) != 0U;
        step.postprocess_reconcile_hint = runtime->postprocess_mode != 0;
        step.update_depth_incremented = true;
        *out_step = step;
        return true;
    }

    if (rec->code >= 0xC0U) {
        step.fixed_dispatch = wp_process_dispatch_for_code(rec->code);
        step.route = wp_process_route_for_dispatch(step.fixed_dispatch);
        step.range_check_aux_called = true;
        if (rec->code >= 0xC0U) {
            step.normalized_packet_bytes = true;
            step.packet_copy_bytes = rec->length > 0U ? (uint16_t)(rec->length - 1U) : 0U;
            step.copied_packet_tail = step.packet_copy_bytes != 0U;
        }
        if (step.fixed_dispatch == WP_PROCESS_FIXED_DISPATCH_COMMAND) {
            step.command_variant_called = true;
        }
        *out_step = step;
        return true;
    }

    if (rec->code >= 0x80U) {
        step.route = WP_PROCESS_ROUTE_MEASURE_DIRTY_RECONCILE;
        *out_step = step;
        return true;
    }
    if (rec->code < 0x20U) {
        step.route = WP_PROCESS_ROUTE_EMIT_SCRATCH_PACK;
        step.parse_dirty_set = true;
        step.status_extend_set = true;
        *out_step = step;
        return true;
    }
    if (rec->code == 0x20U) {
        step.route = WP_PROCESS_ROUTE_SPAN_TABLE_SELECT;
        *out_step = step;
        return true;
    }

    if ((runtime->heap_control_flags_4bf1 & 0x04U) != 0U) {
        step.route = WP_PROCESS_ROUTE_COMMAND_VARIANT_FALLBACK;
        step.command_variant_called = true;
        step.heap_gate_forced_command = true;
    } else {
        step.route = WP_PROCESS_ROUTE_REPLAY_DEPTH_INVOKE;
        step.replay_depth_invoked = true;
    }
    *out_step = step;
    return true;
}

bool wp_parser_process_apply_step(WpLayoutGlobals *runtime,
                                  const WpParserProcessStep *step,
                                  WpParserProcessStats *stats)
{
    if (runtime == NULL || step == NULL || stats == NULL) {
        return false;
    }

    if (step->prelude_reprocess_gate) {
        stats->prelude_reprocess_gates++;
        runtime->parser_runtime_flags |= 0x10U;
    }
    if (step->postprocess_stream_bump) {
        stats->postprocess_stream_bumps++;
        runtime->record_stream_offset_low = (uint16_t)(runtime->record_stream_offset_low + 1U);
        if (runtime->record_stream_offset_low == 0U) {
            runtime->record_stream_offset_high = (uint16_t)(runtime->record_stream_offset_high + 1U);
        }
    }

    if (step->token_prepended) {
        stats->token_prepends++;
    }
    if (step->d4_word_prepend) {
        stats->d4_word_prepends++;
    }
    if (step->range_check_aux_called) {
        stats->range_check_aux_calls++;
    }
    if (step->normalized_packet_bytes) {
        stats->normalized_packet_records++;
    }
    if (step->copied_packet_tail) {
        stats->copied_packet_tail_bytes += step->packet_copy_bytes;
    }
    if (step->command_variant_called) {
        stats->command_variant_calls++;
        runtime->parser_runtime_flags |= 0x08U;
    }
    if (step->heap_gate_forced_command) {
        stats->heap_gate_command_fallbacks++;
    }
    if (step->parse_dirty_set) {
        stats->parse_dirty_sets++;
        runtime->parse_dirty_flags |= 0x02U;
    }
    if (step->status_extend_set) {
        stats->status_extend_sets++;
        runtime->status_extend_4976 |= 0x04U;
    }
    if (step->runtime_mismatch_dirty_set) {
        stats->runtime_mismatch_dirty_sets++;
        runtime->runtime_flags |= 0x08U;
    }

    switch (step->fixed_dispatch) {
        case WP_PROCESS_FIXED_DISPATCH_TEXT_OR_SINGLE:
            stats->dispatch_text_or_single++;
            break;
        case WP_PROCESS_FIXED_DISPATCH_FIXED:
            stats->dispatch_fixed_packet++;
            break;
        case WP_PROCESS_FIXED_DISPATCH_VARIABLE:
            stats->dispatch_variable_packet++;
            break;
        case WP_PROCESS_FIXED_DISPATCH_COMMAND:
            stats->dispatch_command_parser++;
            break;
        case WP_PROCESS_FIXED_DISPATCH_NONE:
        default:
            break;
    }

    switch (step->route) {
        case WP_PROCESS_ROUTE_DIRECT_TEXT_APPEND:
            stats->direct_text_appends++;
            runtime->cursor = (uint16_t)(runtime->cursor + 1U);
            runtime->record_aux_4b34++;
            break;
        case WP_PROCESS_ROUTE_DIRECT_C0_EXTENDED_APPEND:
            stats->direct_c0_extended_appends++;
            runtime->cursor = (uint16_t)(runtime->cursor + 1U);
            runtime->record_aux_4b34 += 2;
            break;
        case WP_PROCESS_ROUTE_EMIT_OR_MEASURE_WINDOW:
            stats->emit_or_measure_windows++;
            break;
        case WP_PROCESS_ROUTE_RECORD_FLAGS_MERGE:
            stats->record_flags_merges++;
            break;
        case WP_PROCESS_ROUTE_BOOTSTRAP_SECONDARY_LINE:
            stats->bootstrap_secondary_lines++;
            break;
        case WP_PROCESS_ROUTE_DEEP_LAYOUT_RECORD:
            stats->deep_layout_records++;
            if (step->d4_deep_subcommand) {
                stats->d4_deep_subcommands++;
            }
            if (step->psp_depth_pulse) {
                runtime->parse_depth_counter++;
                stats->final_psp_depth = runtime->parse_depth_counter;
            }
            if (step->measured_span_reset_hint) {
                stats->measured_span_reset_hints++;
                (void)layout_reset_cursor_aliases_variant_table(runtime);
            }
            if (step->postprocess_reconcile_hint) {
                stats->postprocess_reconcile_hints++;
            }
            if (step->update_depth_incremented) {
                runtime->update_depth++;
                stats->update_depth_increments++;
            }
            break;
        case WP_PROCESS_ROUTE_MEASURE_DIRTY_RECONCILE:
            stats->measure_dirty_reconcile_calls++;
            break;
        case WP_PROCESS_ROUTE_EMIT_SCRATCH_PACK:
            stats->emit_scratch_pack_calls++;
            break;
        case WP_PROCESS_ROUTE_SPAN_TABLE_SELECT:
            stats->span_table_select_calls++;
            break;
        case WP_PROCESS_ROUTE_REPLAY_DEPTH_INVOKE:
            stats->replay_depth_invocations++;
            runtime->record_replay_depth++;
            break;
        case WP_PROCESS_ROUTE_RANGE_AUX_TEXT_OR_CONTROL:
        case WP_PROCESS_ROUTE_RANGE_AUX_FIXED_PACKET:
        case WP_PROCESS_ROUTE_RANGE_AUX_VARIABLE_PACKET:
        case WP_PROCESS_ROUTE_COMMAND_VARIANT_FALLBACK:
        case WP_PROCESS_ROUTE_NONE:
        default:
            break;
    }

    return true;
}

bool wp_parser_process_apply_record(WpLayoutGlobals *runtime,
                                    const WpRecord *rec,
                                    WpParserProcessStats *stats)
{
    WpParserProcessStep step;

    if (runtime == NULL || rec == NULL || stats == NULL) {
        return false;
    }
    if (!wp_parser_process_plan_record(runtime, rec, &step)) {
        return false;
    }
    stats->records_seen++;
    stats->bytes_consumed += rec->length;
    wp_parser_process_count_record_status(rec, stats);
    return wp_parser_process_apply_step(runtime, &step, stats);
}

bool wp_parser_process_run_stream(WpLayoutGlobals *wl, WpParserProcessStats *stats)
{
    WpLayoutGlobals cursor;
    WpLayoutGlobals runtime;
    WpParserProcessStats local_stats;
    bool ok = true;

    if (wl == NULL || stats == NULL) {
        return false;
    }

    wp_parser_process_stats_clear(&local_stats);
    cursor = *wl;
    runtime = *wl;

    runtime.runtime_flags &= 0xFCU;
    local_stats.initial_runtime_flag_clears++;

    while (cursor.record_used_bytes > 0) {
        WpRecord rec;
        int before = cursor.record_used_bytes;

        wp_parser_consume_record(&cursor, &rec);
        if (rec.length == 0U || cursor.record_used_bytes >= before) {
            wp_record_free(&rec);
            ok = false;
            break;
        }
        if (!wp_parser_process_apply_record(&runtime, &rec, &local_stats)) {
            ok = false;
        }
        wp_record_free(&rec);
    }

    local_stats.final_runtime_flags = runtime.runtime_flags;
    local_stats.final_parser_runtime_flags = runtime.parser_runtime_flags;
    local_stats.final_parse_dirty_flags = runtime.parse_dirty_flags;
    local_stats.final_status_extend = runtime.status_extend_4976;
    local_stats.final_update_depth = runtime.update_depth;
    local_stats.final_psp_depth = runtime.parse_depth_counter;
    *stats = local_stats;
    return ok && local_stats.incomplete_records == 0U && local_stats.mismatched_trailers == 0U;
}

bool wp_parser_process_run_loaded_file(WpLoadedFile *file, WpParserProcessStats *stats)
{
    WpLayoutGlobals wl;

    if (file == NULL || stats == NULL) {
        return false;
    }
    memset(&wl, 0, sizeof(wl));
    if (!wp_file_bind_primary_stream(file, &wl, 4096U)) {
        return false;
    }
    return wp_parser_process_run_stream(&wl, stats);
}

bool wp_parser_process_run_file(const char *filename, WpParserProcessStats *stats)
{
    WpLoadedFile file;
    bool ok;

    if (filename == NULL || stats == NULL) {
        return false;
    }
    if (!wp_file_load_body(filename, &file)) {
        return false;
    }
    ok = wp_parser_process_run_loaded_file(&file, stats);
    wp_file_free(&file);
    return ok;
}

/* --- Ported Monolith Functions --- */

/**
 * parser_process_token_stream @ 1000:1e78
 */
uint16_t __cdecl16near parser_process_token_stream(WpLayoutGlobals *wl)
{
    uint16_t ax;
    uint8_t bal;
    uint16_t route_result;
    
    if (wl->parse_depth_counter > 32) return 0xFFFFU;

    wl->runtime_flags &= 0xfc;
    if ((wl->runtime_flags & 0x24) != 0) {
        prepend_byte_to_buffer(wl, 0);
        set_mode_or_status_bits(wl);
        ax = parser_consume_next_input_byte(wl);
    } else {
        ax = (uint16_t)wl->stream_resume_token;
    }

    if (ax == 0xFFFFU) return 0xFFFFU;

    while (true) {
        if (wl->postprocess_mode > 0) {
            ax = (uint16_t)layout_stream_offset_bump(wl, ax);
        }

        if ((wl->emit_flags & 0x16) == 0) {
            if ((uint8_t)ax > 0x20 && (uint8_t)ax < 0x80) {
                layout_increment_cursor_and_span_aux_route_stage_1(wl);
                record_append_byte_under_position_gate(wl, (uint8_t)ax);
                return ax;
            }
            if ((uint8_t)ax == 0xc0) {
                consume_word_from_secondary_buffer(wl);
                if (wl->postprocess_mode > 0) {
                    ax = (uint16_t)layout_stream_offset_bump(wl, ax);
                }
                layout_increment_cursor_and_span_aux_route_stage_2(wl);
                append_byte_to_buffer(wl, (uint8_t)ax);
                append_word_to_buffer(wl, 0);
                parser_consume_next_input_byte(wl);
                record_append_byte_under_position_gate(wl, 0);
                return ax;
            }
        }

        if ((uint8_t)ax == 0xd4) {
             /* Command variants, fixed/variable packets */
             wl->parse_depth_counter++;
             if ((wl->measured_span_flags & 1) != 0) {
                 layout_reset_cursor_aliases_variant_table(wl);
             }
             if (wl->postprocess_mode != 0) {
                 layout_reconcile_line_build_span_words(wl);
             }
             increment_layout_state_update_depth(wl);
             
             bal = layout_variant_balance_check(wl);
             if (bal > 0xbf) {
                 route_result = parser_parse_and_append_command_token_variant(wl);
                 wl->parse_depth_counter--;
                 return route_result;
             }
             
             if (bal > 0x7f) {
                 route_result = (uint16_t)layout_measure_dirty_reconcile(wl, bal);
                 wl->parse_depth_counter--;
                 return route_result;
             }
             
             if (bal < 0x20) {
                 route_result = (uint16_t)layout_emit_scratch_pack(wl, bal, 0);
                 wl->parse_depth_counter--;
                 return route_result;
             }
             
             if (bal == 0x20) {
                 route_result = (uint16_t)layout_span_table_select(wl);
                 wl->parse_depth_counter--;
                 return route_result;
             }
             
             parser_record_replay_depth_increment_and_invoke(wl);
             wl->parse_depth_counter--;
             return ax;
        }

        /* Complex command dispatch path */
        prepend_byte_to_buffer(wl, (uint8_t)ax);
        
        if ((wl->emit_flags & 4) != 0) {
            layout_emit_or_measure_line_window(wl);
            if (wl->record_extension_needs_flush != 0) {
                return ax;
            }
        } else if ((wl->emit_flags & 0x10) != 0) {
            layout_bootstrap_line_from_secondary_gate(wl);
            return ax;
        }

        if ((uint8_t)ax >= 0x80) {
             return (uint16_t)layout_measure_dirty_reconcile(wl, (uint8_t)ax);
        } else if ((uint8_t)ax < 0x20) {
             return (uint16_t)layout_emit_scratch_pack(wl, (uint8_t)ax, 0);
        } else if ((uint8_t)ax == 0x20) {
             return (uint16_t)layout_span_table_select(wl);
        }

        /* Fallback for other codes */
        if ((wl->heap_control_flags_4bf1 & 4) != 0) {
            return parser_parse_and_append_command_token_variant(wl);
        }
        
        parser_record_replay_depth_increment_and_invoke(wl);
        
        /* If we prepended, we MUST return now to avoid infinite loop. */
        return ax;
    }
}

/**
 * parser_inner_token_consume_state_machine @ 1000:0f86
 */
uint32_t __cdecl16near parser_inner_token_consume_state_machine(WpLayoutGlobals *wl, uint16_t in_AX, uint16_t in_DX)
{
    unsigned guard;

    guard = 0;
    backup_and_clear_irq_shadow_flags(wl);
    while (true) {
        layout_merge_secondary_into_primary_cursor(wl);
        if (wl->secondary_record_used_bytes == 0) break;
        if (guard++ > 4096U) break;
        if (parser_consume_next_input_byte(wl) == 0xFFFFU) break;
        if (parser_process_token_stream(wl) == 0xFFFFU) break;
        if (wl->status_dirty_flags & 0x48U) break;
    }

    layout_check_parser_gate_and_restore_mode(wl);
    restore_irq_shadow_flags(wl);
    return ((uint32_t)in_DX << 16) | in_AX;
}

/**
 * parser_run_gated_consume_classify_loop @ 1000:195e
 */
uint16_t __cdecl16near parser_run_gated_consume_classify_loop(WpLayoutGlobals *wl, uint16_t in_AX, uint16_t in_BX, uint16_t in_CX)
{
    /* BX:CX is the position gate (32-bit). */
    while (wl->position_gate_remaining_high > in_BX || 
          (wl->position_gate_remaining_high == in_BX && wl->position_gate_remaining_low > in_CX)) {

        uint8_t token = consume_byte_from_buffer_with_position_gate(wl);
        parser_classify_or_handle_token(wl, token);
    }
    
    return in_AX;
}

/**
 * parser_consume_process_loop_until_pf_clear @ 1000:1dfd
 */
void __cdecl16near parser_consume_process_loop_until_pf_clear(WpLayoutGlobals *wl)
{
    if (parser_consume_next_input_byte(wl) == 0xFFFFU) return;
    parser_process_token_stream(wl);
}

/**
 * consume_gated_byte_and_classify @ 1000:1e08
 */
void __cdecl16near consume_gated_byte_and_classify(WpLayoutGlobals *wl)
{
    uint8_t token = consume_byte_from_buffer_with_position_gate(wl);
    parser_classify_or_handle_token(wl, token);
}

/* Function: parser_classify_until_d4_and_no_op @ 1000:0f15 */
void __cdecl16near parser_classify_until_d4_and_no_op(WpLayoutGlobals *wl)
{
    uint8_t token;
    set_mode_or_status_bits(wl);
    parser_run_gated_consume_classify_loop(wl, 0, 0, 0);
    do {
        uint8_t token_byte = consume_byte_from_buffer_with_position_gate(wl);
        token = (uint8_t)parser_classify_or_handle_token(wl, token_byte);
    } while (token == 0xd4U);
    set_mode_or_status_bits(wl);
    if (parser_consume_next_input_byte(wl) == 0xFFFFU) return;
    parser_bool_expr_eval_order_no_op(wl, 0);
    if (token == 0xd4U) {
        parser_prepend_byte_then_return(wl);
        if ((wl->decode_io_flags_8749 & 0x10U) != 0) {
            uint16_t uVar1 = wl->gate_shadow_776c;
            wl->gate_shadow_776a = wl->gate_shadow_776e;
            wl->gate_shadow_7768 = uVar1;
            wl->decode_io_flags_8749 &= 0xefU;
            parser_classify_until_d4_and_no_op(wl);
        }
    }
}

/* Function: parser_bool_expr_eval_order_no_op @ 1000:101a */
uint16_t __cdecl16near parser_bool_expr_eval_order_no_op(WpLayoutGlobals *wl, uint16_t in_AX)
{
    parser_no_op_body_proxy(wl);
    return in_AX;
}

/* Function: parser_loop_inner_until_record_checkpoint_matches_ah @ 1000:1025 */
void __cdecl16near parser_loop_inner_until_record_checkpoint_matches_ah(WpLayoutGlobals *wl, uint8_t extraout_AH)
{
    uint8_t match;
    do {
        parser_inner_token_consume_state_machine(wl, 0, 0);
        /* 0x4b2e word is primary_record pointer */
        match = *(uint8_t *)(wl->primary_record.word - 2);
    } while (match != extraout_AH);
}

/* Function: parser_consume_and_prepend_byte_then_return @ 1000:1037 */
void __cdecl16near parser_consume_and_prepend_byte_then_return(WpLayoutGlobals *wl, uint8_t in_AL)
{
    uint16_t uVar1;
    parser_classify_or_handle_token(wl, in_AL);
    set_mode_or_status_bits(wl);
    uVar1 = (uint16_t)parser_consume_next_input_byte(wl);
    if (uVar1 == 0xFFFFU) return;
    prepend_byte_to_buffer(wl, (uint8_t)uVar1);
    route_far_jump_shell_segment_proxy(wl);
}

/* Function: parser_prepend_byte_then_return @ 1000:1040 */
void __cdecl16near parser_prepend_byte_then_return(WpLayoutGlobals *wl)
{
    prepend_byte_to_buffer(wl, 0);
    route_far_jump_shell_segment_proxy(wl);
}

/* Function: parser_check_al_vs_bl_bh_or_stride @ 1000:0f5d */
void __cdecl16near parser_check_al_vs_bl_bh_or_stride(WpLayoutGlobals *wl, uint8_t in_AL, uint8_t in_BL, uint8_t in_BH, uint8_t *out_CF)
{
  bool bVar1;
  
  if (((in_AL != in_BH) && (in_AL != in_BL)) &&
     (((bVar1 = in_AL < 0x80, bVar1 && (bVar1 = in_AL < 0xd, 0xd < in_AL)) ||
      ((scan_memory_stride_3_for_char(wl), bVar1 || (in_BH != 0xe3)))))) {
    return;
  }
  return;
}


/* Function: parser_consume_gated_byte_until_ah_and_loop_pf @ 1000:0e42 */
void __cdecl16near parser_consume_gated_byte_until_ah_and_loop_pf(WpLayoutGlobals *wl, uint8_t extraout_AH)
{
  uint16_t unaff_ES;
  uint16_t unaff_DS;
  uint8_t in_CF = 0;
  
  do {
    parser_io_flags_set_4_and_backup_irq(wl, 0, 0);
    if ((bool)in_CF) {
      return;
    }
    consume_gated_byte_and_classify(wl);
    in_CF = *(uint8_t *)(wl->secondary_record.word + 1) < extraout_AH;
  } while (*(uint8_t *)(wl->secondary_record.word + 1) != extraout_AH);
  set_mode_or_status_bits(wl);
  parser_consume_process_loop_until_pf_clear(wl);
  return;
}

/* Function: layout_handle_decode_io_flags_bit1 @ 1000:0e5e */
void __cdecl16near layout_handle_decode_io_flags_bit1(WpLayoutGlobals *wl)
{
  uint16_t unaff_DS;
  
  if ((wl->decode_io_flags_8749 & 1) != 0) {
    if (wl->restore_mode == '\0') {
      if (wl->parser_gate_5c05 != '\0') {
        parser_classify_until_d4_and_no_op(wl);
      }
    }
    else {
      if (wl->restore_mode == '\v') {
        wl->decode_io_flags_8749 = wl->decode_io_flags_8749 | 8;
      }
      layout_handle_restore_mode(wl);
      if ((wl->parser_gate_5c05 != '\0') && ((wl->decode_io_flags_8749 & 2) == 0)) {
        if (wl->restore_mode == '\0') {
          wl->decode_io_flags_8749 = wl->decode_io_flags_8749 | 2;
          wl->gate_shadow_7768 = wl->position_gate_hi_u16;
          wl->gate_shadow_776a = wl->position_gate_lo_u16;
        }
        else {
          wl->gate_shadow_776c = wl->position_gate_hi_u16;
          wl->gate_shadow_776e = wl->position_gate_lo_u16;
          layout_handle_restore_mode(wl);
          wl->gate_shadow_7768 = wl->position_gate_hi_u16;
          wl->gate_shadow_776a = wl->position_gate_lo_u16;
          parser_classify_until_d4_and_no_op(wl);
          set_mode_or_status_bits(wl);
          parser_run_gated_consume_classify_loop(wl, 0, 0, 0);
          wl->decode_io_flags_8749 = wl->decode_io_flags_8749 | 0x12;
        }
      }
    }
  }
  return;
}

/* Function: parser_io_flags_set_4_and_backup_irq @ 1000:0db1 */
uint32_t __cdecl16near parser_io_flags_set_4_and_backup_irq(WpLayoutGlobals *wl, uint16_t in_AX, uint16_t in_DX)
{
  int extraout_DX;
  int extraout_DX_00;
  int iVar1;
  int extraout_DX_01;
  int extraout_DX_02;
  int extraout_DX_03;
  uint16_t unaff_DS;
  uint8_t uVar2;
  bool bVar3;
  uint8_t token;
  
  wl->decode_io_flags_8749 = wl->decode_io_flags_8749 | 4;
  backup_and_clear_irq_shadow_flags(wl);
  uVar2 = false;
  if ((wl->decode_io_flags_8749 & 4) == 0) {
    token = consume_byte_from_buffer_with_position_gate(wl);
    if ((bool)uVar2) goto LAB_1000_0e19;
    goto LAB_1000_0de3;
  }
  uVar2 = 0;
  wl->decode_io_flags_8749 = wl->decode_io_flags_8749 & 0xfb;
  iVar1 = extraout_DX;
  token = 0;
  while ((iVar1 != 1 || (route_call_shell_overlay_io_decode(wl), !(bool)uVar2))) {
    layout_position_gate_advance_helper(wl);
    token = consume_byte_from_buffer_with_position_gate(wl);
        if ((bool)uVar2) {
LAB_1000_0e19:
      layout_handle_decode_io_flags_bit1(wl);
      if ((bool)uVar2) goto LAB_1000_0e39;
      consume_gated_byte_and_classify(wl);
      set_mode_or_status_bits(wl);
      uVar2 = 0;
      iVar1 = extraout_DX_03;
      if ((wl->decode_io_flags_8749 & 8) != 0) {
        wl->decode_io_flags_8749 = wl->decode_io_flags_8749 & 0xf7;
                    /* WARNING: Subroutine does not return */
        route_far_jump_shell_segment_proxy(wl);
      }
    }
    else {
      parser_check_al_vs_bl_bh_or_stride(wl, 0, 0, 0, &uVar2);
      if (!(bool)uVar2) {
        record_append_byte_under_position_gate(wl, 0);
        goto LAB_1000_0e39;
      }
      uVar2 = 0;
      bVar3 = (wl->decode_io_flags_8749 & 1) == 0;
        if ((bVar3) || (parser_bool_expr_eval_order_no_op(wl, 0), !bVar3)) {
        LAB_1000_0de3:
            parser_classify_or_handle_token(wl, token);
            iVar1 = extraout_DX_00;
        }
      else {
        parser_consume_and_prepend_byte_then_return(wl, token);
        iVar1 = extraout_DX_01;
        if (!(bool)uVar2) {
          parser_merge_cursor_consume_loop_then_finalize_layout_state(wl, 0, 0);
          iVar1 = extraout_DX_02;
        }
      }
    }
  }
  layout_check_parser_gate_and_restore_mode(wl);
LAB_1000_0e39:
  restore_irq_shadow_flags(wl);
  return (((uint32_t)in_DX << 16) | in_AX);
}

void __cdecl16near parser_no_op_body_proxy(WpLayoutGlobals *wl) { (void)wl; }
void __cdecl16near parser_carry_chain_eval_order_no_op(WpLayoutGlobals *wl) { (void)wl; }
void __cdecl16near parser_unused_void_proxy(WpLayoutGlobals *wl) { (void)wl; }
uint32_t __cdecl16near layout_no_op_return(WpLayoutGlobals *wl)
{
  parser_no_op_body_proxy(wl);
  if ((wl->runtime_flags & 0x20) == 0 && wl->carry_width != 0) {
    wl->status_dirty_flags |= 0x40;
  }
  return 0;
}

uint16_t __cdecl16near layout_no_op_span_checkpoint(WpLayoutGlobals *wl, uint16_t in_ax)
{
  (void)wl;
  return in_ax;
}

uint16_t __cdecl16near parser_parse_and_append_command_token(WpLayoutGlobals *wl)
{
  return parser_parse_and_append_command_token_variant(wl);
}

void __cdecl16near check_layout_state_update_gate(WpLayoutGlobals *wl, uint8_t *in_CF)
{
  if (in_CF) {
    *in_CF = (uint8_t)(((wl->runtime_flags & 0x80) != 0) ||
                       (((wl->state_flags & 2) != 0) && (wl->update_depth > 0)));
  }
}

uint16_t __cdecl16near parser_loop_iteration_eval_order_no_op(WpLayoutGlobals *wl)
{
  uint16_t ax;
  parser_no_op_body_proxy(wl);
  ax = (uint16_t)scan_memory_stride_3_for_char(wl);
  return ax;
}

void __cdecl16near parser_nested_branch_eval_order_no_op(WpLayoutGlobals *wl)
{
  parser_no_op_body_proxy(wl);
}

uint16_t __cdecl16near parser_parse_and_append_command_token_variant(WpLayoutGlobals *wl)
{
  uint16_t b = parser_consume_next_input_byte(wl);
  if (b == 0xFFFFU) return 0xFFFFU;

  return parser_classify_or_handle_token(wl, (uint8_t)b);
}

void __cdecl16near parser_record_replay_depth_increment_and_invoke(WpLayoutGlobals *wl)
{
  wl->record_replay_depth = (char)(wl->record_replay_depth + 1);
  (void)parser_main_record_loop_with_reentry_guard(wl);
  wl->record_replay_depth = (char)(wl->record_replay_depth - 1);
}

uint16_t __cdecl16near layout_bootstrap_line_from_secondary_gate(WpLayoutGlobals *wl)
{
  wl->emit_flags &= (uint8_t)~0x10;
  parser_carry_chain_eval_order_no_op(wl);
  if (wl->secondary_record_used_bytes < 0x0c) {
    (void)invoke_overlay_probe_secondary_record(wl);
  }
  if (wl->record_buffer_space < 0x800) {
    invoke_overlay_expand_primary_buffer(wl);
  }
  {
    uint16_t *out = (uint16_t *)wl->primary_record.as_record_p;
    out[0] = 0x05d4;
    out[1] = 0x05d4;
    out[2] = wl->line_build_word_51f1;
    out[3] = wl->line_build_word_51f3;
    wl->primary_record.as_record_p = out + 4;
    wl->record_used_bytes += 8;
    wl->record_buffer_space -= 8;
  }
  layout_finalize_record_envelope_commit(wl);
  wl->span_compare_word_51fb = (uint16_t)(layout_get_active_span_total_width(wl) - 8);
  wl->span_compare_word_51ff = (uint16_t)(layout_get_active_span_total_width(wl) - 6);
  return 0;
}

uint8_t __cdecl16near layout_scan_memory_stride_3_for_char(WpLayoutGlobals *wl)
{
  return scan_memory_stride_3_for_char(wl);
}

uint8_t __cdecl16near scan_memory_stride_3_for_char(WpLayoutGlobals *wl)
{
  uint8_t *p;
  if (wl->record_used_bytes <= 0) {
    return 0;
  }
  p = (uint8_t *)wl->primary_record.as_record_p;
  return p[-1];
}

/* 1000:0ca2-0d5d batch (adapted to wl-signature ABI). */
uint8_t __cdecl16near consume_and_prepend_byte_input(WpLayoutGlobals *wl)
{
  uint16_t b = parser_consume_next_input_byte(wl);
  if (b == 0xFFFFU) return 0xFF;
  prepend_byte_to_buffer(wl, (uint8_t)b);
  return (uint8_t)b;
}

uint16_t __cdecl16near consume_and_prepend_word_secondary(WpLayoutGlobals *wl)
{
  uint16_t w = consume_word_from_secondary_buffer(wl);
  prepend_word_to_buffer(wl, w);
  return w;
}

void __cdecl16near layout_table_search_or_scan(WpLayoutGlobals *wl)
{
  byte bVar1;
  int iVar2 = wl->variant_total;

  wl->runtime_flags |= 0x80;
  bVar1 = wl->parser_runtime_flags;
  wl->parser_runtime_flags |= 0x10;
  {
    uint16_t gate = allocate_layout_gate_mask_bit(wl);

    layout_parse_token_stream_until_gate_overflow(wl, gate);
  }
  layout_parse_field_whitespace_position_gate(wl);
  wl->runtime_flags |= 8;
  free_layout_gate_mask_bit(wl);
  wl->parser_runtime_flags &= 0xef;
  wl->parser_runtime_flags |= bVar1 & 0x10;
  if (iVar2 != wl->variant_total) {
    wl->status_dirty_flags |= 0x48;
  }
  wl->runtime_flags &= 0x6f;
}

void __cdecl16near copy_layout_state_words_to_destination(WpLayoutGlobals *wl)
{
  static uint8_t phase = 0;
  uint16_t *dst = (uint16_t *)wl->primary_record.as_record_p;
  const uint16_t *src = (const uint16_t *)&wl->saved_snapshot;
  uint16_t idx = (uint16_t)(phase * 2);

  if (wl->record_buffer_space < 4) {
    invoke_overlay_expand_primary_buffer(wl);
    dst = (uint16_t *)wl->primary_record.as_record_p;
  }
  dst[0] = src[idx % 6];
  dst[1] = src[(idx + 1) % 6];
  wl->primary_record.as_record_p = dst + 2;
  wl->record_used_bytes += 4;
  wl->record_buffer_space -= 4;
  phase = (uint8_t)((phase + 1) % 3);
}
Commit message
This repository is read-only for this account.
Repository snapshot

Current branch
main
Visibility
public
Your access
Read
Remote
None
File activity

View file history