Word Unperfect - XT-Emporium

File editor

#include "wp_layout_status.h"
#include "wp_layout_metrics.h"
#include "wp_parser_process.h"
#include "wp_span_metrics.h"
#include <string.h>

extern void route_far_jump_shell_segment_proxy(WpLayoutGlobals *wl);

static uint8_t wp_u8_from_char(char c)
{
    return (uint8_t)(unsigned char)c;
}

bool wp_layout_emit_gate_reset_variant_total(WpLayoutGlobals *wl,
                                             WpLayoutEmitGateResult *out_result)
{
    WpLayoutEmitGateResult result;
    int16_t old_total;

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

    memset(&result, 0, sizeof(result));
    result.old_variant_total = (int16_t)(uint16_t)wl->variant_total;
    result.new_variant_total = 0;
    result.old_variant_balance = (int16_t)(uint16_t)wl->variant_balance_51bd;
    result.old_parse_dirty_flags = wl->parse_dirty_flags;
    result.old_status_extend = wl->status_extend_4976;
    result.gate_alloc_would_run = true;
    result.variant_batch_would_run = true;
    result.gate_free_would_run = true;

    /* layout_emit_gate_run_reset_variant_total clears parse-dirty bit 3 and
     * status-extend bit 0, then transfers the signed 16-bit variant total into
     * the signed variant balance.  It is intentionally simpler than the later
     * layout_update_variant_totals path ported in pass 22. */
    old_total = (int16_t)(uint16_t)wl->variant_total;
    wl->parse_dirty_flags &= 0xF7U;
    wl->status_extend_4976 &= 0xFEU;
    wl->variant_total = 0;
    wl->variant_balance_51bd = (int16_t)(uint16_t)((uint16_t)wl->variant_balance_51bd +
                                                  (uint16_t)old_total);

    result.new_variant_balance = (int16_t)(uint16_t)wl->variant_balance_51bd;
    result.new_parse_dirty_flags = wl->parse_dirty_flags;
    result.new_status_extend = wl->status_extend_4976;
    result.moved_variant_total = old_total != 0;
    *out_result = result;
    return true;
}

bool wp_layout_mark_status_dirty(WpLayoutGlobals *wl,
                                 WpLayoutStatusDirtyResult *out_result)
{
    WpLayoutStatusDirtyResult result;

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

    memset(&result, 0, sizeof(result));
    result.old_status_dirty_flags = wl->status_dirty_flags;
    (void)wp_layout_emit_gate_reset_variant_total(wl, &result.gate);
    wl->status_dirty_flags |= 0x48U;
    result.new_status_dirty_flags = wl->status_dirty_flags;
    result.dirty_mask_applied = (result.new_status_dirty_flags & 0x48U) == 0x48U;
    *out_result = result;
    return true;
}

/* Raw wrappers for monolith compatibility @ 1000:127a */
void __cdecl16near layout_mark_status_dirty(WpLayoutGlobals *wl)
{
    WpLayoutStatusDirtyResult result;
    (void)wp_layout_mark_status_dirty(wl, &result);
}

void __cdecl16near layout_mark_status_dirty_route_stage_1(WpLayoutGlobals *wl)
{
    layout_mark_status_dirty(wl);
}

void __cdecl16near layout_mark_status_dirty_route_stage_2(WpLayoutGlobals *wl)
{
    layout_mark_status_dirty(wl);
}

bool wp_layout_mark_status_dirty_if_variant_balance_less_than_screen_extent(WpLayoutGlobals *wl,
                                                                            WpLayoutStatusDirtyResult *out_result)
{
    WpLayoutStatusDirtyResult result;
    uint16_t balance;
    uint16_t screen_minus_one;

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

    balance = (uint16_t)wl->variant_balance_51bd;
    screen_minus_one = (uint16_t)((uint16_t)wl->screen_extent_4741 - 1U);
    (void)wp_layout_mark_status_dirty(wl, &result);
    result.checked_balance_against_screen = true;
    result.balance_less_than_screen_extent = balance < screen_minus_one;
    *out_result = result;
    return true;
}

