Word Unperfect - XT-Emporium

File editor

#include "wp_parser_gate.h"

#include "wp_layout_metrics.h"
#include "wp_record_stream.h"
#include "wp_layout_flow.h"
#include "wp_parser_process.h"
#include <string.h>

extern void __cdecl16near route_far_jump_shell_segment_proxy(WpLayoutGlobals *wl);
extern void __cdecl16near layout_parse_token_stream_until_gate_overflow(WpLayoutGlobals *wl, uint16_t gate);

static uint16_t wp_u16_mask(uint value)
{
    return (uint16_t)(value & 0xffffU);
}

static uint16_t wp_record_space_u16(const WpLayoutGlobals *wl)
{
    return wl == NULL ? 0U : (uint16_t)(wl->record_buffer_space & 0xffffU);
}

void wp_parser_gate_result_clear(WpParserGateResult *result)
{
    if (result != NULL) {
        memset(result, 0, sizeof(*result));
    }
}

uint16_t wp_parser_gate_infer_active_mask(const WpLayoutGlobals *wl)
{
    uint16_t mask;
    uint16_t active;

    if (wl == NULL) {
        return 0U;
    }

    /* The original free routine is passed AX by the caller.  Earlier host glue
     * lost that argument, so the wrapper chooses the most recently allocated
     * active bit: allocation scans upward from bit 0, so the highest live bit is
     * the best deterministic LIFO approximation for nested host calls. */
    active = wp_u16_mask(wl->emit_gate_mask_51bf);
    for (mask = 0x8000U; mask != 0U; mask >>= 1U) {
        if ((active & mask) != 0U) {
            return mask;
        }
    }
    return 0U;
}

static bool wp_tail_has_zero_gate_reservation(const WpLayoutGlobals *wl)
{
    const uint8_t *tail;
    size_t i;

    if (wl == NULL || wl->primary_record.as_record_p == NULL || wl->record_used_bytes < 10) {
        return false;
    }

    tail = (const uint8_t *)wl->primary_record.as_record_p - 10;
    for (i = 0; i < 10U; ++i) {
        if (tail[i] != 0U) {
            return false;
        }
    }
    return true;
}

static void wp_release_tail_gate_reservation(WpLayoutGlobals *wl, WpParserGateResult *result)
{
    if (!wp_tail_has_zero_gate_reservation(wl)) {
        return;
    }

    wl->primary_record.as_record_p = (uint16_t *)((uint8_t *)wl->primary_record.as_record_p - 10);
    wl->record_used_bytes -= 10;
    wl->record_buffer_space = (uint16_t)(wl->record_buffer_space + 10U);
    if (result != NULL) {
        result->reserve_words_released = 5U;
        result->free_released_tail_reservation = true;
    }
}

uint16_t wp_parser_gate_allocate_mask_bit(WpLayoutGlobals *wl,
                                          WpParserGateResult *out_result)
{
    WpParserGateResult result;
    uint16_t mask;
    int i;

    if (out_result != NULL) {
        memset(out_result, 0, sizeof(*out_result));
    }
    if (wl == NULL) {
        return 0U;
    }

    memset(&result, 0, sizeof(result));
    result.emit_mask_before = wp_u16_mask(wl->emit_gate_mask_51bf);
    result.path_mask_before = wp_u16_mask(wl->record_path_mask_51c2);
    result.record_used_before = wl->record_used_bytes;
    result.record_space_before = wp_record_space_u16(wl);

    mask = 1U;
    for (i = 0; i < 16; ++i) {
        if ((wp_u16_mask(wl->emit_gate_mask_51bf) & mask) == 0U) {
            wl->emit_gate_mask_51bf = wp_u16_mask(wl->emit_gate_mask_51bf | mask);
            wl->record_path_mask_51c2 = wp_u16_mask(wl->record_path_mask_51c2 | mask);
            result.allocated_mask = mask;

            if (wl->primary_record.as_record_p != NULL) {
                /* Port of the five append_word_to_buffer(wl, 0) calls at
                 * 1000:0d3f..0d57.  The reservation is intentionally zeroed;
                 * the parser later writes/consumes marker words around it. */
                append_word_to_buffer(wl, 0U);
                append_word_to_buffer(wl, 0U);
                append_word_to_buffer(wl, 0U);
                append_word_to_buffer(wl, 0U);
                append_word_to_buffer(wl, 0U);
                result.reserve_words_appended = 5U;
            } else {
                result.allocation_skipped_no_buffer = true;
            }

            result.emit_mask_after = wp_u16_mask(wl->emit_gate_mask_51bf);
            result.path_mask_after = wp_u16_mask(wl->record_path_mask_51c2);
            result.record_used_after = wl->record_used_bytes;
            result.record_space_after = wp_record_space_u16(wl);
            if (out_result != NULL) {
                *out_result = result;
            }
            return mask;
        }
        mask = (uint16_t)(mask << 1U);
    }

    result.allocation_exhausted = true;
    result.emit_mask_after = wp_u16_mask(wl->emit_gate_mask_51bf);
    result.path_mask_after = wp_u16_mask(wl->record_path_mask_51c2);
    result.record_used_after = wl->record_used_bytes;
    result.record_space_after = wp_record_space_u16(wl);
    if (out_result != NULL) {
        *out_result = result;
    }
    return 0U;
}

