inscript-lang 2.0.0__tar.gz → 2.0.2__tar.gz

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.0.0
+Version: 2.0.2
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/analyzer.py

@@ -1772,6 +1772,12 @@ class Analyzer(Visitor):
         if s not in (T_INT, T_ANY) or e not in (T_INT, T_ANY):
             self._error(f"Range bounds must be int, got '{s}' and '{e}'",
                         node.line, node.col)
+        # v2.0.1: validate optional step expression
+        if node.step is not None:
+            st = self.visit(node.step)
+            if st not in (T_INT, T_ANY):
+                self._error(f"Range step must be int, got '{st}'",
+                            node.line, node.col)
         return InScriptType("Range", [T_INT])
 
     def visit_LambdaExpr(self, node: LambdaExpr) -> InScriptType:

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/ast_nodes.py

@@ -195,10 +195,11 @@ class LambdaExpr(Node):
 
 @dataclass
 class RangeExpr(Node):
-    """0..10 (exclusive)  |  0..=10 (inclusive)"""
+    """0..10 (exclusive)  |  0..=10 (inclusive)  |  0..10 step 2  (v2.0.1)"""
     start:     Node
     end:       Node
-    inclusive: bool = False
+    inclusive: bool  = False
+    step:      object = None   # None = auto (1, or -1 if start > end)
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -560,10 +561,11 @@ class PropertyDecl(Node):
 
 @dataclass
 class RangeExpr(Node):
-    """0..10 (exclusive)  |  0..=10 (inclusive)"""
+    """0..10 (exclusive)  |  0..=10 (inclusive)  |  0..10 step 2  (v2.0.1)"""
     start:     Node
     end:       Node
-    inclusive: bool = False
+    inclusive: bool   = False
+    step:      object = None   # None = auto (1 ascending, -1 descending)
 
 @dataclass
 class LambdaExpr(Node):

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "2.0.0"
+VERSION = "2.0.2"
 
 MANIFEST_FILENAME = "inscript.toml"
 LOCK_FILENAME     = "inscript.lock"

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 2.0.0
+Version: 2.0.2
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/interpreter.py

@@ -2470,7 +2470,13 @@ class Interpreter(Visitor):
     def visit_RangeExpr(self, node: RangeExpr) -> Any:
         start = self.visit(node.start)
         end   = self.visit(node.end)
-        return InScriptRange(start, end, inclusive=node.inclusive)
+        # v2.0.1: optional `step` expression
+        if node.step is not None:
+            step = self.visit(node.step)
+        else:
+            # Auto-descend: if start > end, default step to -1
+            step = -1 if int(start) > int(end) else 1
+        return InScriptRange(start, end, step=step, inclusive=node.inclusive)
 
     def visit_AwaitExpr(self, node: AwaitExpr) -> Any:
         """
@@ -2510,41 +2516,76 @@ class Interpreter(Visitor):
         cond = self.visit(node.condition)
         return self.visit(node.then_expr) if cond else self.visit(node.else_expr)
 
+    @staticmethod
+    def _fstring_segments(template: str):
+        """v2.0.2: brace-depth-aware f-string segment splitter.
+        Returns list of (kind, text) where kind is "lit" or "expr".
+        Handles nested braces (match, for, object literals) correctly.
+        {{ and }} in source are stored as sentinel \x00{ and }\x00.
+        """
+        segments = []
+        i = 0
+        n = len(template)
+        lit_buf = []
+        while i < n:
+            ch = template[i]
+            # Sentinel escaped braces: \x00{ = literal {, }\x00 = literal }
+            if ch == "\x00" and i + 1 < n and template[i + 1] == "{":
+                lit_buf.append("{"); i += 2
+            elif ch == "}" and i + 1 < n and template[i + 1] == "\x00":
+                lit_buf.append("}"); i += 2
+            elif ch == "{":
+                # Start of an expression — find matching } with depth tracking
+                if lit_buf:
+                    segments.append(("lit", "".join(lit_buf))); lit_buf = []
+                depth = 1; j = i + 1; in_str = None
+                while j < n and depth > 0:
+                    c2 = template[j]
+                    if in_str:
+                        if c2 == "\\" and j + 1 < n: j += 2; continue
+                        if c2 == in_str: in_str = None
+                    elif c2 in ('"', "\'"):
+                        in_str = c2
+                    elif c2 == "{":
+                        depth += 1
+                    elif c2 == "}":
+                        depth -= 1
+                        if depth == 0: break
+                    j += 1
+                segments.append(("expr", template[i + 1:j]))
+                i = j + 1
+            else:
+                lit_buf.append(ch); i += 1
+        if lit_buf:
+            segments.append(("lit", "".join(lit_buf)))
+        return segments
+
     def visit_FStringExpr(self, node: FStringExpr) -> Any:
         """f"Hello {name}, score={score:.1f}" — evaluate {expr} segments at runtime.
+        v2.0.2: brace-depth-aware splitter handles match/for/object literals inside {}.
         Supports Python-style format specs: {x:.2f}, {n:06d}, {s:>20} etc.
-        {{ and }} in source produce literal braces (stored as \x00{ and }\x00 sentinels)."""
-        import re
+        {{ and }} in source produce literal braces."""
         result = []