/* Raw wrapper @ 1000:12a2 */
void __cdecl16near layout_mark_status_dirty_if_variant_balance_less_than_screen_extent(WpLayoutGlobals *wl)
{
    WpLayoutStatusDirtyResult result;
    (void)wp_layout_mark_status_dirty_if_variant_balance_less_than_screen_extent(wl, &result);
}

bool wp_layout_display_metric_offset(const WpLayoutGlobals *wl,
                                     WpLayoutDisplayOffsetResult *out_result)
{
    WpLayoutDisplayOffsetResult result;

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

    memset(&result, 0, sizeof(result));
    result.old_irq_state = wp_u8_from_char(wl->irq_state_7903);
    result.irq_timer = wp_u8_from_char(wl->irq_timer_7902_char);
    result.machine_flags = wl->machine_flags_676c;
    if (wl->irq_state_7903 != 1 && wl->irq_timer_7902_char == 0 &&
        (wl->machine_flags_676c & 0x02U) != 0U) {
        result.offset = 1U;
        result.machine_metric_enabled = true;
        if ((wl->machine_flags_676c & 0x01U) != 0U) {
            result.offset = 2U;
            result.double_offset_enabled = true;
        }
    }
    *out_result = result;
    return true;
}

bool wp_layout_update_display_metrics_and_palette_guard(WpLayoutGlobals *wl,
                                                        uint16_t input_metric,
                                                        WpLayoutDisplayUpdateResult *out_result)
{
    WpLayoutDisplayUpdateResult result;
    WpLayoutDisplayOffsetResult offset_result;
    int limit;
    int metric;

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

    memset(&result, 0, sizeof(result));
    result.input_metric = input_metric;
    result.old_display_metric_44de = wl->display_metric_44de;
    result.old_display_metric_44e4 = wl->display_metric_44e4;
    result.old_status_dirty_flags = wl->status_dirty_flags;
    result.old_render_dirty_flags = wl->render_dirty_flags;
    result.old_irq_state = wp_u8_from_char(wl->irq_state_7903);

    (void)wp_layout_display_metric_offset(wl, &offset_result);
    result.machine_offset = offset_result.offset;
    wl->display_metric_44e4 = 0;
    limit = wl->display_metric_44e2 - 2 - (int)offset_result.offset;
    result.computed_limit = limit;

    if (input_metric == 0U) {
        result.zero_input_path = true;
        metric = wl->display_metric_44de;
        if (metric < limit) {
            if (((wl->config_digit_1699 == '2') ||
                 (wl->config_digit_1699 != '1' && wl->config_digit_169b != '2')) &&
                wl->display_palette_guard_44ee == 0) {
                wl->display_metric_44e4 = metric + 3;
            } else if (wl->display_palette_guard_44ee != 0) {
                result.palette_guard_blocked = true;
            }
            metric = (limit - metric) - 2;
        }
    } else {
        metric = (int)(int16_t)input_metric;
        if (metric < limit) {
            if (wl->display_palette_guard_44ee == 0 && wl->config_digit_1699 != '1') {
                wl->display_metric_44e4 = (limit - metric) + 1;
            } else if (wl->display_palette_guard_44ee != 0) {
                result.palette_guard_blocked = true;
            }
        }
    }

    wl->display_metric_44de = metric;
    wl->display_metric_44e4 += (int)offset_result.offset;
    result.refresh_would_run = true;
    wl->status_dirty_flags |= 0x48U;
    wl->render_dirty_flags |= 0x9BU;
    wl->irq_state_7903 = 0;

    result.new_display_metric_44de = wl->display_metric_44de;
    result.new_display_metric_44e4 = wl->display_metric_44e4;
    result.new_status_dirty_flags = wl->status_dirty_flags;
    result.new_render_dirty_flags = wl->render_dirty_flags;
    result.new_irq_state = wp_u8_from_char(wl->irq_state_7903);
    *out_result = result;
    return true;
}

/* Raw wrapper @ 1000:132c */
void __cdecl16near layout_update_display_metrics_and_palette_guard(WpLayoutGlobals *wl, uint16_t in_AX)
{
    WpLayoutDisplayUpdateResult result;
    (void)wp_layout_update_display_metrics_and_palette_guard(wl, in_AX, &result);
}

/* Raw wrapper @ 1000:13b6 */
void __cdecl16near layout_get_machine_flags_display_offset(WpLayoutGlobals *wl)
{
    WpLayoutDisplayOffsetResult result;
    (void)wp_layout_display_metric_offset(wl, &result);
}

bool wp_layout_decrement_irq_timer_and_dirty_flags(WpLayoutGlobals *wl,
                                                   WpLayoutIrqDirtyPulseResult *out_result)
{
    WpLayoutIrqDirtyPulseResult result;
    uint8_t timer;

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

    memset(&result, 0, sizeof(result));
    result.old_irq_timer = wp_u8_from_char(wl->irq_timer_7902_char);
    result.old_status_dirty_flags = wl->status_dirty_flags;
    result.old_render_dirty_flags = wl->render_dirty_flags;
    result.old_status_scratch = wl->status_scratch_479f;

    timer = wp_u8_from_char(wl->irq_timer_7902_char);
    if (timer != 0U) {
        timer = (uint8_t)(timer - 1U);
        wl->irq_timer_7902_char = (char)timer;
        result.timer_decremented = true;
        if (timer == 0U) {
            result.display_update_ran = wp_layout_update_display_metrics_and_palette_guard(wl, 0U,
                                                                                           &result.display_update);
        }
    }

    wl->status_dirty_flags |= 0x48U;
    wl->render_dirty_flags |= 0x1BU;
    wl->status_scratch_479f |= 0x01U;

    result.new_irq_timer = wp_u8_from_char(wl->irq_timer_7902_char);
    result.new_status_dirty_flags = wl->status_dirty_flags;
    result.new_render_dirty_flags = wl->render_dirty_flags;
    result.new_status_scratch = wl->status_scratch_479f;
    *out_result = result;
    return true;
}

/* Raw wrapper @ 1000:1303 */
void __cdecl16near layout_decrement_irq_timer_and_dirty_flags(WpLayoutGlobals *wl)
{
    WpLayoutIrqDirtyPulseResult result;
    (void)wp_layout_decrement_irq_timer_and_dirty_flags(wl, &result);
}

bool wp_layout_status_extend_update(WpLayoutGlobals *wl,
                                    uint8_t token,
                                    WpLayoutCarryUpdateResult *out_result)
{
    WpLayoutCarryUpdateResult result;
    int base_total;
    int adjustment;
    uint16_t scaled;
    uint16_t old_carry;

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

    memset(&result, 0, sizeof(result));
    result.token = token;
    base_total = wl->explicit_span_total;
    if (base_total == 0) {
        base_total = (int)(int16_t)(uint16_t)wl->default_span_a +
                     (int)(int16_t)(uint16_t)wl->default_span_b;
        result.used_default_span_total = true;
    }
    adjustment = token == (uint8_t)'\n' ? wl->span_width_adj_5043 : wl->span_width_adj_5041;
    result.used_newline_adjustment = token == (uint8_t)'\n';
    scaled = (uint16_t)(((uint32_t)(uint16_t)(base_total + adjustment) *
                         (uint32_t)(uint16_t)wl->span_scale_q8_5039) >> 8U);
    if ((int16_t)scaled < 1) {
        scaled = 1U;
        result.minimum_width_forced = true;
    }

    old_carry = (uint16_t)wl->carry_width;
    result.old_carry_width = wl->carry_width;
    if (old_carry < scaled) {
        wl->carry_width = 0;
        result.saturated_to_zero = true;
    } else {
        wl->carry_width = (int)(uint16_t)(old_carry - scaled);
    }

    result.base_span_total = base_total;
    result.span_adjustment = adjustment;
    result.span_scale_q8 = (uint16_t)wl->span_scale_q8_5039;
    result.scaled_width = scaled;
    result.new_carry_width = wl->carry_width;
    *out_result = result;
    return true;
}

bool wp_layout_token_uses_span_metric_lookup(uint16_t token_word)
{
    uint8_t low = (uint8_t)(token_word & 0xFFU);
    return low < 0x21U || ((low > 0xA8U && low != 0xACU) && low < 0xAFU);
}

int wp_layout_lookup_span_metric_host(const WpLayoutGlobals *wl,
                                      uint16_t token_word,
                                      WpLayoutCursorMetricResult *out_result)
{
    WpLayoutCursorMetricResult result;
    uint8_t high;
    uint8_t low;
    int metric;

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

    memset(&result, 0, sizeof(result));
    result.token_word = token_word;
    result.token = (uint8_t)(token_word & 0xFFU);
    result.metric_lookup_path = wp_layout_token_uses_span_metric_lookup(token_word);
    high = (uint8_t)(token_word >> 8U);
    low = result.token;
    result.high_byte_token = high != 0U;

    metric = 0;
    if (result.metric_lookup_path) {
        if (low == 0x20U) {
            metric = wl->span_metric_delta_4bd8;
        } else if (high == 0U) {
            metric = wl->span_metric_delta_4bda;
            if (wl->status_stream_gate_4987 != -1 && wl->span_table_ofs_4bdc != 0) {
                metric += wl->span_table_ofs_4bdc;
            }
        } else {
            metric = (int)(int16_t)(uint16_t)wl->span_table_word_a_4be0;
            if (metric == 0) {
                metric = wl->span_metric_delta_4bd8;
            }
            if (wl->span_table_word_b_4be2 != 0U) {
                metric += (int)(int16_t)(uint16_t)wl->span_table_word_b_4be2;
            }
        }
    }

    result.metric = metric;
    if (out_result != NULL) {
        *out_result = result;
    }
    return metric;
}

bool wp_layout_render_dirty_or_advance_cursor(WpLayoutGlobals *wl,
                                              uint16_t token_word,
                                              bool carry_flag_set,
                                              WpLayoutCursorMetricResult *out_result)
{
    WpLayoutCursorMetricResult result;
    int metric;

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

    metric = wp_layout_lookup_span_metric_host(wl, token_word, &result);
    result.carry_flag_set = carry_flag_set;
    result.old_cursor_alias = wl->cursor;
    result.old_record_aux = wl->record_aux_4b34;
    result.old_span_aux_word = (uint16_t)wl->span_aux_word_53f6;

    if (!carry_flag_set) {
        wl->cursor += metric;
        wl->record_aux_4b34 += 1;
        wl->span_aux_word_53f6 = (uint16_t)((uint16_t)wl->span_aux_word_53f6 + 1U);
        result.cursor_advanced = true;
        if (wl->postprocess_mode != 0) {
            WpLayoutReconcileResult reconcile;
            result.postprocess_reconcile_requested =
                wp_layout_reconcile_line_build_span_words(wl, (uint16_t)metric, &reconcile);
        }
    }

    result.new_cursor_alias = wl->cursor;
    result.new_record_aux = wl->record_aux_4b34;
    result.new_span_aux_word = (uint16_t)wl->span_aux_word_53f6;
    *out_result = result;
    return true;
}

/* Raw wrapper @ 1000:254e */
void __cdecl16near layout_status_extend_update(WpLayoutGlobals *wl, uint8_t in_AL)
{
    WpLayoutCarryUpdateResult result;
    (void)wp_layout_status_extend_update(wl, in_AL, &result);
}

/* Raw wrapper @ 1000:26c5 */
uint16_t __cdecl16near layout_render_dirty_or_flags(WpLayoutGlobals *wl, uint16_t in_AX, uint8_t in_CF)
{
    WpLayoutCursorMetricResult result;
    (void)wp_layout_render_dirty_or_advance_cursor(wl, in_AX, in_CF != 0, &result);
    return in_AX;
}

