Word Unperfect - XT-Emporium

File editor

/* Ghidra-extracted primary/secondary record buffer primitives from wp_record_stream.c.
 * Overlay refill paths are modeled through host-safe helpers in wp_record_ring.c.
 */

#include "wp_record_stream.h"
#include "wp_record_ring.h"
#include <stdint.h>

extern WpLayoutGlobals g_wp_layout;

static void reverse_copy_bytes_or_words(WpLayoutGlobals *wl, uint16_t count);

uint8_t __cdecl16near consume_byte_from_primary_buffer(WpLayoutGlobals *wl)

{
  uint8_t *record_byte_cursor;
  uint8_t uVar1;
  undefined2 unaff_ES;
  undefined2 unaff_DS;
  bool bVar2;

  (void)unaff_ES;
  (void)unaff_DS;
  do {
    bVar2 = false;
    if (wl->record_used_bytes != 0) {
      wl->record_used_bytes = wl->record_used_bytes - 1;
      record_byte_cursor = (uint8_t *)wl->primary_record.as_record_p - 1;
      wl->primary_record.as_record_p = (uint16_t *)record_byte_cursor;
      uVar1 = *record_byte_cursor;
      wl->record_buffer_space = wl->record_buffer_space + 1;
      return uVar1;
    }
    uVar1 = invoke_overlay_consume_record_stream(wl);
    if (wl->record_used_bytes == 0) {
      return uVar1;
    }
  } while (!bVar2);
  return uVar1;
}

uint16_t __cdecl16near consume_word_from_primary_buffer(WpLayoutGlobals *wl)

{
  uint16_t uVar1;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;

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

  if (wl->record_used_bytes < 2) {
    uVar1 = invoke_overlay_consume_record_stream(wl);
    if (wl->record_used_bytes < 2) {
      if (wl->record_used_bytes == 1) {
        return (uint16_t)consume_byte_from_primary_buffer(wl);
      }
      return uVar1;
    }
  }

  /* The primary buffer is consumed as a LIFO byte stream.  Reading a native
   * uint16_t at cursor-2 reverses the logical byte order on little-endian
   * hosts, so compose the word from the next two stream bytes explicitly. */
  {
    uint8_t lo = consume_byte_from_primary_buffer(wl);
    uint8_t hi = consume_byte_from_primary_buffer(wl);
    return (uint16_t)((uint16_t)lo | ((uint16_t)hi << 8));
  }
}

uint8_t __cdecl16near consume_byte_from_buffer_with_position_gate(WpLayoutGlobals *wl)

{
  uint8_t *record_byte_cursor;
  uint8_t uVar1;
  uint uVar2;
  undefined2 unaff_ES;
  undefined2 unaff_DS;
  bool bVar3;

  (void)unaff_ES;
  (void)unaff_DS;
  do {
    bVar3 = false;
    if (wl->record_used_bytes != 0) {
      wl->record_used_bytes = wl->record_used_bytes - 1;
      record_byte_cursor = (uint8_t *)wl->primary_record.as_record_p - 1;
      wl->primary_record.as_record_p = (uint16_t *)record_byte_cursor;
      uVar1 = *record_byte_cursor;
      wl->record_buffer_space = wl->record_buffer_space + 1;
      uVar2 = wl->position_gate_remaining_low;
      wl->position_gate_remaining_low = wl->position_gate_remaining_low - 1;
      if (uVar2 != 0) {
        return uVar1;
      }
      wl->position_gate_remaining_high = wl->position_gate_remaining_high - 1;
      return uVar1;
    }
    uVar1 = invoke_overlay_consume_record_stream(wl);
    if (wl->record_used_bytes == 0) {
      return uVar1;
    }
  } while (!bVar3);
  return uVar1;
}

uint16_t __cdecl16near parser_consume_next_input_byte(WpLayoutGlobals *wl)