-        template = node.template
-        pos = 0
-        for m in re.finditer(r'(?<!\x00)\{([^}\x00][^}]*)\}', template):
-            result.append(template[pos:m.start()])
-            inner = m.group(1).strip()
-
-            # Split off format spec: {expr:spec}
-            # Key: only split on ':' that is NOT inside brackets AND NOT after '?'
-            # (ternary x ? a : b uses ':' but it's not a format spec)
+        for kind, text in self._fstring_segments(node.template):
+            if kind == "lit":
+                result.append(text)
+                continue
+            inner = text.strip()
+            # Split off format spec {expr:spec}, respecting brackets and ternary
             fmt_spec = None
-            depth = 0
-            ternary_depth = 0
-            split_at = -1
+            depth = 0; ternary_depth = 0; split_at = -1
             for i, ch in enumerate(inner):
-                if ch in '([{': depth += 1
-                elif ch in ')]}': depth -= 1
-                elif ch == '?' and depth == 0: ternary_depth += 1
-                elif ch == ':' and depth == 0:
-                    if ternary_depth > 0:
-                        ternary_depth -= 1  # this ':' closes the ternary
-                    else:
-                        split_at = i
-                        break
+                if ch in "([{": depth += 1
+                elif ch in ")]}": depth -= 1
+                elif ch == "?" and depth == 0: ternary_depth += 1
+                elif ch == ":" and depth == 0:
+                    if ternary_depth > 0: ternary_depth -= 1
+                    else: split_at = i; break
             if split_at > 0:
-                expr_src = inner[:split_at].strip()
-                fmt_spec = inner[split_at+1:].strip()
+                expr_src  = inner[:split_at].strip()
+                fmt_spec  = inner[split_at + 1:].strip()
             else:
                 expr_src = inner
-
             try:
                 from parser import parse
                 prog = parse(expr_src)
@@ -2552,19 +2593,13 @@ class Interpreter(Visitor):
                 for stmt in prog.body:
                     val = self.visit(stmt)
                 if fmt_spec:
-                    # Apply Python format spec directly — supports .2f, 06d, >10s etc.
-                    try:
-                        result.append(format(val, fmt_spec))
-                    except Exception:
-                        result.append(_inscript_str(val))
+                    try:    result.append(format(val, fmt_spec))
+                    except: result.append(_inscript_str(val))
                 else:
                     result.append(_inscript_str(val))
             except Exception:
-                result.append(f"{{{inner}}}")
-            pos = m.end()
-        result.append(template[pos:])
-        final = "".join(result).replace("\x00{", "{").replace("}\x00", "}")
-        return final
+                result.append("{" + inner + "}")
+        return "".join(result)
 
     def visit_DestructureDecl(self, node: DestructureDecl) -> Any:
         """let [a, b, c] = arr  |  let {x, y} = point  |  let [[a,b],[c,d]] = nested"""

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/parser.py

@@ -1555,13 +1555,19 @@ class Parser:
         line, col = self._pos()
         left = self.parse_shift()
 
-        # Range: start..end  or  start..=end
+        # Range: start..end  or  start..=end  or  start..end step n  (v2.0.1)
         if self.check(TT.DOTDOT, TT.DOTDOT_EQ):
             inclusive = (self.current.type == TT.DOTDOT_EQ)
             self.advance()
             right = self.parse_shift()
+            # Optional `step` suffix: 0..20 step 2
+            step_expr = None
+            if (self.current and self.current.type == TT.IDENT
+                    and self.current.value == "step"):
+                self.advance()  # consume 'step'
+                step_expr = self.parse_shift()
             return RangeExpr(start=left, end=right, inclusive=inclusive,
-                             line=line, col=col)
+                             step=step_expr, line=line, col=col)
 
         # Membership: x in collection  /  x not in collection
         if self.check(TT.IN):

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "2.0.0"
+version = "2.0.2"
 description = "InScript — a game-focused scripting language with 59 game modules and a bytecode VM"
 readme = "README.md"
 license = { text = "MIT" }

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/repl.py

@@ -40,7 +40,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 HISTORY_FILE = Path.home() / ".inscript" / "history"
 HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-VERSION = "2.0.0"
+VERSION = "2.0.2"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):

{inscript_lang-2.0.0 → inscript_lang-2.0.2}/stdlib_values.py

@@ -281,16 +281,25 @@ class InScriptRange:
         self.inclusive = inclusive
 
     def __iter__(self):
-        stop = self.end + 1 if self.inclusive else self.end
+        # v2.0.1: support negative step (descending ranges)
+        if self.step > 0:
+            stop = self.end + 1 if self.inclusive else self.end
+        else:
+            stop = self.end - 1 if self.inclusive else self.end
         return iter(range(self.start, stop, self.step))
 
     def __len__(self):
-        stop = self.end + 1 if self.inclusive else self.end
-        return max(0, (stop - self.start + self.step - 1) // self.step)
+        if self.step > 0:
+            stop = self.end + 1 if self.inclusive else self.end
+            return max(0, (stop - self.start + self.step - 1) // self.step)
+        else:
+            stop = self.end - 1 if self.inclusive else self.end
+            return max(0, (self.start - stop + (-self.step) - 1) // (-self.step))
 
     def __repr__(self):
         op = "..=" if self.inclusive else ".."
-        return f"{self.start}{op}{self.end}"
+        s = f" step {self.step}" if self.step not in (1, -1) else ("" if self.step == 1 else " step -1")
+        return f"{self.start}{op}{self.end}{s}"
 
 
 class InScriptGenerator: