ibm5250 0.1.0.dev5__tar.gz → 0.1.0.dev6__tar.gz

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ibm5250
-Version: 0.1.0.dev5
+Version: 0.1.0.dev6
 Summary: IBM 5250 terminal automation library
 License-File: LICENSE
 Requires-Python: >=3.11

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ibm5250"
-version = "0.1.0.dev5"
+version = "0.1.0.dev6"
 description = "IBM 5250 terminal automation library"
 requires-python = ">=3.11"
 

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/src/ibm5250/connection.py

@@ -33,7 +33,6 @@ from .constants import (
     TN5250EDataType,
     TN5250ERecordType,
     TN5250ESubNeg,
-    encode_addr,
 )
 from .exceptions import ConnectionError, ProtocolError, RecvTimeout
 
@@ -49,6 +48,8 @@ _TELNET_OPT_CMD_LEN = 3  # bytes: IAC + command + option (WILL/WONT/DO/DONT)
 # SNA / TN5250E wire-format framing constants
 _GDS_RECORD_ID_HI = 0x12  # SNA GDS record-type identifier, high byte
 _GDS_RECORD_ID_LO = 0xA0  # SNA GDS record-type identifier, low byte
+_VAR_HDR_OP_HI = 0x08  # TN5250E variable-header opcode byte 0
+_VAR_HDR_OP_LO = 0x2C  # TN5250E variable-header opcode byte 1
 _SAVE_SCREEN_RESP_CC1 = 0x01  # CC1 value in the Save Screen response variable header
 
 # TN5250E header byte 7 (request/response flags). Real emulators set bit 0x40
@@ -81,12 +82,10 @@ class TN5250EHeader:
     err_flag: int = 0x00
 
     aid: int = AID.NO_AID  # AID byte placed in the variable header (default: no-AID)
-    cursor_row: int = 0x00
-    cursor_col: int = 0x00
 
     def to_bytes(self, payload_len: int) -> bytes:
-        # 3-byte variable header: cursor row, cursor column, AID.
-        var_hdr = bytes([self.cursor_row, self.cursor_col, self.aid])
+        # 3-byte variable header: _VAR_HDR_OP_HI _VAR_HDR_OP_LO <AID>
+        var_hdr = bytes([_VAR_HDR_OP_HI, _VAR_HDR_OP_LO, self.aid])
         var_len = len(var_hdr)
         total = payload_len + _TN5250E_HEADER_LEN + var_len
         return (
@@ -239,8 +238,6 @@ class TN5250Connection:
         *,
         data_type: int = TN5250EDataType.INPUT,
         aid: int = AID.NO_AID,
-        cursor_pos: int | None = None,
-        cols: int = 80,
     ) -> None:
         """Send a 5250 data record to the host.
 
@@ -251,21 +248,16 @@ class TN5250Connection:
             raise ConnectionError("Not connected")
 
         escaped = _iac_escape(data)
-        cursor_row, cursor_col = (
-            encode_addr(cursor_pos, cols) if cursor_pos is not None else (0, 0)
-        )
 
         if self._tn5250e_active:
             hdr = TN5250EHeader(
                 data_type=data_type,
                 aid=aid,
-                cursor_row=cursor_row,
-                cursor_col=cursor_col,
             ).to_bytes(len(escaped))
             frame = hdr + escaped
         else:
-            # Basic TN5250 carries AID and cursor address in the data stream.
-            frame = bytes([aid, cursor_row, cursor_col]) + escaped
+            # Basic TN5250: AID byte is the first byte of the payload
+            frame = bytes([aid]) + escaped
 
         frame += bytes([TelnetCmd.INTERPRET_AS_COMMAND, TelnetCmd.END_OF_RECORD])
 

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/src/ibm5250/constants.py

@@ -87,7 +87,6 @@ class Command:
         0x02  # Introduces an inline WSF record within a WTD stream
     )
     ESC = 0x04  # precedes Write Structured Field inline
-    CLEAR_UNIT = 0x40  # erase the display and format table
     WRITE_TO_DISPLAY = (
         0x11  # main screen update command; followed by CC1/CC2 and orders
     )
@@ -122,10 +121,11 @@ class CC2:
     """Control Character 2 — second byte after WTD command."""
 
     RESET = 0x00
-    UNLOCK_KEYBOARD = 0x08
-    RESET_MDT = 0x10  # Clear all MDT bits
-    RESET_MDT_UNLOCK = 0x18
+    UNLOCK_KEYBOARD = 0x01
+    RESET_MDT = 0x02  # Clear all MDT bits
+    RESET_MDT_UNLOCK = 0x03
     SET_MDT = 0x04  # Set MDT on all input fields
+    MOVE_CURSOR = 0x08  # IC order sets cursor, not default position
 
 
 # ---------------------------------------------------------------------------

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/src/ibm5250/data-stream-logic.md

@@ -24,8 +24,7 @@ The **TN5250Connection** manages the TCP socket to the IBM i (AS/400) host.
 
 ### Sending (`send_record`)
 
-1. Takes raw 5250 payload bytes. For input records, the three-byte TN5250E
-   variable header contains the cursor row, cursor column, and AID.
+1. Takes raw 5250 payload bytes.
 2. IAC-escapes them (any 0xFF in the data becomes 0xFF 0xFF).
 3. Prepends the TN5250E header (with data-type and AID byte) if in enhanced mode.
 4. Appends IAC-EOR terminator.
@@ -45,17 +44,16 @@ The **DataStreamParser** takes a raw 5250 payload (one record from the connectio
 
 Every 5250 record starts with a **command byte**:
 
-| Command                         | Meaning                                                                             |
-| ------------------------------- | ----------------------------------------------------------------------------------- |
-| `0x11` (Write to Display)       | Main screen update — followed by CC1, CC2, then orders/data                         |
-| `0x40` (Clear Unit)             | Clears the display and field definitions                                            |
-| `0x02` (Save Screen)            | Server wants to save the current screen (same format as WTD)                        |
-| `0x12` (Restore Screen)         | Server wants to restore a previously saved screen                                   |
-| `0x04` (ESC)                    | Escape prefix — next byte is the real command (Clear Unit, WTD, WSF, Save, Restore) |
-| `0xF3` (Write Structured Field) | Carries structured data like Query commands                                         |
-| `0x42/0x52/0x72/0x62`           | Read commands — server asks client to send back screen/field data                   |
-| `0x21` (Write Error Code)       | Display error on status line                                                        |
-| `0x50` (Clear Format Table)     | Discard field definitions                                                           |
+| Command                         | Meaning                                                                 |
+| ------------------------------- | ----------------------------------------------------------------------- |
+| `0x11` (Write to Display)       | Main screen update — followed by CC1, CC2, then orders/data             |
+| `0x02` (Save Screen)            | Server wants to save the current screen (same format as WTD)            |
+| `0x12` (Restore Screen)         | Server wants to restore a previously saved screen                       |
+| `0x04` (ESC)                    | Escape prefix — next byte is the real command (WTD, WSF, Save, Restore) |
+| `0xF3` (Write Structured Field) | Carries structured data like Query commands                             |
+| `0x42/0x52/0x72/0x62`           | Read commands — server asks client to send back screen/field data       |
+| `0x21` (Write Error Code)       | Display error on status line                                            |
+| `0x50` (Clear Format Table)     | Discard field definitions                                               |
 
 ### Control Characters (CC1 / CC2)
 
@@ -67,9 +65,9 @@ After a WTD or Save Screen command, two bytes control screen-level behavior:
   - `0x00`: Don't clear — overlay on existing content
 
 - **CC2** — Keyboard and field flags:
-  - `0x08`: Unlock the keyboard (let the user type)
-  - `0x10`: Reset all Modified Data Tags (MDT) on fields
-  - `0x18`: Both unlock + reset MDT
+  - `0x01`: Unlock the keyboard (let the user type)
+  - `0x02`: Reset all Modified Data Tags (MDT) on fields
+  - `0x03`: Both unlock + reset MDT
 
 ### Orders (the body of a WTD)
 
@@ -148,11 +146,6 @@ The **Screen** holds the actual state that represents what you'd see on a physic
 - `find_field_by_label(label)` — finds the first input field immediately after the given label text
 - `get_field_text(field)` — reads the EBCDIC content of a specific field and decodes it
 
-Display extraction honors 5250 non-display attributes. Text following a
-non-display attribute byte is blanked until the next display attribute, and
-fields carrying a non-display FCW (such as password fields) remain readable
-through field APIs but are omitted from rendered screen text.
-
 ---
 
 ## 4. Terminal Layer (`terminal.py`)

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/src/ibm5250/datastream.py

@@ -36,6 +36,7 @@ from dataclasses import dataclass, field
 from enum import Enum, auto
 
 from .constants import (
+    _KNOWN_ORDERS,
     AID,
     CC1,
     EBCDIC_NULL,
@@ -86,7 +87,6 @@ class DSEvent:
     data: bytes = b""  # EBCDIC bytes (WRITE_CHARS, REPEAT_TO char, …)
     field_format_word: bytes = b""  # Field Format Word 2-byte tuple (START_FIELD)
     field_control_words: list[bytes] = field(default_factory=list)  # optional FCW pairs
-    field_length: int = 0  # explicit field length supplied by an FCW
     attribute_type: int = 0  # SA attribute type
     attribute_value: int = 0  # SA attribute value
     command: int = 0  # raw command byte (COMMAND event)
@@ -208,20 +208,8 @@ class DataStreamParser:
                     byte_offset,
                     data_view[byte_offset] if byte_offset < total_bytes else 0xFF,
                 )
-                clear_unit = (
-                    byte_offset < total_bytes
-                    and data_view[byte_offset] == Command.CLEAR_UNIT
-                )
-                if clear_unit:
-                    byte_offset += 1
-                    yield DSEvent(
-                        type=DSEventType.COMMAND,
-                        command=Command.CLEAR_UNIT,
-                    )
-                    yield DSEvent(type=DSEventType.CLEAR_SCREEN)
                 if (
-                    not clear_unit
-                    and byte_offset < total_bytes
+                    byte_offset < total_bytes
                     and data_view[byte_offset] == Command.WRITE_STRUCTURED_FIELD
                 ):
                     # ESC 0xF3 — Write Structured Field
@@ -234,7 +222,7 @@ class DataStreamParser:
                 if byte_offset < total_bytes and data_view[byte_offset] in (
                     Command.SAVE_SCREEN,
                     Command.RESTORE_SCREEN,
-                ) and not clear_unit:
+                ):
                     sub_command = data_view[byte_offset]
                     byte_offset += 1
                     log.debug(
@@ -244,17 +232,14 @@ class DataStreamParser:
                     return
                 # ESC + WTD (0x11): explicit Write to Display
                 if (
-                    not clear_unit
-                    and byte_offset < total_bytes
+                    byte_offset < total_bytes
                     and data_view[byte_offset] == Command.WRITE_TO_DISPLAY
                 ):
                     byte_offset += 1  # consume the 0x11 WTD byte
                     # fall through to read CC1/CC2 below
                 # ESC used as an implicit WTD command: next two bytes are CC1/CC2.
                 # IBM i sometimes sends 0x04 CC1 CC2 orders instead of 0x11 CC1 CC2.
-                if clear_unit:
-                    pass
-                elif byte_offset + 2 > total_bytes:
+                if byte_offset + 2 > total_bytes:
                     # Only one byte remains — treat it as a standalone CC1 (clear command)
                     if byte_offset + 1 <= total_bytes:
                         cc1 = data_view[byte_offset]
@@ -273,33 +258,32 @@ class DataStreamParser:
                     else:
                         log.debug("ESC with insufficient bytes for CC1/CC2 — skipping")
                     return
-                else:
-                    cc1 = data_view[byte_offset]
-                    cc2 = data_view[byte_offset + 1]
-                    byte_offset += 2
-                    log.debug(
-                        "ESC treated as implicit WTD: CC1=0x%02X CC2=0x%02X", cc1, cc2
-                    )
-                    yield DSEvent(
-                        type=DSEventType.COMMAND,
-                        command=command_byte,
-                        control_char_1=cc1,
-                        control_char_2=cc2,
-                    )
-                    cc1_clear_flags = cc1 & (CC1.CLEAR_UNIT | CC1.CLEAR_UNIT_ALT)
-                    if cc1_clear_flags in (
-                        CC1.CLEAR_UNIT,
-                        CC1.CLEAR_UNIT_ALT,
-                        CC1.CLEAR_FORMAT_TABLE,
-                    ):  # Clear Unit, Clear Unit Alternate, or Clear Format Table
-                        yield DSEvent(type=DSEventType.CLEAR_SCREEN)
-                        if cc1_clear_flags == CC1.CLEAR_UNIT_ALT:
-                            alt_rows = SCREEN_ROWS if self.rows == SCREEN_ROWS_27 else SCREEN_ROWS_27
-                            alt_cols = SCREEN_COLS if self.cols == SCREEN_COLS_132 else SCREEN_COLS_132
-                            self.rows = alt_rows
-                            self.cols = alt_cols
-                            self._size = alt_rows * alt_cols
-                            yield DSEvent(type=DSEventType.RESIZE_SCREEN, rows=alt_rows, cols=alt_cols)
+                cc1 = data_view[byte_offset]
+                cc2 = data_view[byte_offset + 1]
+                byte_offset += 2
+                log.debug(
+                    "ESC treated as implicit WTD: CC1=0x%02X CC2=0x%02X", cc1, cc2
+                )
+                yield DSEvent(
+                    type=DSEventType.COMMAND,
+                    command=command_byte,
+                    control_char_1=cc1,
+                    control_char_2=cc2,
+                )
+                cc1_clear_flags = cc1 & (CC1.CLEAR_UNIT | CC1.CLEAR_UNIT_ALT)
+                if cc1_clear_flags in (
+                    CC1.CLEAR_UNIT,
+                    CC1.CLEAR_UNIT_ALT,
+                    CC1.CLEAR_FORMAT_TABLE,
+                ):  # Clear Unit, Clear Unit Alternate, or Clear Format Table
+                    yield DSEvent(type=DSEventType.CLEAR_SCREEN)
+                    if cc1_clear_flags == CC1.CLEAR_UNIT_ALT:
+                        alt_rows = SCREEN_ROWS if self.rows == SCREEN_ROWS_27 else SCREEN_ROWS_27
+                        alt_cols = SCREEN_COLS if self.cols == SCREEN_COLS_132 else SCREEN_COLS_132
+                        self.rows = alt_rows
+                        self.cols = alt_cols
+                        self._size = alt_rows * alt_cols
+                        yield DSEvent(type=DSEventType.RESIZE_SCREEN, rows=alt_rows, cols=alt_cols)
 
             case _:
                 # Unrecognised command — treat remainder as orders/data
@@ -473,7 +457,6 @@ class DataStreamParser:
                     # Collect optional Field Control Word (FCW) pairs (2 bytes each).
                     # FCW pairs follow until we encounter a known order byte or run out of data.
                     field_control_words: list[bytes] = []
-                    field_length = 0
                     while byte_offset + 2 <= total_bytes:
                         next_byte = data_view[byte_offset]
                         # Orders that can immediately follow an SF/MF — stop collecting FCWs
@@ -498,10 +481,17 @@ class DataStreamParser:
                         )
                         byte_offset += 2
                         field_control_words.append(field_control_word)
-                        fcw_type = field_control_word[0] & 0x7F
-                        if fcw_type in (0x22, 0x26) and byte_offset < total_bytes:
-                            field_length = data_view[byte_offset]
-                            byte_offset += 1
+                        # FCW type 0x22 carries an additional field-length byte
+                        if (field_control_word[0] & 0x7F) == 0x22 and byte_offset < total_bytes:
+                            byte_offset += 1  # skip field length byte
+                        # FCW type 0x26 (resequencing) carries an additional byte;
+                        # only skip it if the next byte is an inline WSF/ESC marker
+                        elif (field_control_word[0] & 0x7F) == 0x26 and byte_offset < total_bytes:
+                            next_byte_val = data_view[byte_offset]
+                            if next_byte_val not in (
+                                Command.INLINE_WRITE_STRUCTURED_FIELD, Command.ESC
+                            ):
+                                byte_offset += 1  # skip resequencing extra byte
                         # If bit 15 of the FCW is 0, this is the last FCW in the chain
                         if not (field_control_word[0] & FCW.CONTINUATION_BIT):
                             break
@@ -510,26 +500,34 @@ class DataStreamParser:
                         position=current_buffer_position,
                         field_format_word=field_format_word,
                         field_control_words=field_control_words,
-                        field_length=field_length,
                     )
                     yield ev
                     current_buffer_position = (
                         current_buffer_position + 1
                     ) % self._size  # attribute byte consumes one position
 
-                # --- Inline attribute marker (0x02) / ESC (0x04) ---
+                # --- Inline Write Structured Field (0x02) / ESC (0x04) ---
+                # IBM i embeds 0x02 XX YY sequences in text to carry colour/attribute overrides. Each marker is exactly 3 bytes.
+                # 0x04 (ESC) in the order stream also introduces structured fields.
                 case Command.INLINE_WRITE_STRUCTURED_FIELD | Command.ESC:
                     next_byte = data_view[byte_offset + 1] if byte_offset + 1 < total_bytes else 0xFF
-                    if current_byte == Command.INLINE_WRITE_STRUCTURED_FIELD:
-                        byte_offset += min(4, total_bytes - byte_offset)
+                    third_byte = data_view[byte_offset + 2] if byte_offset + 2 < total_bytes else 0xFF
+                    # Disambiguate: 0x04 0x11 could be ESC+WTD or data+SBA.
+                    # If the third byte is a plausible 1-based SBA row address (0x01–0x1B),
+                    # this is a data byte followed by an SBA order — not ESC+WTD.
+                    # Row 0x00 is invalid for SBA (1-based encoding), so that case
+                    # falls through to the ESC+WTD handler.
+                    if next_byte == Order.SET_BUFFER_ADDRESS and 0x01 <= third_byte <= 0x1B:
+                        # byte[+1] is a real order and byte[+2] is a plausible operand
+                        # → 0x02/0x04 is just a data byte, not a WSF marker
+                        byte_offset += 1
                     # ESC + WTD (0x04 0x11): embedded Write to Display sub-command
-                    elif next_byte == Command.WRITE_TO_DISPLAY:
+                    elif current_byte == Command.ESC and next_byte == Command.WRITE_TO_DISPLAY:
                         if byte_offset + 4 > total_bytes:
                             break
                         cc1 = data_view[byte_offset + 2]
                         cc2 = data_view[byte_offset + 3]
                         byte_offset += 4  # consume ESC + WTD + CC1 + CC2
-                        current_buffer_position = 0
                         log.debug(
                             "Inline ESC+WTD: CC1=0x%02X CC2=0x%02X", cc1, cc2
                         )
@@ -549,8 +547,18 @@ class DataStreamParser:
                                 self.cols = alt_cols
                                 self._size = alt_rows * alt_cols
                                 yield DSEvent(type=DSEventType.RESIZE_SCREEN, rows=alt_rows, cols=alt_cols)
+                    elif current_byte == Command.INLINE_WRITE_STRUCTURED_FIELD and next_byte == 0x00:
+                        # 0x02 0x00 0x00 XX — consume 3 if the 4th byte is a structural order
+                        # (preserving the order), otherwise consume 4 (the 4th byte is trailing padding)
+                        fourth_byte = data_view[byte_offset + 3] if byte_offset + 3 < total_bytes else 0xFF
+                        if fourth_byte in _KNOWN_ORDERS or fourth_byte in (
+                            Command.INLINE_WRITE_STRUCTURED_FIELD, Command.ESC
+                        ):
+                            byte_offset += 3
+                        else:
+                            byte_offset += 4 if byte_offset + 4 <= total_bytes else (total_bytes - byte_offset)
                     else:
-                        # Other inline ESC markers are four bytes.
+                        # Real inline WSF attribute marker (4 bytes: marker + type + value + trailing)
                         byte_offset += 4 if byte_offset + 4 <= total_bytes else 3
 
                 # --- SET_ATTRIBUTE ---
@@ -687,8 +695,6 @@ def build_aid_response(
     cursor_pos: int,
     fields: list[FieldResponse],
     cols: int = SCREEN_COLS,
-    *,
-    include_cursor: bool = True,
 ) -> bytes:
     """Build the workstation→host input response record payload.
 