{
  uint8_t uVar1;
  undefined2 unaff_ES;
  undefined2 unaff_DS;
  bool bVar2;

  (void)unaff_ES;
  (void)unaff_DS;
  do {
    bVar2 = false;
    if (wl->secondary_record_used_bytes != 0) {
      uVar1 = *wl->secondary_record.as_secondary_p;
      wl->secondary_record_used_bytes = wl->secondary_record_used_bytes - 1;
      wl->secondary_record.as_secondary_p = wl->secondary_record.as_secondary_p + 1;
      wl->record_buffer_space = wl->record_buffer_space + 1;
      return (uint16_t)uVar1;
    }
    uVar1 = invoke_overlay_probe_secondary_record(wl);
    if (wl->secondary_record_used_bytes == 0) {
      return 0xFFFFU;
    }
  } while (!bVar2);
  return (uint16_t)uVar1;
}

uint16_t __cdecl16near consume_word_from_secondary_buffer(WpLayoutGlobals *wl)

{
  uint16_t uVar1;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;

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

  if (wl->secondary_record_used_bytes < 2) {
    uVar1 = invoke_overlay_probe_secondary_record(wl);
    if (wl->secondary_record_used_bytes < 2) {
      if (wl->secondary_record_used_bytes == 1) {
        return (uint16_t)parser_consume_next_input_byte(wl);
      }
      return uVar1;
    }
  }

  /* Secondary records are FIFO, but composing from bytes keeps the host port
   * endian- and alignment-independent. */
  {
    uint16_t lo;
    uint16_t hi;

    lo = parser_consume_next_input_byte(wl);
    if (lo == 0xFFFFU) return 0xFFFFU;
    hi = parser_consume_next_input_byte(wl);
    if (hi == 0xFFFFU) return 0xFFFFU;
    return (uint16_t)((uint16_t)lo | ((uint16_t)hi << 8));
  }
}

void record_append_byte_under_position_gate(WpLayoutGlobals *wl, uint8_t al)

{
  uint8_t *puVar2;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;
  wl->position_gate_remaining_low = wl->position_gate_remaining_low + 1;
  if (wl->position_gate_remaining_low != 0) {
    puVar2 = (uint8_t *)wl->primary_record.as_record_p;
    *puVar2 = al;
    wl->primary_record.as_record_p = (uint16_t *)(puVar2 + 1);
    wl->record_used_bytes = wl->record_used_bytes + 1;
    wl->record_buffer_space = wl->record_buffer_space - 1;
    if (wl->record_buffer_space == 0) {
      invoke_overlay_expand_primary_buffer(wl);
    }
    return;
  }
  wl->position_gate_remaining_high = wl->position_gate_remaining_high + 1;
  append_byte_to_buffer(wl, al);
  return;
}

void record_append_byte_under_position_gate_value(WpLayoutGlobals *wl, uint8_t al)

{
  uint8_t *puVar2;
  undefined2 unaff_ES;
  undefined2 unaff_DS;
  int *piVar1;

  (void)unaff_ES;
  (void)unaff_DS;
  wl->position_gate_remaining_low = wl->position_gate_remaining_low + 1;
  if (wl->position_gate_remaining_low != 0) {
    puVar2 = (uint8_t *)wl->primary_record.as_record_p;
    *puVar2 = al;
    wl->primary_record.as_record_p = (uint16_t *)(puVar2 + 1);
    wl->record_used_bytes = wl->record_used_bytes + 1;
    wl->record_buffer_space = wl->record_buffer_space - 1;
    if (wl->record_buffer_space == 0) {
      invoke_overlay_expand_primary_buffer(wl);
    }
    return;
  }
  wl->position_gate_remaining_high = wl->position_gate_remaining_high + 1;
  puVar2 = (uint8_t *)wl->primary_record.as_record_p;
  *puVar2 = al;
  wl->primary_record.as_record_p = (uint16_t *)(puVar2 + 1);
  wl->record_used_bytes = wl->record_used_bytes + 1;
  piVar1 = (int *)&wl->record_buffer_space;
  *piVar1 = *piVar1 + -1;
  if (*piVar1 == 0) {
    invoke_overlay_expand_primary_buffer(wl);
  }
  return;
}

void __cdecl16near append_byte_to_buffer(WpLayoutGlobals *wl, uint8_t al)