/* Raw wrapper @ 1000:26e3 */
uint16_t __cdecl16near layout_cursor_metric_fold(WpLayoutGlobals *wl, uint8_t in_AL)
{
    WpLayoutCursorMetricResult result;
    return (uint16_t)wp_layout_lookup_span_metric_host(wl, in_AL, &result);
}

/* Function: backup_and_clear_irq_shadow_flags @ 1000:15ff */
uint16_t __cdecl16near backup_and_clear_irq_shadow_flags(WpLayoutGlobals *wl)
{
    /* Use offset 0 for IRQ driver state as no explicit BX is passed in host build. */
    uint16_t offset_lo = 0;
    uint16_t offset_hi = 1;

    wl->irq_shadow_lo_7900 = wl->irq_driver_state[offset_lo];
    wl->irq_driver_state[offset_lo] = 0;
    wl->irq_shadow_hi_7901 = wl->irq_driver_state[offset_hi];
    wl->irq_driver_state[offset_hi] = 0;
    return 0;
}

/* Function: restore_irq_shadow_flags @ 1000:1622 */
void __cdecl16near restore_irq_shadow_flags(WpLayoutGlobals *wl)
{
    /* The original logic used the backed-up values as OFFSETS back into the table. */
    wl->irq_driver_state[wl->irq_shadow_lo_7900] = wl->irq_shadow_lo_7900;
    wl->irq_driver_state[wl->irq_shadow_hi_7901] = wl->irq_shadow_hi_7901;
}

/* Function: layout_check_parser_gate_and_restore_mode @ 1000:0ee5 */
void __cdecl16near layout_check_parser_gate_and_restore_mode(WpLayoutGlobals *wl)
{
    if ((wl->decode_io_flags_8749 & 1) != 0) {
        if (wl->parser_gate_5c05 == '\0') {
            if (wl->restore_mode != '\0') {
                layout_handle_restore_mode(wl);
            }
        } else {
            if (wl->restore_mode != '\0') {
                if ((wl->decode_io_flags_8749 & 2) == 0) {
                    return;
                }
                layout_handle_restore_mode(wl);
            }
            parser_classify_until_d4_and_no_op(wl);
        }
    }
}

/* Function: layout_handle_restore_mode @ 1000:1087 */
void __cdecl16near layout_handle_restore_mode(WpLayoutGlobals *wl)
{
    if (wl->restore_mode == '\f') {
        route_far_jump_shell_segment_proxy(wl);
    }
    layout_calc_span_width_and_carry(wl);
    if (wl->record_extension_block_count != '\0') {
        /* route_far_jump_shell_segment_proxy(wl); */
    }
    if ((uint8_t)wl->restore_mode < 5) {
        route_far_jump_shell_segment_proxy(wl);
    }
    if (wl->restore_mode == 10) {
        route_far_jump_shell_segment_proxy(wl);
    }
    if (10 < wl->restore_mode) {
        route_far_jump_shell_segment_proxy(wl);
    }
    route_far_jump_shell_segment_proxy(wl);
}

bool wp_layout_clean_processed_segments_and_update_cursor_alias(WpLayoutGlobals *wl,
                                                                uint16_t span_metric,
                                                                WpLayoutCursorMetricResult *out_result)
{
    WpLayoutCursorMetricResult result;
    WpLayoutReconcileResult reconcile;

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

    memset(&result, 0, sizeof(result));
    result.old_cursor_alias = wl->cursor;
    result.old_record_aux = wl->record_aux_4b34;
    result.old_span_aux_word = (uint16_t)wl->span_aux_word_53f6;
    result.old_cursor_alias_shadow = (uint16_t)wl->cursor_alias_shadow_4b3e;
    result.postprocess_reconcile_requested =
        wp_layout_increment_cursor_pack_state(wl, span_metric, &reconcile);
    wl->cursor_alias_shadow_4b3e = (undefined2)(uint16_t)wl->cursor;
    wl->render_dirty_flags |= 0x03U;
    wl->processed_segments = 0;
    wl->postprocess_mode = 1;
    result.processed_segments_cleared = true;
    result.render_dirty_set = true;
    result.new_cursor_alias = wl->cursor;
    result.new_record_aux = wl->record_aux_4b34;
    result.new_span_aux_word = (uint16_t)wl->span_aux_word_53f6;
    result.new_cursor_alias_shadow = (uint16_t)wl->cursor_alias_shadow_4b3e;
    *out_result = result;
    return true;
}