@@ -711,16 +717,10 @@ def build_aid_response(
     bytes
         Raw 5250 payload ready for :meth:`TN5250Connection.send_record`.
     """
-    response_payload = bytearray()
-    if include_cursor and not fields:
-        address_high, address_low = encode_addr(cursor_pos, cols)
-        response_payload += bytes(
-            [Order.SET_BUFFER_ADDRESS, address_high, address_low]
-        )
-
     if fields:
+        # The cursor SBA doubles as the first field's SBA — no separate entry needed.
         address_high, address_low = encode_addr(fields[0].buffer_pos, cols)
-        response_payload += bytes(
+        response_payload = bytearray(
             [Order.SET_BUFFER_ADDRESS, address_high, address_low]
         )
         response_payload += fields[0].data.rstrip(bytes([EBCDIC_SPACE, EBCDIC_NULL]))
@@ -734,6 +734,13 @@ def build_aid_response(
             response_payload += field_response.data.rstrip(
                 bytes([EBCDIC_SPACE, EBCDIC_NULL])
             )
+    else:
+        # No modified fields — send cursor position only.
+        address_high, address_low = encode_addr(cursor_pos, cols)
+        response_payload = bytearray(
+            [Order.SET_BUFFER_ADDRESS, address_high, address_low]
+        )
+
     return bytes(response_payload)
 
 

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/src/ibm5250/screen.py

@@ -19,7 +19,6 @@ from collections.abc import Sequence
 from dataclasses import dataclass, field
 
 from .constants import (
-    CC2,
     EBCDIC_NULL,
     EBCDIC_SPACE,
     FFW,
@@ -65,7 +64,6 @@ class Field:
         False  # Modified Data Tag — set when user edits the field
     )
     _saved_data: bytes = b""  # original content before user modification
-    _explicit_length: int = 0
 
     # ---- derived properties ----
 
@@ -92,16 +90,7 @@ class Field:
     @property
     def is_non_display(self) -> bool:
         """True when the field is non-display (password entry)."""
-        return (
-            (self.field_format_word[1] & FFW.DISPLAY_ATTR_MASK) == FFW.NON_DISPLAY
-            or (
-                self.field_format_word[1] == 0x00
-                and any(
-                    (fcw[0] & 0x7F) == 0x27
-                    for fcw in self.field_control_words
-                )
-            )
-        )
+        return (self.field_format_word[1] & 0xE0) == FFW.NON_DISPLAY
 
     @property
     def mdt(self) -> bool:
@@ -200,7 +189,7 @@ class Screen:
 
         elif event_type == DSEventType.COMMAND:
             cc2 = event.control_char_2
-            if cc2 & CC2.RESET_MDT:
+            if cc2 & 0x02:  # reset MDT bits on all fields
                 for screen_field in self._fields:
                     screen_field.mdt = False
 
@@ -212,6 +201,17 @@ class Screen:
 
         elif event_type == DSEventType.WRITE_CHARS:
             self._write(event.position, event.data)
+            # Clear ghost tail when a shorter value overwrites a longer one
+            pos = event.position
+            new_len = len(event.data)
+            prev_len = self._write_lengths.get(pos, 0)
+            if prev_len > new_len:
+                tail_start = pos + new_len
+                tail_end = min(pos + prev_len, self._size)
+                self._chars[tail_start:tail_end] = (
+                    bytes([EBCDIC_SPACE]) * (tail_end - tail_start)
+                )
+            self._write_lengths[pos] = new_len
 
         elif event_type == DSEventType.ERASE_TO:
             self._fill_range(event.position, event.attribute_value, EBCDIC_NULL)
@@ -236,10 +236,7 @@ class Screen:
         pre_existing_field_rows: set[int] = {f.start_pos // self.cols for f in self._fields}
 
         for ev in events:
-            if (
-                ev.type == DSEventType.COMMAND
-                and ev.control_char_2 & CC2.UNLOCK_KEYBOARD
-            ):
+            if ev.type == DSEventType.COMMAND and ev.control_char_2 & 0x01:
                 deferred_unlock = True
             if ev.type == DSEventType.CLEAR_SCREEN:
                 has_clear = True
@@ -311,14 +308,23 @@ class Screen:
         zero_based_row = row - 1
         zero_based_col = col - 1
         buffer_pos = rowcol_to_pos(zero_based_row, zero_based_col, self.cols)
-        positions = [(buffer_pos + offset) % self._size for offset in range(length)]
-        return ebcdic_decode(self._display_bytes(positions))
+        raw_bytes = bytes(self._chars[buffer_pos : buffer_pos + length])
+        if len(raw_bytes) < length:
+            # Wrap around to the beginning of the buffer
+            raw_bytes += bytes(self._chars[: length - len(raw_bytes)])
+        # Replace attribute bytes (< 0x40) with EBCDIC space so they display as blank
+        display_bytes = bytes(b if b >= 0x40 else EBCDIC_SPACE for b in raw_bytes)
+        return ebcdic_decode(display_bytes)
 
     def get_row(self, row: int) -> str:
         """Return the full text of *row* (0-based) as a Python string."""
         row_start_pos = row * self.cols
-        positions = range(row_start_pos, row_start_pos + self.cols)
-        return ebcdic_decode(self._display_bytes(positions))
+        row_bytes = self._chars[row_start_pos : row_start_pos + self.cols]
+        # Bytes 0x00–0x3F are IBM 5250 field/character attribute cells, not
+        # displayable characters.  Replace them with EBCDIC space (0x40) so
+        # they render as blanks rather than as garbage CP037 glyphs.
+        display_bytes = bytes(b if b >= 0x40 else EBCDIC_SPACE for b in row_bytes)
+        return ebcdic_decode(display_bytes)
 
     def get_all_rows(self) -> list[str]:
         """Return all rows as a list of strings."""
@@ -359,15 +365,7 @@ class Screen:
             f._saved_data = bytes(self._chars[pos : pos + write_len])
         self._chars[pos : pos + len(encoded)] = encoded
         f.mdt = True
-        self._cursor = min(pos + len(encoded), self._size - 1)
-        if len(encoded) == write_len:
-            next_fields = [
-                candidate
-                for candidate in self.input_fields
-                if candidate.data_pos > f.data_pos
-            ]
-            if next_fields:
-                self._cursor = min(next_fields, key=lambda candidate: candidate.data_pos).data_pos
+        self._cursor = pos  # move cursor into the field
 
     # ---- field lookups ----
 
@@ -584,38 +582,6 @@ class Screen:
         self._write_lengths.clear()
         self._keyboard_locked = True
 
-    def _display_bytes(self, positions: Sequence[int]) -> bytes:
-        """Return displayable bytes, honoring non-display attributes and fields."""
-        position_list = list(positions)
-        if not position_list:
-            return b""
-
-        hidden = False
-        for byte in self._chars[: position_list[0]]:
-            if 0x20 <= byte <= 0x3F:
-                hidden = (byte & 0x07) == 0x07
-
-        non_display_positions = {
-            pos
-            for screen_field in self._fields
-            if screen_field.is_non_display
-            for pos in range(
-                screen_field.data_pos,
-                min(screen_field.data_pos + screen_field.length, self._size),
-            )
-        }
-        display = bytearray()
-        for pos in position_list:
-            byte = self._chars[pos]
-            if 0x20 <= byte <= 0x3F:
-                hidden = (byte & 0x07) == 0x07
-                display.append(EBCDIC_SPACE)
-            elif byte < 0x40 or hidden or pos in non_display_positions:
-                display.append(EBCDIC_SPACE)
-            else:
-                display.append(byte)
-        return bytes(display)
-
     def _write(self, start: int, data: bytes) -> None:
         end = min(start + len(data), self._size)
         count = end - start
@@ -634,10 +600,8 @@ class Screen:
         """Add or update a field from an SF/MF event."""
         new_field = Field(
             start_pos=event.position,
-            length=event.field_length,
             field_format_word=event.field_format_word,
             field_control_words=event.field_control_words,
-            _explicit_length=event.field_length,
         )
         # Replace any existing field at this position (dedup, preserving order)
         for i, existing in enumerate(self._fields):
@@ -657,9 +621,6 @@ class Screen:
         if not fields:
             return
         for field_index, current_field in enumerate(fields):
-            if current_field._explicit_length:
-                current_field.length = current_field._explicit_length
-                continue
             if field_index + 1 < len(fields):
                 next_field_start_pos = fields[field_index + 1].start_pos
             else:

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/src/ibm5250/terminal.py

@@ -156,7 +156,6 @@ class Terminal:
         self._cols = cols
         self._saved_screens: list[Screen] = []
         self._save_pending: bool = False
-        self._screen_before_partial_update: Screen | None = None
 
     # ------------------------------------------------------------------
     # Connection management
@@ -210,8 +209,6 @@ class Terminal:
         wait:
             Block until a screen update is received.
         """
-        if self._screen.keyboard_locked:
-            self.wait_for_keyboard_unlock()
         self._send_aid(aid)
         if wait:
             self._recv_and_apply()
@@ -523,18 +520,9 @@ class Terminal:
             for modified_field in modified_fields
         ]
         aid_payload = build_aid_response(
-            self._screen.cursor_pos,
-            field_responses,
-            cols=self._screen.cols,
-            include_cursor=False,
-        )
-        self._conn.send_record(
-            aid_payload,
-            data_type=TN5250EDataType.INPUT,
-            aid=aid,
-            cursor_pos=self._screen.cursor_pos,
-            cols=self._screen.cols,
+            self._screen.cursor_pos, field_responses, cols=self._screen.cols
         )