{
  int *piVar1;
  uint8_t *puVar2;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;
  puVar2 = (uint8_t *)wl->primary_record.as_record_p;
  *puVar2 = al;
  wl->primary_record.as_record_p = (uint16_t *)(puVar2 + 1);
  wl->record_used_bytes = wl->record_used_bytes + 1;
  piVar1 = (int *)&wl->record_buffer_space;
  *piVar1 = *piVar1 + -1;
  if (*piVar1 == 0) {
    invoke_overlay_expand_primary_buffer(wl);
  }
  return;
}

void __cdecl16near append_word_to_buffer(WpLayoutGlobals *wl, uint16_t ax)

{
  uint *puVar1;
  uint uVar2;
  uint16_t *puVar3;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;
  wl->record_used_bytes = wl->record_used_bytes + 2;
  puVar1 = (uint *)&wl->record_buffer_space;
  uVar2 = *puVar1;
  *puVar1 = *puVar1 - 2;
  if (uVar2 < 2) {
    ax = invoke_overlay_expand_primary_buffer(wl);
  }
  puVar3 = (uint16_t *)wl->primary_record.as_record_p;
  *puVar3 = ax;
  wl->primary_record.as_record_p = (uint16_t *)(puVar3 + 1);
  return;
}

void __cdecl16near prepend_byte_to_buffer(WpLayoutGlobals *wl, uint8_t al)

{
  int *piVar1;
  uint8_t *secondary_byte_cursor;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;
  secondary_byte_cursor = (uint8_t *)wl->secondary_record.as_secondary_p - 1;
  *secondary_byte_cursor = al;
  wl->secondary_record.as_secondary_p = secondary_byte_cursor;
  wl->secondary_record_used_bytes = wl->secondary_record_used_bytes + 1;
  piVar1 = (int *)&wl->record_buffer_space;
  *piVar1 = *piVar1 + -1;
  if (*piVar1 == 0) {
    invoke_overlay_expand_primary_buffer(wl);
  }
  return;
}

void __cdecl16near prepend_word_to_buffer(WpLayoutGlobals *wl, uint16_t ax)

{
  uint *puVar1;
  uint uVar2;
  uint16_t *secondary_word_cursor;
  undefined2 unaff_ES;
  undefined2 unaff_DS;

  (void)unaff_ES;
  (void)unaff_DS;
  wl->secondary_record_used_bytes = wl->secondary_record_used_bytes + 2;
  puVar1 = (uint *)&wl->record_buffer_space;
  uVar2 = *puVar1;
  *puVar1 = *puVar1 - 2;
  if (uVar2 < 2) {
    ax = invoke_overlay_expand_primary_buffer(wl);
  }
  secondary_word_cursor = (uint16_t *)(wl->secondary_record.as_secondary_p - 2);
  *secondary_word_cursor = ax;
  wl->secondary_record.as_secondary_p = (uint8_t *)secondary_word_cursor;
  return;
}

void __cdecl16near copy_words_between_pointers(WpLayoutGlobals *wl, uint16_t count)

{
  uint16_t *primary_word_cursor;
  uint16_t *secondary_word_cursor;
  uint16_t uVar3;
  uint16_t uVar4;
  uint extraout_DX;
  uint16_t *puVar5;
  uint16_t *puVar6;
  undefined2 unaff_ES;
  undefined2 unaff_DS;
  bool bVar7;

  (void)unaff_ES;
  (void)unaff_DS;
  uVar4 = count;
  if (count != 0) {
    do {
      uVar3 = count;
      if (wl->secondary_record_used_bytes < count) {
        uVar3 = (uint16_t)wl->secondary_record_used_bytes;
      }
      if (uVar3 == 0) {
        break;
      }
      count = uVar4 - uVar3;
      wl->secondary_record_used_bytes = wl->secondary_record_used_bytes - uVar3;
      wl->record_used_bytes = wl->record_used_bytes + uVar3;
      puVar5 = (uint16_t *)wl->secondary_record.as_secondary_p;
      puVar6 = (uint16_t *)wl->primary_record.as_record_p;
      uVar4 = uVar3 >> 1;
      if ((uVar3 & 1) != 0) {
        primary_word_cursor = puVar6;
        puVar6 = (uint16_t *)((uintptr_t)puVar6 + 1);
        secondary_word_cursor = puVar5;
        puVar5 = (uint16_t *)((uintptr_t)puVar5 + 1);
        *(uint8_t *)primary_word_cursor = *(uint8_t *)secondary_word_cursor;
      }
      for (; uVar4 != 0; uVar4 = uVar4 - 1) {
        primary_word_cursor = puVar6;
        puVar6 = puVar6 + 1;
        secondary_word_cursor = puVar5;
        puVar5 = puVar5 + 1;
        *primary_word_cursor = *secondary_word_cursor;
      }
      wl->secondary_record.as_secondary_p = (uint8_t *)puVar5;
      wl->primary_record.as_record_p = (uint16_t *)puVar6;
      bVar7 = false;
    } while ((count != 0) && (invoke_overlay_probe_secondary_record(wl), uVar4 = (uint16_t)extraout_DX, !bVar7));
  }
  return;
}

