ibm5250 0.1.0.dev6__tar.gz → 0.1.0.dev7__tar.gz

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

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

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

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

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

@@ -33,6 +33,7 @@ from .constants import (
     TN5250EDataType,
     TN5250ERecordType,
     TN5250ESubNeg,
+    encode_addr,
 )
 from .exceptions import ConnectionError, ProtocolError, RecvTimeout
 
@@ -48,8 +49,6 @@ _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
@@ -82,10 +81,12 @@ 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: _VAR_HDR_OP_HI _VAR_HDR_OP_LO <AID>
-        var_hdr = bytes([_VAR_HDR_OP_HI, _VAR_HDR_OP_LO, self.aid])
+        # 3-byte variable header: cursor row, cursor column, AID.
+        var_hdr = bytes([self.cursor_row, self.cursor_col, self.aid])
         var_len = len(var_hdr)
         total = payload_len + _TN5250E_HEADER_LEN + var_len
         return (
@@ -238,6 +239,8 @@ 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.
 
@@ -248,16 +251,21 @@ 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: AID byte is the first byte of the payload
-            frame = bytes([aid]) + escaped
+            # Basic TN5250 carries AID and cursor address in the data stream.
+            frame = bytes([aid, cursor_row, cursor_col]) + escaped
 
         frame += bytes([TelnetCmd.INTERPRET_AS_COMMAND, TelnetCmd.END_OF_RECORD])
 

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

@@ -87,6 +87,7 @@ 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
     )
@@ -121,11 +122,10 @@ class CC2:
     """Control Character 2 — second byte after WTD command."""
 
     RESET = 0x00
-    UNLOCK_KEYBOARD = 0x01
-    RESET_MDT = 0x02  # Clear all MDT bits
-    RESET_MDT_UNLOCK = 0x03
+    UNLOCK_KEYBOARD = 0x08
+    RESET_MDT = 0x10  # Clear all MDT bits
+    RESET_MDT_UNLOCK = 0x18
     SET_MDT = 0x04  # Set MDT on all input fields
-    MOVE_CURSOR = 0x08  # IC order sets cursor, not default position
 
 
 # ---------------------------------------------------------------------------
@@ -541,10 +541,17 @@ def decode_addr(hi: int, lo: int, cols: int = SCREEN_COLS) -> int:
 
 
 def pos_to_rowcol(pos: int, cols: int = SCREEN_COLS) -> tuple[int, int]:
-    """Convert a linear position to (row, col), both 0-based."""
-    return divmod(pos, cols)
+    """Convert a zero-based linear position to a 1-based ``(row, col)``."""
+    if pos < 0:
+        raise ValueError("Buffer position must be non-negative")
+    row, col = divmod(pos, cols)
+    return row + 1, col + 1
 
 
 def rowcol_to_pos(row: int, col: int, cols: int = SCREEN_COLS) -> int:
-    """Convert (row, col) to a linear position (both 0-based)."""
-    return row * cols + col
+    """Convert a 1-based ``(row, col)`` to a zero-based linear position."""
+    if row < 1 or col < 1:
+        raise ValueError("Screen coordinates start at (1, 1)")
+    if col > cols:
+        raise ValueError(f"Column must be between 1 and {cols}")
+    return (row - 1) * cols + col - 1

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

@@ -24,7 +24,8 @@ The **TN5250Connection** manages the TCP socket to the IBM i (AS/400) host.
 
 ### Sending (`send_record`)
 
-1. Takes raw 5250 payload bytes.
+1. Takes raw 5250 payload bytes. For input records, the three-byte TN5250E
+   variable header contains the cursor row, cursor column, and AID.
 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.