bool wp_layout_parse_carry_adjust(WpLayoutGlobals *wl,
                                  WpLayoutParseCarryResult *out_result)
{
    WpLayoutParseCarryResult result;
    int32_t balance_sum;

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

    memset(&result, 0, sizeof(result));
    result.old_parse_dirty_flags = wl->parse_dirty_flags;
    result.old_parser_runtime_flags = wl->parser_runtime_flags;
    result.variant_balance = (int16_t)(uint16_t)wl->variant_balance_51bd;
    result.variant_total = (int16_t)(uint16_t)wl->variant_total;
    balance_sum = (int32_t)result.variant_balance + (int32_t)result.variant_total;
    result.balance_plus_total = (int16_t)(uint16_t)balance_sum;
    result.screen_extent = (int16_t)(uint16_t)wl->screen_extent_4741;
    result.variant_count = wp_u8_from_char(wl->variant_count);
    result.active_variant_index = wp_u8_from_char(wl->active_variant_index);
    result.gate_alloc_would_run = true;
    result.gate_free_would_run = true;
    result.post_emit_cleanup_calls = 1U;

    /* layout_parse_carry_adjust repeatedly calls layout_post_emit_gate_cleanup
     * while the signed variant balance plus the pending variant total is beyond
     * the screen extent.  Host code performs a single bounded classification of
     * the branch that would have been taken, keeping the flag side effects. */
    result.threshold_reached = balance_sum >= (int32_t)result.screen_extent;
    if (result.threshold_reached) {
        if (result.variant_count == 0U) {
            result.no_variants_iteration_would_run = true;
        } else if (result.active_variant_index > result.variant_count) {
            result.variant_decode_would_run = true;
        } else {
            result.active_variant_within_count = true;
        }
    }

    wl->parse_dirty_flags &= 0xFDU;
    result.new_parse_dirty_flags = wl->parse_dirty_flags;
    result.new_parser_runtime_flags = wl->parser_runtime_flags;
    result.parse_bit_02_cleared = (result.old_parse_dirty_flags & 0x02U) != 0U &&
                                  (result.new_parse_dirty_flags & 0x02U) == 0U;
    result.return_flags = (uint16_t)(wl->parser_runtime_flags & 0x04U);
    *out_result = result;
    return true;
}