+        self._conn.send_record(aid_payload, data_type=TN5250EDataType.INPUT, aid=aid)
         self._screen.clear_modified_fields()
         self._screen._keyboard_locked = True
         if aid in (AID.PAGE_DOWN, AID.PAGE_UP):
@@ -565,9 +553,7 @@ class Terminal:
                 event.type == DSEventType.COMMAND
                 and event.command == Command.SAVE_SCREEN
             ):
-                screen_to_save = self._screen_before_partial_update or self._screen
-                self._saved_screens.append(screen_to_save.copy())
-                self._screen_before_partial_update = None
+                self._saved_screens.append(self._screen.copy())
                 self._save_pending = True
                 self._conn.send_save_screen_response()
             elif (
@@ -575,12 +561,10 @@ class Terminal:
                 and event.command == Command.RESTORE_SCREEN
             ):
                 if self._saved_screens:
+                    # Back-to-back SAVE+RESTORE: discard the redundant save
                     if self._save_pending and len(self._saved_screens) >= 2:
-                        saved_current = self._saved_screens.pop()
-                        self._screen = self._saved_screens.pop()
-                        self._saved_screens.append(saved_current)
-                    else:
-                        self._screen = self._saved_screens.pop()
+                        self._saved_screens.pop()
+                    self._screen = self._saved_screens.pop()
                     self._screen.clear_modified_fields()
                     # If a CLEAR_UNIT_ALT resized the parser before restore,
                     # the restored screen dimensions won't match — resize preserving content