@@ -44,16 +45,17 @@ 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             |
-| `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                                               |
+| 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                                                           |
 
 ### Control Characters (CC1 / CC2)
 
@@ -65,9 +67,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:
-  - `0x01`: Unlock the keyboard (let the user type)
-  - `0x02`: Reset all Modified Data Tags (MDT) on fields
-  - `0x03`: Both unlock + reset MDT
+  - `0x08`: Unlock the keyboard (let the user type)
+  - `0x10`: Reset all Modified Data Tags (MDT) on fields
+  - `0x18`: Both unlock + reset MDT
 
 ### Orders (the body of a WTD)
 
@@ -146,6 +148,11 @@ 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.dev6 → ibm5250-0.1.0.dev7}/src/ibm5250/datastream.py

@@ -36,7 +36,6 @@ from dataclasses import dataclass, field
 from enum import Enum, auto
 
 from .constants import (
-    _KNOWN_ORDERS,
     AID,
     CC1,
     EBCDIC_NULL,
@@ -87,6 +86,7 @@ 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,8 +208,20 @@ class DataStreamParser:
                     byte_offset,
                     data_view[byte_offset] if byte_offset < total_bytes else 0xFF,
                 )
-                if (
+                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
                     and data_view[byte_offset] == Command.WRITE_STRUCTURED_FIELD
                 ):
                     # ESC 0xF3 — Write Structured Field
@@ -222,7 +234,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(
@@ -232,14 +244,17 @@ class DataStreamParser:
                     return
                 # ESC + WTD (0x11): explicit Write to Display
                 if (
-                    byte_offset < total_bytes
+                    not clear_unit
+                    and 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 byte_offset + 2 > total_bytes:
+                if clear_unit:
+                    pass
+                elif 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]
@@ -258,32 +273,33 @@ class DataStreamParser:
                     else:
                         log.debug("ESC with insufficient bytes for CC1/CC2 — skipping")
                     return
-                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)
+                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)
 
             case _:
                 # Unrecognised command — treat remainder as orders/data
@@ -457,6 +473,7 @@ 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
@@ -481,17 +498,10 @@ class DataStreamParser:
                         )
                         byte_offset += 2
                         field_control_words.append(field_control_word)
-                        # 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
+                        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
                         # 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
@@ -500,34 +510,26 @@ 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 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.
+                # --- Inline attribute marker (0x02) / ESC (0x04) ---
                 case Command.INLINE_WRITE_STRUCTURED_FIELD | Command.ESC:
                     next_byte = data_view[byte_offset + 1] if byte_offset + 1 < total_bytes else 0xFF
-                    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
+                    if current_byte == Command.INLINE_WRITE_STRUCTURED_FIELD:
+                        byte_offset += min(4, total_bytes - byte_offset)
                     # ESC + WTD (0x04 0x11): embedded Write to Display sub-command
-                    elif current_byte == Command.ESC and next_byte == Command.WRITE_TO_DISPLAY:
+                    elif 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
                         )
@@ -547,18 +549,8 @@ 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:
-                        # Real inline WSF attribute marker (4 bytes: marker + type + value + trailing)
+                        # Other inline ESC markers are four bytes.
                         byte_offset += 4 if byte_offset + 4 <= total_bytes else 3
 
                 # --- SET_ATTRIBUTE ---
@@ -695,6 +687,8 @@ 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.
 
@@ -717,10 +711,16 @@ 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 = bytearray(
+        response_payload += bytes(
             [Order.SET_BUFFER_ADDRESS, address_high, address_low]
         )
         response_payload += fields[0].data.rstrip(bytes([EBCDIC_SPACE, EBCDIC_NULL]))
@@ -734,13 +734,6 @@ 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.dev6 → ibm5250-0.1.0.dev7}/src/ibm5250/screen.py

@@ -19,6 +19,7 @@ from collections.abc import Sequence
 from dataclasses import dataclass, field
 
 from .constants import (
+    CC2,
     EBCDIC_NULL,
     EBCDIC_SPACE,
     FFW,
@@ -64,6 +65,8 @@ 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
+    _screen_cols: int = SCREEN_COLS
 
     # ---- derived properties ----
 
@@ -90,7 +93,16 @@ class Field:
     @property
     def is_non_display(self) -> bool:
         """True when the field is non-display (password entry)."""
-        return (self.field_format_word[1] & 0xE0) == FFW.NON_DISPLAY
+        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
+                )
+            )
+        )
 
     @property
     def mdt(self) -> bool:
@@ -103,13 +115,13 @@ class Field:
 
     @property
     def row(self) -> int:
-        """0-based screen row of the first data byte."""
-        return pos_to_rowcol(self.data_pos)[0]
+        """1-based screen row of the first data byte."""
+        return pos_to_rowcol(self.data_pos, self._screen_cols)[0]
 
     @property
     def col(self) -> int:
-        """0-based screen column of the first data byte."""
-        return pos_to_rowcol(self.data_pos)[1]
+        """1-based screen column of the first data byte."""
+        return pos_to_rowcol(self.data_pos, self._screen_cols)[1]
 
     def __repr__(self) -> str:
         protection_indicator = "P" if self.is_protected else "I"
@@ -189,7 +201,7 @@ class Screen:
 
         elif event_type == DSEventType.COMMAND:
             cc2 = event.control_char_2
-            if cc2 & 0x02:  # reset MDT bits on all fields
+            if cc2 & CC2.RESET_MDT:
                 for screen_field in self._fields:
                     screen_field.mdt = False
 
@@ -201,17 +213,6 @@ 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,7 +237,10 @@ 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 & 0x01:
+            if (
+                ev.type == DSEventType.COMMAND
+                and ev.control_char_2 & CC2.UNLOCK_KEYBOARD
+            ):
                 deferred_unlock = True
             if ev.type == DSEventType.CLEAR_SCREEN:
                 has_clear = True
@@ -278,11 +282,11 @@ class Screen:
 
     @property
     def cursor_row(self) -> int:
-        return self._cursor // self.cols
+        return pos_to_rowcol(self._cursor, self.cols)[0]
 
     @property
     def cursor_col(self) -> int:
-        return self._cursor % self.cols
+        return pos_to_rowcol(self._cursor, self.cols)[1]
 
     @property
     def keyboard_locked(self) -> bool:
@@ -305,30 +309,19 @@ class Screen:
 
         Wraps across row boundaries if needed.
         """
-        zero_based_row = row - 1
-        zero_based_col = col - 1
-        buffer_pos = rowcol_to_pos(zero_based_row, zero_based_col, self.cols)
-        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)
+        buffer_pos = self._coordinate_to_pos(row, col)
+        positions = [(buffer_pos + offset) % self._size for offset in range(length)]
+        return ebcdic_decode(self._display_bytes(positions))
 
     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
-        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)
+        """Return the full text of *row* (1-based) as a Python string."""
+        row_start_pos = self._coordinate_to_pos(row, 1)
+        positions = range(row_start_pos, row_start_pos + self.cols)
+        return ebcdic_decode(self._display_bytes(positions))
 
     def get_all_rows(self) -> list[str]:
         """Return all rows as a list of strings."""
-        return [self.get_row(r) for r in range(self.rows)]
+        return [self.get_row(row) for row in range(1, self.rows + 1)]
 
     def get_screen_text(self) -> str:
         """Return the entire screen as a single newline-separated string."""
@@ -365,13 +358,21 @@ class Screen:
             f._saved_data = bytes(self._chars[pos : pos + write_len])
         self._chars[pos : pos + len(encoded)] = encoded
         f.mdt = True
-        self._cursor = pos  # move cursor into the field
+        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
 
     # ---- field lookups ----
 
     def find_field_at(self, row: int, col: int) -> Field | None:
-        """Return the field whose data area contains *(row, col)*, or ``None``."""
-        pos = rowcol_to_pos(row, col, self.cols)
+        """Return the field at 1-based *(row, col)*, or ``None``."""
+        pos = self._coordinate_to_pos(row, col)
         for f in self._fields:
             if f.data_pos <= pos < f.data_pos + f.length:
                 return f
@@ -546,14 +547,14 @@ class Screen:
     def find_text(
         self, text: str, *, case_sensitive: bool = False
     ) -> tuple[int, int] | None:
-        """Return *(row, col)* (0-based) of the first occurrence of *text*, or ``None``."""
+        """Return 1-based *(row, col)* for the first occurrence, or ``None``."""
         rows = self.get_all_rows()
-        for r, row_text in enumerate(rows):
+        for row, row_text in enumerate(rows, start=1):
             s = row_text if case_sensitive else row_text.lower()
             t = text if case_sensitive else text.lower()
             idx = s.find(t)
             if idx >= 0:
-                return r, idx
+                return row, idx + 1
         return None
 
     # ---- modified fields (for AID response) ----
@@ -575,6 +576,11 @@ class Screen:
     # Internal helpers
     # ------------------------------------------------------------------
 
+    def _coordinate_to_pos(self, row: int, col: int) -> int:
+        if row > self.rows:
+            raise ValueError(f"Row must be between 1 and {self.rows}")
+        return rowcol_to_pos(row, col, self.cols)
+
     def _clear(self) -> None:
         self._chars[:] = bytearray([EBCDIC_SPACE] * self._size)
         self._attrs[:] = bytearray(self._size)
@@ -582,6 +588,38 @@ 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
@@ -600,8 +638,11 @@ 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,
+            _screen_cols=self.cols,
         )
         # Replace any existing field at this position (dedup, preserving order)
         for i, existing in enumerate(self._fields):
@@ -621,6 +662,9 @@ 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:
@@ -647,8 +691,8 @@ class Screen:
         """Pretty-print the screen with a border (useful for debugging)."""
         divider = "+" + "-" * self.cols + "+"
         lines = [divider]
-        for r in range(self.rows):
-            lines.append("|" + self.get_row(r) + "|")
+        for row in range(1, self.rows + 1):
+            lines.append("|" + self.get_row(row) + "|")
         lines.append(divider)
         return "\n".join(lines)
 
@@ -731,8 +775,7 @@ class Screen:
 
         rows = []
         for display_row in range(display_start_row, display_end_row + 1):
-            row_idx = display_row - 1
-            row_text = self.get_row(row_idx)
+            row_text = self.get_row(display_row)
             columns = [row_text[start:end].strip() for start, end in resolved]
             rows.append([] if all(c == "" for c in columns) else columns)
         return rows

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

@@ -156,6 +156,7 @@ 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
@@ -209,6 +210,8 @@ 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()
@@ -257,7 +260,9 @@ class Terminal:
             self._screen.set_field_text(f, existing + text)
 
     def move_cursor(self, row: int, col: int) -> None:
-        """Move the cursor to *(row, col)* (0-based) without sending a key."""
+        """Move the cursor to 1-based *(row, col)* without sending a key."""
+        if row > self._rows:
+            raise ValueError(f"Row must be between 1 and {self._rows}")
         pos = rowcol_to_pos(row, col, self._cols)
         self._screen._cursor = pos
 
@@ -328,7 +333,7 @@ class Terminal:
         *,
         timeout: float | None = None,
     ) -> None:
-        """Block until the cursor lands on *(row, col)* (0-based)."""
+        """Block until the cursor lands on 1-based *(row, col)*."""
         self._wait_for(
             lambda: self._screen.cursor_row == row and self._screen.cursor_col == col,
             desc=f"cursor at ({row},{col})",
@@ -382,7 +387,7 @@ class Terminal:
         return FieldProxy(self, f)
 
     def find_field_at(self, row: int, col: int) -> FieldProxy:
-        """Return the (unprotected) field at *(row, col)* (0-based).
+        """Return the unprotected field at 1-based *(row, col)*.
 
         Raises :class:`~ibm5250.exceptions.FieldNotFound` if none exists there.
         """
@@ -520,9 +525,18 @@ class Terminal:
             for modified_field in modified_fields
         ]
         aid_payload = build_aid_response(
-            self._screen.cursor_pos, field_responses, cols=self._screen.cols
+            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._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):
@@ -553,7 +567,9 @@ class Terminal:
                 event.type == DSEventType.COMMAND
                 and event.command == Command.SAVE_SCREEN
             ):
-                self._saved_screens.append(self._screen.copy())
+                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._save_pending = True
                 self._conn.send_save_screen_response()
             elif (
@@ -561,10 +577,12 @@ 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:
-                        self._saved_screens.pop()
-                    self._screen = self._saved_screens.pop()
+                        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._screen.clear_modified_fields()
                     # If a CLEAR_UNIT_ALT resized the parser before restore,
                     # the restored screen dimensions won't match — resize preserving content
@@ -606,7 +624,6 @@ 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.
@@ -616,6 +633,18 @@ 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.dev6 → ibm5250-0.1.0.dev7}/uv.lock

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