bool wp_layout_update_parse_dirty_flags(WpLayoutGlobals *wl,
                                        WpLayoutParseDirtyUpdateResult *out_result)
{
    WpLayoutParseDirtyUpdateResult result;

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

    memset(&result, 0, sizeof(result));
    result.old_parse_dirty_flags = wl->parse_dirty_flags;
    result.old_parser_runtime_flags = wl->parser_runtime_flags;
    result.old_status_dirty_flags = wl->status_dirty_flags;
    result.old_variant_total = (int16_t)(uint16_t)wl->variant_total;
    result.old_variant_balance = (int16_t)(uint16_t)wl->variant_balance_51bd;

    if ((wl->parse_dirty_flags & 0x04U) != 0U) {
        result.skipped_busy = true;
        result.new_parse_dirty_flags = wl->parse_dirty_flags;
        result.new_parser_runtime_flags = wl->parser_runtime_flags;
        result.new_status_dirty_flags = wl->status_dirty_flags;
        result.new_variant_total = (int16_t)(uint16_t)wl->variant_total;
        result.new_variant_balance = (int16_t)(uint16_t)wl->variant_balance_51bd;
        *out_result = result;
        return true;
    }

    result.ran = true;
    wl->parse_dirty_flags |= 0x04U;
    result.parse_busy_bit_set = true;

    if (wp_layout_parse_carry_adjust(wl, &result.carry)) {
        result.parse_carry_ran = true;
    }

    if ((wl->parse_dirty_flags & 0x08U) != 0U) {
        WpLayoutStatusDirtyResult dirty;
        if (wp_layout_mark_status_dirty_if_variant_balance_less_than_screen_extent(wl, &dirty)) {
            result.dirty_if_balance_ran = true;
            result.dirty_if_balance_less_than_screen = dirty.balance_less_than_screen_extent;
        }
    }

    if (wl->variant_total != 0) {
        WpLayoutVariantBalanceResult balance;
        if (wp_layout_reset_variant_total_and_update_dirty_flags(wl, &balance)) {
            result.variant_total_reset_ran = true;
        }
        wl->status_dirty_flags |= 0x48U;
    }

    wl->parse_dirty_flags &= 0xFBU;
    wl->parser_runtime_flags &= 0xFBU;
    if ((result.carry.return_flags & 0x04U) != 0U) {
        wl->parser_runtime_flags |= 0x04U;
        result.parser_runtime_bit_04_restored = true;
    }

    result.new_parse_dirty_flags = wl->parse_dirty_flags;
    result.new_parser_runtime_flags = wl->parser_runtime_flags;
    result.new_status_dirty_flags = wl->status_dirty_flags;
    result.new_variant_total = (int16_t)(uint16_t)wl->variant_total;
    result.new_variant_balance = (int16_t)(uint16_t)wl->variant_balance_51bd;
    result.status_dirty_mask_applied = (result.new_status_dirty_flags & 0x48U) == 0x48U &&
                                       result.new_status_dirty_flags != result.old_status_dirty_flags;
    *out_result = result;
    return true;
}

bool wp_layout_status_line_refresh_hub(WpLayoutGlobals *wl,
                                       uint16_t metric,
                                       WpLayoutStatusLineRefreshResult *out_result)
{
    WpLayoutStatusLineRefreshResult result;
    uint16_t scale;
    uint32_t scaled32;
    uint32_t divided;
    uint32_t index;

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

    memset(&result, 0, sizeof(result));
    scale = (uint16_t)wl->scale_factor_4b14;
    if (scale == 0U) {
        scale = 1U;
    }
    result.input_metric = metric;
    result.runtime_scale = scale;
    result.old_emit_scratch = wl->emit_record_scratch_5031;
    wl->emit_record_scratch_5031 = metric;

    scaled32 = (uint32_t)metric * (uint32_t)scale;
    result.scale_overflowed = scaled32 > 0xFFFFU;
    result.scaled_metric = (uint16_t)scaled32;
    if (!result.scale_overflowed && result.scaled_metric < metric) {
        result.scaled_metric = metric;
        result.scale_clamped_to_input = true;
    }
    if (result.scaled_metric < (uint16_t)wl->span_metric_delta_4bd8) {
        result.record_path_walk_would_run = true;
    }

    divided = (uint32_t)result.scaled_metric / (uint32_t)scale;
    result.divided_metric = (uint16_t)divided;
    result.metrics_window_base = (uint16_t)wl->metrics_window_base_50ba;
    if (divided >= (uint32_t)result.metrics_window_base) {
        index = divided - (uint32_t)result.metrics_window_base;
        if (index < (uint32_t)(uint16_t)wl->video_rows_minus_one_44dc &&
            index < (uint32_t)sizeof(wl->overlay_scratch_5ad7)) {
            result.inside_metrics_window = true;
            result.buffer_index = (uint16_t)index;
            result.old_buffer_byte = wl->overlay_scratch_5ad7[index];
            result.new_buffer_byte = result.old_buffer_byte != (uint8_t)' ' ? 0x13U : (uint8_t)' ';
            wl->overlay_scratch_5ad7[index] = result.new_buffer_byte;
            result.byte_return_wrote = true;
        }
    }

    result.heap_cursor_rebase_would_run = !result.byte_return_wrote;
    result.irq_or_timer_touch_would_run = true;
    wl->emit_record_scratch_5031 = result.old_emit_scratch;
    result.restored_emit_scratch = wl->emit_record_scratch_5031;
    *out_result = result;
    return true;
}

