nc-gcode-interpreter 0.2.4__tar.gz → 0.2.6__tar.gz

{nc_gcode_interpreter-0.2.4 → nc_gcode_interpreter-0.2.6}/CHANGELOG.md

@@ -4,6 +4,50 @@ Notable changes to **nc-gcode-interpreter**. The format loosely follows
 [Keep a Changelog](https://keepachangelog.com/); versions are git tags,
 released to PyPI.
 
+## [v0.2.6] - 2026-07-09
+
+### Added
+
+- String operations (manual 4.1.4), so real CAM programs that build a
+  timestamped protocol-file name now parse and run end to end:
+  - Single-character writes into a STRING variable, `STRING[<index>] = "<char>"`
+    (manual 4.1.4.8), 0-based; only user-defined variables, never system
+    variables. The right-hand side must be exactly one character and the index
+    in range, both enforced loudly.
+  - The `<<` concatenation operator, joining quoted strings, STRING variables,
+    string functions and numbers (INT in plain form, REAL with up to 10 decimals
+    and trailing zeros trimmed, per manual 4.1.4.1).
+  - String functions: `SPRINT` (printf-style: `%d %f %s %x %b %c` with field
+    width and precision; unsupported conversions error loudly), `SUBSTR`,
+    `INDEX`, `RINDEX`, `NUMBER`, `STRLEN`, `ISNUMBER`. All string indices are
+    0-based; the search family returns `-1` when not found; `NUMBER` on a
+    non-numeric string is a hard error.
+
+### Fixed
+
+- A quoted string that is only whitespace (e.g. `" "`) no longer loses its
+  content: the implicit `WHITESPACE` rule used to eat it, so `INDEX(x, " ")`
+  found nothing — exactly the space that date-formatting code searches for.
+  Quoted-string bodies are now taken verbatim (leading/trailing spaces too).
+- Declaring a variable whose name collides with a reserved axis letter *with*
+  an initializer (e.g. `DEF STRING[13] S = "..."`) now reports the name
+  collision ("conflicts with an axis name") instead of a confusing downstream
+  "cannot assign a string" error.
+
+## [v0.2.5] - 2026-07-08
+
+### Changed
+
+- Interpreter throughput on the DataFrame/batch path: the per-output-row `Row`
+  allocations are now recycled instead of freed. Profiling the 1.1 GB → DataFrame
+  conversion showed ~50% of CPU in the system allocator, dominated by allocating
+  and freeing each of the 22M rows' cell buffers. After a batch is built its rows
+  are cleared (capacity retained) into a pool and handed back to the interpreter
+  to refill, bounding live row allocations to ~2× the batch size instead of the
+  whole-file row count. Output is byte-identical; the streaming (`nc_to_rows`)
+  and in-memory collect paths are unchanged. ~10% off end-to-end on the large
+  real-world program (#61).
+
 ## [v0.2.4] - 2026-07-08
 
 ### Changed

{nc_gcode_interpreter-0.2.4 → nc_gcode_interpreter-0.2.6}/Cargo.lock

@@ -506,7 +506,7 @@ checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
 [[package]]
 name = "nc-gcode-interpreter"
-version = "0.2.4"
+version = "0.2.6"
 dependencies = [
  "arrow-array",
  "arrow-data",

{nc_gcode_interpreter-0.2.4 → nc_gcode_interpreter-0.2.6}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nc-gcode-interpreter"
-version = "0.2.4"
+version = "0.2.6"
 edition = "2021"
 readme = "README.md"
 

{nc_gcode_interpreter-0.2.4 → nc_gcode_interpreter-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nc-gcode-interpreter
-Version: 0.2.4
+Version: 0.2.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3.12

nc_gcode_interpreter-0.2.6/python/tests/test_string_operations.py

@@ -0,0 +1,79 @@
+"""String operations from NC programming manual 4.1.4: single-character
+writes, `<<` concatenation, and the SPRINT/SUBSTR/INDEX/NUMBER family."""
+
+import pytest
+from nc_gcode_interpreter import nc_to_dataframe
+
+
+def test_single_character_write_replaces_one_character():
+    """STRING[<index>] = "<char>" overwrites one character in place (manual
+    4.1.4.8); index 5 is the space in "AXIS N HERE" (0-based)."""
+    _df, state = nc_to_dataframe('DEF STRING[13] MSG = "AXIS N HERE"\nMSG[5] = "X"\n')
+    assert state["string_table"]["MSG"] == "AXIS X HERE"
+
+
+def test_date_formatting_idiom_zero_pads_with_index_and_char_write():
+    """The real CAM idiom that motivated this feature: SPRINT a date (its
+    `%2d` fields space-pad single digits), then replace every space with "0"
+    via a WHILE/INDEX/char-write loop."""
+    program = (
+        "DEF STRING[13] DT\n"
+        'DT = SPRINT("20%2d%2d%2dT%2d%2d", 24, 5, 29, 13, 31)\n'
+        'WHILE (INDEX(DT, " ") > 0)\n'
+        '  DT[INDEX(DT, " ")] = "0"\n'
+        "ENDWHILE\n"
+    )
+    _df, state = nc_to_dataframe(program)
+    assert state["string_table"]["DT"] == "20240529T1331"
+
+
+def test_concat_operator_joins_strings_and_formats_numbers():
+    """`<<` joins quoted strings and STRING variables; an INT converts to
+    plain form and a REAL keeps up to 10 decimals with trailing zeros trimmed
+    (manual 4.1.4.1) - distinct from SPRINT `%F`'s fixed six decimals."""
+    program = (
+        "DEF STRING[13] DT = \"20240529T1331\"\n"
+        "DEF STRING[100] WF\n"
+        'WF = "//NC:/DIR/CAL_" << DT << ".TXT"\n'
+        "DEF INT IDX = 2\n"
+        "DEF REAL VAL = 9.654\n"
+        "DEF STRING[50] MSGS\n"
+        'MSGS = "i:" << IDX << "/v:" << VAL\n'
+    )
+    _df, state = nc_to_dataframe(program)
+    assert state["string_table"]["WF"] == "//NC:/DIR/CAL_20240529T1331.TXT"
+    assert state["string_table"]["MSGS"] == "i:2/v:9.654"
+
+
+@pytest.mark.parametrize(
+    "expression, expected",
+    [
+        ('NUMBER(SUBSTR("20240529T1331", 2, 2))', 24.0),
+        ('STRLEN("20240529T1331")', 13.0),
+        ('INDEX("20240529T1331", "T")', 8.0),
+        ('INDEX("20240529T1331", "Q")', -1.0),
+        ('RINDEX("20240529T1331", "3")', 11.0),
+        ('ISNUMBER("12.5")', 1.0),
+        ('ISNUMBER("x9")', 0.0),
+    ],
+)
+def test_string_query_functions(expression, expected):
+    """INDEX/RINDEX/STRLEN/ISNUMBER are 0-based; the search family returns -1
+    when the character is not found (manual 4.1.4.6)."""
+    _df, state = nc_to_dataframe(f"R1={expression}")
+    assert state["symbol_table"]["R1"] == expected
+
+
+def test_number_on_non_numeric_string_raises():
+    """NUMBER on a string that is not a valid number is a loud failure, never
+    a silent 0 (manual 4.1.4.2)."""
+    with pytest.raises(ValueError, match="not a valid number"):
+        nc_to_dataframe('R1 = NUMBER("abc")')
+
+
+def test_whitespace_only_string_literal_keeps_its_content():
+    """Regression: a quoted string that is only whitespace (e.g. " ") must
+    keep its content rather than being eaten by implicit whitespace skipping -
+    exactly the space the date-zeroing idiom above searches for."""
+    _df, state = nc_to_dataframe('DEF STRING[8] STR = " X"\nR1 = INDEX(STR, " ")\n')
+    assert state["symbol_table"]["R1"] == 0.0

{nc_gcode_interpreter-0.2.4 → nc_gcode_interpreter-0.2.6}/src/grammar.pest

@@ -145,16 +145,34 @@ assignment     = {
 
   | (variable ~ "=" ~ axis_increment) // variable must be an axis, and may be a normal variable. Sort it out after parsing
 
+  // A string concatenation (`<<`) must be tried before `expression`/`string_value`:
+  // those would each match only the first operand and leave `<< ...` dangling.
+  | (variable ~ "=" ~ string_expression) // string variable built with << (manual 4.1.4)
+
   | (variable ~ "=" ~ expression) // variable may be an axis, and may be a normal variable. Sort it out after parsing
 
   | (variable ~ "=" ~ string_value) // string variable (DEF STRING or reassignment); never an axis
 
+  | (variable_array ~ "=" ~ string_expression) // string-valued array element (never an axis)
+
   | (variable_array ~ "=" ~ expression) // variable may not be an axis
+
+  | (variable_array ~ "=" ~ string_value) // single-character write into a STRING variable: STRING[<index>] = "<char>" (manual 4.1.4.8)
 }
 axis_increment = { ^"IC" ~ "(" ~ expression ~ ")" }
-// A quoted string as assignment RHS. Non-silent (unlike quoted_string) so an
-// empty "" still yields a pair to interpret.
-string_value   = { QUOTE ~ string? ~ QUOTE }
+// A quoted string. Compound-atomic ($): no implicit WHITESPACE is skipped
+// between the quotes, so a string that is only spaces (e.g. " ", searched for
+// by INDEX in real date-formatting code) keeps its content instead of being
+// eaten by the WHITESPACE rule. The inner `string` pair still surfaces.
+string_value   = ${ QUOTE ~ string ~ QUOTE }
+// String concatenation with the link operator `<<` (manual 4.1.4): joins
+// quoted strings, STRING variables, string functions (SPRINT/SUBSTR) and
+// numbers (converted to text) into one string. Requires at least one `<<` so
+// a lone string or expression still matches the simpler rules. Each operand is
+// a quoted string or a full (numeric or string-returning) expression; `<<` is
+// not an expression operator, so `expression` stops at the next `<<`.
+string_expression = { concat_operand ~ ("<<" ~ concat_operand)+ }
+concat_operand    = { string_value | expression }
 
 assignment_multi =  { variable_array ~ "=" ~ (value_array | value_repeating) }
 value_array      =  { "SET" ~ "(" ~ (expression | value_none) ~ ("," ~ (expression | value_none))* ~ ")" }
@@ -203,7 +221,7 @@ integer          = @{ "-"? ~ ASCII_DIGIT+ ~ !ASCII_ALPHA } // Ensure integers ar
 arith_fun        = { arith_fun_name ~ "(" ~ function_arguments ~ ")" }
 arith_fun_name   = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
 
-tool_selection = { ^"T" ~ "=" ~ quoted_string }
+tool_selection = { ^"T" ~ "=" ~ string_value }
 
 // Frame instructions. A single rule captures the whole family (with any
 // number of axis assignments, including none: a bare substituting frame
@@ -216,9 +234,11 @@ frame_kw = @{
 
 // function call parser
 non_returning_function_call =  { identifier ~ ("(" ~ function_arguments? ~ ")")? }
-function_arguments          =  { ((expression | quoted_string)? ~ ",")* ~ (expression | quoted_string) }
-quoted_string               = _{ QUOTE ~ (string)* ~ QUOTE }
-string                      =  { (!"\"" ~ ANY)+ }
+function_arguments          =  { ((expression | string_value)? ~ ",")* ~ (expression | string_value) }
+// Atomic body: a maximal run of non-quote characters, taken verbatim with no
+// WHITESPACE skipping (may be empty for ""). Its quote wrapper (string_value)
+// is compound-atomic, so leading/trailing/only-whitespace content survives.
+string                      = @{ (!"\"" ~ ANY)* }
 
 // builtins, globally available names
 nc_variable = { "$" ~ identifier }