@@ -622,6 +606,7 @@ class Terminal:
         if restore_index is not None:
             post_events = parsed_events[restore_index + 1:]
             self._screen.apply_all(post_events)
+            print(f"RESTORE: screen text after apply_all:\n{self._screen.get_screen_text()}")
             # After RESTORE, the saved screen has keyboard locked. The server
             # sends a follow-up record to unlock it — consume it now to
             # prevent out-of-turn AID sends.
@@ -631,18 +616,6 @@ class Terminal:
                 except RecvTimeout:
                     pass
         else:
-            has_screen_content = any(
-                event.type not in (DSEventType.COMMAND, DSEventType.QUERY)
-                for event in parsed_events
-            )
-            if has_screen_content:
-                if any(
-                    event.type == DSEventType.CLEAR_SCREEN
-                    for event in parsed_events
-                ):
-                    self._screen_before_partial_update = None
-                else:
-                    self._screen_before_partial_update = self._screen.copy()
             self._screen.apply_all(parsed_events)
 
     def _send_query_reply(self) -> None:

{ibm5250-0.1.0.dev5 → ibm5250-0.1.0.dev6}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "ibm5250"
-version = "0.1.0.dev5"
+version = "0.1.0.dev6"
 source = { editable = "." }
 
 [package.dev-dependencies]