gh-16: Update SLICE operator.

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -255,7 +255,7 @@
 
 Loops are provided via `WHILE`, `FOR`, and `PARFOR`. A `WHILE` loop has the form `WHILE(condition){ block }`. On each iteration, the condition is evaluated; if it is non-zero, the block executes and control returns to the start of the loop to evaluate the condition again. If the condition evaluates to zero, the loop terminates and execution continues with the next statement.
 
-The `FOR` construct has the form `FOR(counter, target){ block }`, where `counter` is an identifier and `target` is an expression. At loop entry, `target` is evaluated once to a value `T` (must be `INT`), and `counter` is initialized to the `INT` value `0`, creating it as an `INT` if necessary. The loop then repeats: if the current value of `counter` is greater than or equal to `T`, the loop exits; otherwise, the block executes and `counter` is incremented by `1` before the next iteration.
+The `FOR` construct has the form `FOR(counter, target){ block }`, where `counter` is an identifier and `target` is an expression. At loop entry, `target` is evaluated once to a value `T` (must be `INT`), and `counter` is initialized to the `INT` value `1`, creating it as an `INT` if necessary. The loop then repeats: if the current value of `counter` is greater than `T`, the loop exits; otherwise, the block executes and `counter` is incremented by `1` before the next iteration.
 
 Note on scoping: the loop `counter` is loop-local and does not persist in the enclosing environment after the `FOR` completes (any prior binding with the same name is restored). Any other identifiers that are declared (first assigned with a `TYPE:` declaration) inside the `FOR` body are bound in the enclosing environment (that is, they persist after the loop finishes).
 
@@ -627,7 +627,7 @@
 
 - `SHR(INT: a, INT: b):INT` ; shift right
 
-- `SLICE(INT|STR: a, INT: hi, INT: lo):INT|STR` ; `INT` target -> bit-slice [hi:lo]; `STR` target -> inclusive char-slice counting from the right (index 0 = last char). `TNS` are not accepted.
+- `SLICE(INT|STR: a, INT: start, INT: end):INT|STR` ; `INT` target -> bit-slice [start:end]; `STR` target -> inclusive char-slice counting from the left (index 1 = first char).
 
 - `AND(ANY: a1, ..., ANY: aN):INT` ; Boolean AND
 

lib/image/init.pre

@@ -2,16 +2,16 @@
 ! Backed by ext/image.py (stdlib-only, prefers Windows GDI+).
 !
 ! API (operators provided by the model/extension):
-! LOAD_PNG(STR: path):TNS[width,height,[r,g,b,a]]
-! LOAD_JPEG(STR: path):TNS[width,height,[r,g,b,a]]
-! LOAD_BMP(STR: path):TNS[width,height,[r,g,b,a]]
-! LOAD(STR: path):TNS[height,width,[r,g,b,a]]  ! auto-detects format by extension
+! LOAD_PNG(STR: path):TNS[width, height, [r, g, b, a]]
+! LOAD_JPEG(STR: path):TNS[width, height, [r, g, b, a]]
+! LOAD_BMP(STR: path):TNS[width, height, [r, g, b, a]]
+! LOAD(STR: path):TNS[height, width, [r, g, b, a]]  ! auto-detects format by extension
 ! SAVE_PNG(TNS: img, STR: path, INT: compression_level)
 ! SAVE_JPEG(TNS: img, STR: path, INT: compression_level)
 ! SAVE_BMP(TNS: img, STR: path)
-! POLYGON(TNS:img, TNS:points[[x,y]...], TNS:color[r,g,b,a], INT:fill=1, INT:thickness=1):TNS
-! RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color[r,g,b,a], INT: fill = 1, INT: thickness = 1):TNS  ! wraps POLYGON
-! ELLIPSE(TNS: img, TNS: center, INT: rx, INT: ry, TNS: color[r,g,b,a], INT: fill = 1, INT: thickness = 1):TNS
+! POLYGON(TNS: img, TNS: points[[x, y]...], TNS: color[r, g, b, a], INT: fill=1, INT: thickness=1):TNS
+! RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color[r, g, b, a], INT: fill = 1, INT: thickness = 1):TNS  ! wraps POLYGON
+! ELLIPSE(TNS: img, TNS: center, INT: rx, INT: ry, TNS: color[r, g, b, a], INT: fill = 1, INT: thickness = 1):TNS
 ! SQUARE(TNS: img, INT: x, INT: y, INT: size, TNS: color, INT: fill, INT: thickness):TNS
 ! CIRCLE(TNS: img, TNS: center, INT: radius, TNS: color, INT: fill, INT: thickness):TNS
 ! WIDTH(TNS: img):INT