bool wp_layout_execute_emit_or_measure_pass(WpLayoutGlobals *wl,
                                            WpLayoutEmitMeasureResult *out_result)
{
    WpLayoutEmitMeasureResult result;
    WpLayoutDisplayOffsetResult offset;
    uint32_t candidate;
    uint16_t refresh_count;
    uint16_t i;

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

    memset(&result, 0, sizeof(result));
    result.old_render_dirty_flags = wl->render_dirty_flags;
    result.display_metric_44de = (uint16_t)wl->display_metric_44de;
    result.old_display_metric_44e4 = (uint16_t)wl->display_metric_44e4;
    result.display_limit = (uint16_t)wl->display_metric_44e2;
    (void)wp_layout_display_metric_offset(wl, &offset);
    result.machine_offset = offset.offset;

    candidate = (uint32_t)offset.offset + (uint32_t)(uint16_t)wl->display_metric_44de + 2U;
    result.initial_candidate = (uint16_t)candidate;
    result.adjusted_candidate = (uint16_t)candidate;
    if ((uint16_t)candidate != (uint16_t)wl->display_metric_44e2) {
        if ((uint16_t)wl->display_metric_44e2 <= (uint16_t)candidate) {
            result.display_limit_reached = true;
            wl->render_dirty_flags &= 0xF7U;
            result.render_dirty_bit_cleared = (result.old_render_dirty_flags & 0x08U) != 0U;
            result.new_render_dirty_flags = wl->render_dirty_flags;
            result.new_display_metric_44e4 = (uint16_t)wl->display_metric_44e4;
            *out_result = result;
            return true;
        }
        result.candidate_adjusted_from_e4 = true;
        if ((uint16_t)wl->display_metric_44e4 < 4U) {
            candidate = (uint32_t)(uint16_t)wl->display_metric_44e4 +
                        (uint32_t)(uint16_t)wl->display_metric_44de + 2U;
        } else {
            candidate = (uint32_t)((uint16_t)wl->display_metric_44e4 - 1U);
        }
        result.adjusted_candidate = (uint16_t)candidate;
    }

    if (candidate > 0U && candidate <= (uint32_t)(uint16_t)wl->display_metric_44e2) {
        uint16_t writable;
        result.inside_window = true;
        result.overlay_emit_would_run = true;
        result.overlay_tail_would_run = true;
        writable = (uint16_t)((uint16_t)wl->video_rows_minus_one_44dc + 3U);
        if (writable >= sizeof(wl->overlay_scratch_5ad7)) {
            writable = (uint16_t)(sizeof(wl->overlay_scratch_5ad7) - 1U);
        }
        if (writable > 0U) {
            memset(wl->overlay_scratch_5ad7, ' ', writable);
            wl->overlay_scratch_5ad7[writable] = 0x13U;
            result.spaces_written = writable;
            result.scratch_line_written = true;
        }
        refresh_count = 1U;
        if (wl->variant_count != 0) {
            refresh_count = (uint16_t)(uint8_t)wl->active_variant_index;
            if (refresh_count == 0U) {
                refresh_count = 1U;
            }
            result.variant_refresh_iterations = refresh_count;
        }
        if (refresh_count > 64U) {
            refresh_count = 64U;
        }
        for (i = 0; i < refresh_count; ++i) {
            WpLayoutStatusLineRefreshResult refresh;
            if (wp_layout_status_line_refresh_hub(wl, (uint16_t)candidate, &refresh)) {
                result.last_refresh = refresh;
                result.status_line_refreshes++;
            }
        }
        wl->display_metric_44e4 = (int)(uint16_t)candidate;
    } else {
        wl->render_dirty_flags &= 0xF7U;
        result.render_dirty_bit_cleared = (result.old_render_dirty_flags & 0x08U) != 0U;
    }

    result.new_render_dirty_flags = wl->render_dirty_flags;
    result.new_display_metric_44e4 = (uint16_t)wl->display_metric_44e4;
    *out_result = result;
    return true;
}
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