static void reverse_copy_bytes_or_words(WpLayoutGlobals *wl, uint16_t count)
{
  uint8_t *src_cursor;
  uint8_t *dst_cursor;
  uint16_t copy_words;

  if ((wl == NULL) || (count == 0)) {
    return;
  }

  src_cursor = (uint8_t *)wl->primary_record.as_record_p + count;
  dst_cursor = (uint8_t *)wl->secondary_record.as_secondary_p + count;

  if ((count & 1U) != 0U) {
    --src_cursor;
    --dst_cursor;
    *dst_cursor = *src_cursor;
  }

  copy_words = (uint16_t)(count >> 1);
  while (copy_words != 0) {
    src_cursor -= 2U;
    dst_cursor -= 2U;
    dst_cursor[0] = src_cursor[0];
    dst_cursor[1] = src_cursor[1];
    copy_words = (uint16_t)(copy_words - 1U);
  }
}

void __cdecl16near record_transfer_primary_to_secondary_reverse(WpLayoutGlobals *wl, uint16_t count)

{
  uint extraout_DX;
  undefined2 unaff_DS;
  bool bVar1;

  (void)extraout_DX;
  (void)unaff_DS;
  if (count != 0) {
    do {
      if (wl->record_used_bytes < count) {
        count = (uint16_t)wl->record_used_bytes;
      }
      if (count == 0) {
        break;
      }
      wl->record_used_bytes = wl->record_used_bytes - count;
      wl->secondary_record_used_bytes = wl->secondary_record_used_bytes + count;
      wl->secondary_record.word = wl->secondary_record.word - count;
      wl->primary_record.word = wl->primary_record.word - count;
      reverse_copy_bytes_or_words(wl, count);
      bVar1 = false;
      (void)invoke_overlay_consume_record_stream(wl);
      break;
    } while (!bVar1);
  }
  return;
}

uint8_t __cdecl16near invoke_overlay_consume_record_stream(WpLayoutGlobals *wl)
{
  WpRecordRingResult ring_result;

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

  /* The DOS path advances the stream cursor and bumps the block/scale counters
   * for this consume operation.  Keep host behavior aligned through the
   * far-bump helper.
   */
  wp_record_ring_far_bump_indices_if_ax(wl, 0, true, &ring_result);
  return (uint8_t)0;
}

uint8_t __cdecl16near invoke_overlay_probe_secondary_record(WpLayoutGlobals *wl)
{
  WpRecordRingResult ring_result;

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

  /* Probe/fetch secondary room by sliding in a 2 KiB chunk when needed. */
  wp_record_ring_check_secondary_space(wl, 1, &ring_result);
  return (uint8_t)(wl->secondary_record_used_bytes & 0xFFU);
}

uint16_t __cdecl16near invoke_overlay_expand_primary_buffer(WpLayoutGlobals *wl)
{
  WpRecordRingResult ring_result;

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

  /* Grow the active primary window by one compact step when space runs low. */
  wp_record_ring_compact_primary_by_2kb(wl, &ring_result);
  return (uint16_t)0;
}
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