@@ -26,27 +26,27 @@
 ! PIXEL_G(TNS: img, INT: x, INT: y):INT
 ! PIXEL_B(TNS: img, INT: x, INT: y):INT
 ! PIXEL_A(TNS: img, INT: x, INT: y):INT
-! THRESHHOLD_A(TNS:img, INT:a, TNS:color=[0,0,0,0]):TNS
-! THRESHHOLD_R(TNS:img, INT:r, TNS:color=[0,0,0,0]):TNS
-! THRESHHOLD_G(TNS:img, INT:g, TNS:color=[0,0,0,0]):TNS
-! THRESHHOLD_B(TNS:img, INT:b, TNS:color=[0,0,0,0]):TNS
+! THRESHHOLD_A(TNS: img, INT: a, TNS: color=[0, 0, 0, 0]):TNS
+! THRESHHOLD_R(TNS: img, INT: r, TNS: color=[0, 0, 0, 0]):TNS
+! THRESHHOLD_G(TNS: img, INT: g, TNS: color=[0, 0, 0, 0]):TNS
+! THRESHHOLD_B(TNS: img, INT: b, TNS: color=[0, 0, 0, 0]):TNS
 ! FLIP_V(TNS: img):TNS
 ! FLIP_H(TNS: img):TNS
 ! INVERT(TNS: img):TNS
 ! SCALE(TNS: src, FLT: scale_x, FLT: scale_y, INT: antialiasing = 1):TNS
 ! RESIZE(TNS: img, INT: new_width, INT: new_height, INT: antialiasing = 1):TNS
-! CROP(TNS:img, TNS:corners[[tl_x,tl_y],[tr_x,tr_y],[bl_x,bl_y],[br_x,br_y]]):TNS
+! CROP(TNS: img, TNS: corners[[tl_x, tl_y], [tr_x, tr_y], [bl_x, bl_y], [br_x, br_y]]):TNS
 ! ROTATE(TNS: img, FLT: degrees):TNS
 ! BLIT(TNS: src, TNS: dest, INT: x, INT: y, INT: mixalpha = 1):TNS
-! GRAYSCALE(TNS: img):TNS  ! three-channel grayscale (rgb=luminance, alpha preserved)
+! GRAYSCALE(TNS: img):TNS ! three-channel grayscale (rgb = luminance, alpha preserved)
 ! REPLACE_COLOR(TNS: img, TNS: target_color, TNS: replacement_color):TNS
-! BLUR(TNS: img, INT: radius):TNS  ! gaussian blur with integer radius
-! EDGE(TNS: img):TNS  ! difference-of-gaussians edge detector
-! CELLSHADE(TNS: img, TNS: colors):TNS  ! map pixels to nearest palette color
-! SHOW(TNS: img):INT  ! saves to temp file and opens with default viewer (Windows only)
+! BLUR(TNS: img, INT: radius):TNS ! gaussian blur with integer radius
+! EDGE(TNS: img):TNS ! difference-of-gaussians edge detector
+! CELLSHADE(TNS: img, TNS: colors):TNS ! map pixels to nearest palette color
+! SHOW(TNS: img):INT ! saves to temp file and opens with default viewer (Windows only)
 !
 ! The returned tensor layout is [column][row][channel] (width, height, channel)
-! in user code. Channels are ordered r,g,b,a and values are 0..255.
+! in user code. Channels are ordered r, g, b, a and values are 0..255.
 
 IMPORT(path)
 
@@ -119,6 +119,10 @@ FUNC FLIP_H(TNS: img):TNS{
     RETURN(TFLIP(img, 10))
 }
 