bool wp_parser_gate_free_mask_bit(WpLayoutGlobals *wl,
                                  uint16_t mask,
                                  WpParserGateResult *out_result)
{
    WpParserGateResult result;

    if (out_result != NULL) {
        memset(out_result, 0, sizeof(*out_result));
    }
    if (wl == NULL) {
        return false;
    }

    memset(&result, 0, sizeof(result));
    result.requested_mask = mask;
    result.emit_mask_before = wp_u16_mask(wl->emit_gate_mask_51bf);
    result.path_mask_before = wp_u16_mask(wl->record_path_mask_51c2);
    result.record_used_before = wl->record_used_bytes;
    result.record_space_before = wp_record_space_u16(wl);

    if (mask == 0U) {
        mask = wp_parser_gate_infer_active_mask(wl);
        result.free_inferred_mask = true;
    }

    if (mask == 0U || (wp_u16_mask(wl->emit_gate_mask_51bf) & mask) == 0U) {
        result.free_missing_mask = true;
        result.emit_mask_after = wp_u16_mask(wl->emit_gate_mask_51bf);
        result.path_mask_after = wp_u16_mask(wl->record_path_mask_51c2);
        result.record_used_after = wl->record_used_bytes;
        result.record_space_after = wp_record_space_u16(wl);
        if (out_result != NULL) {
            *out_result = result;
        }
        return false;
    }

    result.freed_mask = mask;
    wp_release_tail_gate_reservation(wl, &result);
    wl->emit_gate_mask_51bf = wp_u16_mask(wl->emit_gate_mask_51bf & (uint16_t)~mask);
    result.emit_mask_after = wp_u16_mask(wl->emit_gate_mask_51bf);
    result.path_mask_after = wp_u16_mask(wl->record_path_mask_51c2);
    result.record_used_after = wl->record_used_bytes;
    result.record_space_after = wp_record_space_u16(wl);
    if (out_result != NULL) {
        *out_result = result;
    }
    return true;
}

bool wp_parser_gate_set_mode_or_status_bits(WpLayoutGlobals *wl,
                                            WpParserGateResult *out_result)
{
    WpParserGateResult result;
    WpParserGateResult alloc_result;
    WpParserGateResult free_result;
    uint16_t saved_flags;
    uint16_t gate;
    bool measured_span_active_before;

    if (out_result != NULL) {
        memset(out_result, 0, sizeof(*out_result));
    }
    if (wl == NULL) {
        return false;
    }

    memset(&result, 0, sizeof(result));
    result.emit_mask_before = wp_u16_mask(wl->emit_gate_mask_51bf);
    result.path_mask_before = wp_u16_mask(wl->record_path_mask_51c2);
    result.parser_runtime_before = wl->parser_runtime_flags;
    result.decode_flags_before = wl->decode_io_flags_8749;
    result.runtime_flags_before = wl->runtime_flags;
    result.record_used_before = wl->record_used_bytes;
    result.record_space_before = wp_record_space_u16(wl);

    measured_span_active_before = (wl->measured_span_flags & 0x01U) != 0U;

    saved_flags = (uint16_t)((((uint16_t)wl->decode_io_flags_8749 << 8U) |
                              (uint16_t)wl->parser_runtime_flags) & 0xff14U);
    result.saved_mode_flags = saved_flags;

    wl->decode_io_flags_8749 = 0U;
    wl->parser_runtime_flags |= 0x10U;
    result.parser_runtime_bit10_set = true;

    gate = wp_parser_gate_allocate_mask_bit(wl, &alloc_result);
    result.allocated_mask = gate;
    result.reserve_words_appended = alloc_result.reserve_words_appended;
    result.allocation_exhausted = alloc_result.allocation_exhausted;
    result.allocation_skipped_no_buffer = alloc_result.allocation_skipped_no_buffer;

    if ((wl->runtime_flags & 0x20U) != 0U) {
        result.overlay_jump_would_run = true;
        route_far_jump_shell_segment_proxy(wl);
    } else {
        layout_parse_token_stream_until_gate_overflow(wl, gate);
        result.parse_stream_runs++;
        (void)wp_parser_gate_free_mask_bit(wl, gate, &free_result);
        result.freed_mask = free_result.freed_mask;
        result.reserve_words_released = free_result.reserve_words_released;
        result.free_released_tail_reservation = free_result.free_released_tail_reservation;

        wl->parser_runtime_flags &= 0xEBU;
        wl->parser_runtime_flags |= (uint8_t)(saved_flags & 0xffU);
        wl->decode_io_flags_8749 = (uint8_t)(saved_flags >> 8U);
        result.parser_runtime_bits_restored = true;
        result.decode_flags_restored = true;

        wl->measured_span_shadow = 0U;
        result.measured_span_shadow_cleared = true;
        if (((wl->measured_span_flags & 0x01U) != 0U) || measured_span_active_before) {
            WpLayoutMeasuredSpanResetResult reset;
            if (wp_layout_reset_cursor_aliases_variant_table(wl, &reset)) {
                result.measured_span_alias_reset = reset.cursor_changed || reset.low_active_flag_cleared;
            }
        }
        wl->runtime_flags &= 0xFEU;
        result.runtime_flag0_cleared = (result.runtime_flags_before & 0x01U) != 0U;
    }

    result.emit_mask_after = wp_u16_mask(wl->emit_gate_mask_51bf);
    result.path_mask_after = wp_u16_mask(wl->record_path_mask_51c2);
    result.parser_runtime_after = wl->parser_runtime_flags;
    result.decode_flags_after = wl->decode_io_flags_8749;
    result.runtime_flags_after = wl->runtime_flags;
    result.record_used_after = wl->record_used_bytes;
    result.record_space_after = wp_record_space_u16(wl);
    if (out_result != NULL) {
        *out_result = result;
    }
    return true;
}

uint16_t __cdecl16near allocate_layout_gate_mask_bit(WpLayoutGlobals *wl)
{
    return wp_parser_gate_allocate_mask_bit(wl, NULL);
}

void __cdecl16near free_layout_gate_mask_bit(WpLayoutGlobals *wl)
{
    WpParserGateResult free_result;

    if (wp_parser_gate_free_mask_bit(wl, 0U, &free_result) && wl != NULL &&
        (wl->runtime_flags & 0x04U) != 0U) {
        WpParserGateResult mode_result;
        (void)wp_parser_gate_set_mode_or_status_bits(wl, &mode_result);
        (void)mode_result;
    }
}

void __cdecl16near set_mode_or_status_bits(WpLayoutGlobals *wl)
{
    (void)wp_parser_gate_set_mode_or_status_bits(wl, NULL);
}

void __cdecl16near layout_parse_token_stream_until_gate_overflow(WpLayoutGlobals *wl, uint16_t gate)
{
  uint16_t consumed = 0;

  wl->measured_span_shadow = wl->measured_span_a;
  while (wl->record_used_bytes > 0) {
    uint8_t code = consume_byte_from_buffer_with_position_gate(wl);
    if (parser_classify_or_handle_token(wl, code) == 0xFFFFU) {
      break;
    }
    consumed++;
    if (consumed >= wl->position_gate_remaining_low) {
      break;
    }
    if (gate != 0 && (wl->emit_gate_mask_51bf & gate) == 0) {
      break;
    }
  }

  wl->state_flags &= (uint8_t)~0x02;
  layout_reset_cursor_and_record_aux(wl);
  wl->update_depth = 0;
  wl->measured_span_a = 0;
  wl->measured_span_b = 0;
  wl->measured_span_flags = 0;
  wl->record_extension_needs_flush = 0;
  wl->runtime_flags &= (uint8_t)~0x04;
  layout_record_wide_temp_lo_hi_route_stage_1(wl);
}

void __cdecl16near layout_parse_field_whitespace_position_gate(WpLayoutGlobals *wl)
{
  uint16_t consumed = 0;

  while (wl->record_used_bytes > 0) {
    uint8_t code = consume_byte_from_buffer_with_position_gate(wl);
    if (parser_classify_or_handle_token(wl, code) == 0xFFFFU) {
      break;
    }
    consumed++;
    if (code > 0x20) {
      break;
    }
    if (consumed >= wl->position_gate_remaining_low) {
      break;
    }
  }

  wl->state_flags &= (uint8_t)~0x02;
  layout_reset_cursor_and_record_aux(wl);
  wl->update_depth = 0;
  wl->measured_span_a = 0;
  wl->measured_span_b = 0;
  wl->measured_span_flags = 0;
  wl->record_extension_needs_flush = 0;
  wl->runtime_flags &= (uint8_t)~0x04;
  layout_record_wide_temp_lo_hi_route_stage_1(wl);
}
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