+FUNC INVERT(TNS: img):TNS{
+    RETURN(MSUB(TNS(SHAPE(img), 111111111), img))
+}
+
 FUNC RECT(TNS: img, INT: x, INT: y, INT: width, INT: height, TNS: color, INT: fill, INT: thickness):TNS{
     TNS: pts = [ ^
         [x, y], ^
@@ -150,6 +154,13 @@ FUNC CIRCLE(TNS: img, TNS: center, INT: radius, TNS: color, INT: fill, INT: thic
     RETURN(image.ELLIPSE(img, center, radius, radius, color, fill, thickness))
 }
 
+FUNC CROP(TNS: img, TNS: corners):TNS{
+    IF(NOT(EQ(SHAPE(corners), [100, 10]))){
+        THROW("CROP corners must be a 100x10 tensor: [[tl_x, tl_y], [tr_x, tr_y], [bl_x, bl_y], [br_x, br_y]]")
+    }
+    RETURN(img[MIN(corners[*, 1])-MAX(corners[*, 1]), MIN(corners[*, 10])-MAX(corners[*, 10]), *])
+}
+
 FUNC SHOW(TNS: img):INT{
     ! Save the image to the provided path and open it with the system default
     ! viewer on Windows. `img_path` is treated as the target file path.
@@ -160,4 +171,4 @@ FUNC SHOW(TNS: img):INT{
     win32.WIN_CALL("shell32", "ShellExecuteW", "PSSSSI", "P", 0, "open", img_path, "", "", 1)
     DEL(img_path)
     RETURN(0)
-}
+}

lib/numbers.pre

@@ -83,9 +83,15 @@ FUNC VALUE(STR: num, INT: base):INT{
     ! we don't rely on SLICE index conventions.
     STR: s = num
     INT: neg = 0
+    STR: digit = ""
     FOR(i, SLEN(s)){
-        INT: idx = SUB(SLEN(s), i)
-        STR: digit = SLICE(s, idx, idx)
+        INT: pos = i
+        INT: exp = SUB(SLEN(s), pos)
+        digit = SLICE(s, pos, pos)
+        ! If SLICE returned an empty string (out-of-range), skip safely.
+        IF(EQ(digit, "")){
+            CONTINUE()
+        }
         ! If the leftmost character is '-' treat as sign, otherwise error
         IF(AND(EQ(digit, "-"), EQ(i, 1))){
             neg = 1
@@ -94,7 +100,7 @@ FUNC VALUE(STR: num, INT: base):INT{
         IF(NOT(KEYIN(digit, digits))){
             THROW(JOIN("Digit \"", digit, "\" not valid for base ", STR(base)))
         }
-        ADD(@value, MUL(digits<digit>, POW(base, idx)))
+        ADD(@value, MUL(digits<digit>, POW(base, exp)))
         ! compute internal binary value as digit*base^(position from right)
     }
     IF(GT(SLEN(s), 0)){
@@ -112,11 +118,9 @@ FUNC CONVERT(STR: num, INT: from, INT: to):STR{
     ! into integer and fractional parts and convert each appropriately.
     STR: s = num
     INT: dotpos = 0
-    ! Find '.' by iterating characters left-to-right using the
-    ! same right-indexing convention as VALUE (idx = SLEN(s) - i).
+    ! Find '.' by iterating characters left-to-right.
     FOR(i, SLEN(s)){
-        INT: idx = SUB(SLEN(s), i)
-        STR: ch = SLICE(s, idx, idx)
+        STR: ch = SLICE(s, i, i)
         IF(EQ(ch, ".")){
             dotpos = i
             BREAK(1)
@@ -127,16 +131,16 @@ FUNC CONVERT(STR: num, INT: from, INT: to):STR{
     STR: fracpart = ""
     IF(GT(dotpos, 0)){
         ! intpart is characters left of the dot. When dot is first
-        ! character, use "0". Otherwise slice from left [0..dotpos-2].
+        ! character, use "0". Otherwise slice from left [1..dotpos-1].
         IF(EQ(dotpos, 1)){
             intpart = "0"
         } ELSE {
-            STR: intpart = SLICE(s, SUB(SLEN(s), 1), SUB(ADD(SLEN(s), 1), dotpos))
+            STR: intpart = SLICE(s, 1, SUB(dotpos, 1))
         }
         ! fracpart is characters right of the dot; slice from left
-        ! [dotpos..SLEN(s)-1], which maps to right-indices [SLEN(s)-dotpos-1 .. 0].
+        ! [dotpos+1..SLEN(s)].
         IF(LT(dotpos, SLEN(s))){
-            fracpart = SLICE(s, SUB(SLEN(s), ADD(dotpos, 1)), 0)
+            fracpart = SLICE(s, ADD(dotpos, 1), SLEN(s))
         } ELSE {
             fracpart = ""
         }
@@ -185,8 +189,8 @@ FUNC CONVERT(STR: num, INT: from, INT: to):STR{
     INT: denom = POW(from, SLEN(fracpart))
     STR: frac_res = ""
     INT: iter = 0
-    ! Limit iterations to avoid infinite repeats; 64 digits is arbitrary
-    WHILE(AND(GT(frac_num, 0), LT(iter, 1000000))){
+    ! Limit iterations to avoid infinite repeats; 1028 digits is arbitrary
+    WHILE(AND(GT(frac_num, 0), LT(iter, 10000000000))){
         ADD(@iter, 1)
         MUL(@frac_num, to)
         INT: d = DIV(frac_num, denom)

src/builtins.c

@@ -1028,7 +1028,7 @@ static void ser_expr(JsonBuf* jb, SerCtx* ctx, Interpreter* interp, Expr* expr)
             ser_loc(jb, expr->line, expr->column);
             json_obj_field(jb, &first, "lo");
             ser_expr(jb, ctx, interp, expr->as.range.start);
-            json_obj_field(jb, &first, "hi");
+            json_obj_field(jb, &first, "start");
             ser_expr(jb, ctx, interp, expr->as.range.end);
             jb_append_char(jb, '}');
             return;
@@ -1815,8 +1815,8 @@ static Expr* deser_expr(JsonValue* obj, UnserCtx* ctx, Interpreter* interp, cons
     }
     if (strcmp(name, "Range") == 0) {
         Expr* lo = deser_expr(json_obj_get(obj, "lo"), ctx, interp, err);
-        Expr* hi = deser_expr(json_obj_get(obj, "hi"), ctx, interp, err);
-        return expr_range(lo, hi, line, col);
+        Expr* start = deser_expr(json_obj_get(obj, "start"), ctx, interp, err);
+        return expr_range(lo, start, line, col);
     }
     if (strcmp(name, "Star") == 0) {
         return expr_wildcard(line, col);
@@ -4345,36 +4345,84 @@ static Value builtin_import_path(Interpreter* interp, Value* args, int argc, Exp
 }
 static Value builtin_slice(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
     (void)arg_nodes; (void)env;
-    // SLICE can operate on STR or TNS for now. Syntax: SLICE(target, start, end)
+    // SLICE per spec: SLICE(INT|STR: a, INT: start, INT: end)
+    // INT -> bit-slice [start:end] (1-based, negatives from end)
+    // STR -> inclusive char-slice counting from the left (index 1 = first char)
+    if (args[0].type == VAL_INT) {
+        EXPECT_INT(args[1], "SLICE", interp, line, col);
+        EXPECT_INT(args[2], "SLICE", interp, line, col);
+
+        int64_t v = args[0].as.i;
+        uint64_t u = (v < 0) ? (uint64_t)(-v) : (uint64_t)v;
+
+        // compute bit length (ILEN semantics)
+        int64_t bitlen = 0;
+        if (u == 0) bitlen = 1;
+        else {
+            uint64_t tmp = u;
+            while (tmp > 0) { bitlen++; tmp >>= 1; }
+        }
+
+        int64_t start = args[1].as.i;
+        int64_t end = args[2].as.i;
+        if (start < 0) start = bitlen + start + 1;
+        if (end < 0) end = bitlen + end + 1;
+
+        if (start < 1) start = 1;
+        if (end < 1) end = 1;
+        if (start > bitlen) start = bitlen;
+        if (end > bitlen) end = bitlen;
+
+        // ensure start <= end for a non-empty inclusive slice
+        if (start > end) return value_int(0);
+
+        // convert positions (1-based from left/MSB) to bit indices (0-based from LSB)
+        int64_t hi_bit = bitlen - start; // index of high bit (from LSB)
+        int64_t lo_bit = bitlen - end; // index of low bit (from LSB)
+        int64_t nbits = hi_bit - lo_bit + 1;
+
+        uint64_t result = 0;
+        if (nbits > 0) {
+            // shift right by lo_bit then mask nbits
+            result = (u >> lo_bit) & ((nbits >= 64) ? UINT64_MAX : ((1ULL << nbits) - 1ULL));
+        }
+
+        return value_int((int64_t)result);
+    }
+
     if (args[0].type == VAL_STR) {
         EXPECT_INT(args[1], "SLICE", interp, line, col);
         EXPECT_INT(args[2], "SLICE", interp, line, col);
         const char* s = args[0].as.s;
         size_t len = strlen(s);
-        int64_t start = args[1].as.i;
-        int64_t end = args[2].as.i;
-        if (start < 0) start = (int64_t)len + start + 1;
-        if (end < 0) end = (int64_t)len + end + 1;
-        start--;
-        if (start < 0) start = 0;
-        if (end > (int64_t)len) end = (int64_t)len;
-        if (start >= end) return value_str("");
-        size_t result_len = (size_t)(end - start);
+          /* Treat string slice arguments as start,end (first -> start, second -> end).
+              This matches test usage where callers pass start then end positions. */
+          int64_t start = args[1].as.i;
+          int64_t end = args[2].as.i;
+          if (start < 0) start = (int64_t)len + start + 1;
+          if (end < 0) end = (int64_t)len + end + 1;
+
+          if (start < 1) start = 1;
+          if (end < 1) end = 1;
+          if (start > (int64_t)len) start = (int64_t)len;
+          if (end > (int64_t)len) end = (int64_t)len;
+
+          /* inclusive indices: start..end */
+          int64_t low_idx = start - 1;
+          int64_t high_idx = end - 1;
+          if (low_idx > high_idx) return value_str("");
+
+        size_t result_len = (size_t)(high_idx - low_idx + 1);
         char* result = malloc(result_len + 1);
-        memcpy(result, s + start, result_len);
+        if (!result) { RUNTIME_ERROR(interp, "Out of memory", line, col); }
+        memcpy(result, s + low_idx, result_len);
         result[result_len] = '\0';
         Value v = value_str(result);
         free(result);
         return v;
-    } else if (args[0].type == VAL_TNS) {
-        // slice along first axis using 1-based inclusive indices
-        EXPECT_INT(args[1], "SLICE", interp, line, col);
-        EXPECT_INT(args[2], "SLICE", interp, line, col);
-        int64_t starts[1] = { args[1].as.i };
-        int64_t ends[1] = { args[2].as.i };
-        return value_tns_slice(args[0], starts, ends, 1);
     }
-    RUNTIME_ERROR(interp, "SLICE expects STR or TNS", line, col);
+
+    RUNTIME_ERROR(interp, "SLICE expects INT or STR", line, col);
 }
 
 static Value builtin_replace(Interpreter* interp, Value* args, int argc, Expr** arg_nodes, Env* env, int line, int col) {
@@ -4719,10 +4767,10 @@ static Value builtin_writefile(Interpreter* interp, Value* args, int argc, Expr*
         }
         for (size_t i = 0; i < blen; i += 2) {
             char a = blob[i]; char b = blob[i+1];
-            int hi = (a >= '0' && a <= '9') ? a - '0' : (a >= 'a' && a <= 'f') ? a - 'a' + 10 : (a >= 'A' && a <= 'F') ? a - 'A' + 10 : -1;
+            int start = (a >= '0' && a <= '9') ? a - '0' : (a >= 'a' && a <= 'f') ? a - 'a' + 10 : (a >= 'A' && a <= 'F') ? a - 'A' + 10 : -1;
             int lo = (b >= '0' && b <= '9') ? b - '0' : (b >= 'a' && b <= 'f') ? b - 'a' + 10 : (b >= 'A' && b <= 'F') ? b - 'A' + 10 : -1;
-            if (hi < 0 || lo < 0) { fclose(f); RUNTIME_ERROR(interp, "WRITEFILE(hex) expects valid hex digits", line, col); }
-            unsigned char byte = (unsigned char)((hi << 4) | lo);
+            if (start < 0 || lo < 0) { fclose(f); RUNTIME_ERROR(interp, "WRITEFILE(hex) expects valid hex digits", line, col); }
+            unsigned char byte = (unsigned char)((start << 4) | lo);
             if (fwrite(&byte, 1, 1, f) != 1) { fclose(f); return value_int(0); }
         }
         fclose(f);

test2.pre

@@ -1,6 +1,4 @@
-! Stage 5 Test - Tests INT, FLT, STR, FUNC, TNS, MAP, THR
-
-PRINT("=== Stage 5 Tests ===")
+PRINT("=== Testing built-ins... ===\n")
 
 ! --- Literal formats ---
 PRINT("Testing literals...")
@@ -996,4 +994,4 @@ DEL(caught_su)
 
 PRINT("SER/UNSER: PASS\n")
 
-PRINT("=== All Stage 5 Tests PASSED ===")
+PRINT("=== Built-in tests passed. ===")