zexus 1.7.1 → 1.7.2

package/src/zexus/parser/strategy_structural.py

@@ -28,6 +28,8 @@ class StructuralAnalyzer:
         block_id = 0
         n = len(tokens)
 
+        debug_enabled = zexus_config.enable_debug_logs
+
         # helper sets for stopping heuristics (mirrors context parser)
         stop_types = {SEMICOLON, RBRACE}
         
@@ -37,11 +39,11 @@ class StructuralAnalyzer:
         # Statement starters (keywords that begin a new statement)
         # NOTE: SEND and RECEIVE removed - they can be used as function calls in expressions
         statement_starters = {
-              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, EXTERNAL,
+              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, FINALLY, EXTERNAL,
               SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
               EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, SEAL, PERSISTENT, AUDIT,
               RESTRICT, SANDBOX, TRAIL, GC, BUFFER, SIMD,
-              DEFER, PATTERN, ENUM, STREAM, WATCH,
+              DEFER, PATTERN, ENUM, STREAM, WATCH, MATCH,
               CAPABILITY, GRANT, REVOKE, VALIDATE, SANITIZE, IMMUTABLE,
               INTERFACE, TYPE_ALIAS, MODULE, PACKAGE, USING,
               CHANNEL, ATOMIC,
@@ -135,13 +137,44 @@ class StructuralAnalyzer:
                     declaration_type = tokens[i].type
                     export_tokens.append(tokens[i])
                     i += 1
-                    # Now collect the rest of the declaration (NAME = VALUE)
-                    while i < n and tokens[i].type not in stop_types:
-                        # Stop if we see another statement starter (but not CONST/LET since we just saw it)
-                        if tokens[i].type in statement_starters and tokens[i].type not in [CONST, LET]:
-                            break
-                        export_tokens.append(tokens[i])
+
+                    # Track nesting counts so that braces/parentheses inside the value don't prematurely terminate the statement
+                    paren_depth = 0
+                    brace_depth = 0
+                    bracket_depth = 0
+
+                    while i < n:
+                        current = tokens[i]
+
+                        # Update nesting counters before applying boundary heuristics
+                        if current.type == LPAREN:
+                            paren_depth += 1
+                        elif current.type == RPAREN:
+                            paren_depth = max(paren_depth - 1, 0)
+                        elif current.type == LBRACE:
+                            brace_depth += 1
+                        elif current.type == RBRACE:
+                            brace_depth = max(brace_depth - 1, 0)
+                        elif current.type == LBRACKET:
+                            bracket_depth += 1
+                        elif current.type == RBRACKET:
+                            bracket_depth = max(bracket_depth - 1, 0)
+
+                        export_tokens.append(current)
                         i += 1
+
+                        in_nested_structure = (paren_depth > 0 or brace_depth > 0 or bracket_depth > 0)
+
+                        # Stop if we reach a clear boundary at top level (first semicolon or closing brace outside of literal)
+                        if not in_nested_structure and current.type in stop_types:
+                            break
+
+                        # Stop if we see another statement starter at top level (but not CONST/LET since we just saw it)
+                        if not in_nested_structure and current.type in statement_starters and current.type not in [CONST, LET]:
+                            # Remove the boundary token so the next statement sees it
+                            export_tokens.pop()
+                            i -= 1
+                            break
                 elif i < n and tokens[i].type == CONTRACT:
                     # export contract Name { ... } - collect entire contract
                     export_tokens.append(tokens[i])
@@ -171,6 +204,30 @@ class StructuralAnalyzer:
                         elif tokens[i].type == RBRACE:
                             brace_count -= 1
                         i += 1
+                elif i < n and tokens[i].type == DATA:
+                    # export data Name { ... } - collect entire data declaration
+                    export_tokens.append(tokens[i])
+                    i += 1
+
+                    brace_count = 0
+
+                    # Collect modifiers, type params, and until first brace
+                    while i < n:
+                        export_tokens.append(tokens[i])
+                        if tokens[i].type == LBRACE:
+                            brace_count = 1
+                            i += 1
+                            break
+                        i += 1
+
+                    # Collect body until matching closing brace
+                    while i < n and brace_count > 0:
+                        export_tokens.append(tokens[i])
+                        if tokens[i].type == LBRACE:
+                            brace_count += 1
+                        elif tokens[i].type == RBRACE:
+                            brace_count -= 1
+                        i += 1
                 elif i < n and tokens[i].type == FUNCTION:
                     # export function name(...) { ... } - collect entire function
                     export_tokens.append(tokens[i])
@@ -451,8 +508,16 @@ class StructuralAnalyzer:
                     catch_tokens = [catch_token] + pre_brace_tokens + catch_block_tokens
                     final_idx = after_catch_idx
                 
+                # Check for finally block
+                finally_tokens = []
+                if final_idx < n and tokens[final_idx].type == FINALLY:
+                    finally_token = tokens[final_idx]
+                    finally_block_tokens, after_finally_idx = self._collect_brace_block(tokens, final_idx + 1)
+                    finally_tokens = [finally_token] + finally_block_tokens
+                    final_idx = after_finally_idx
+                
                 # Combine all tokens
-                full_tokens = [t] + try_block_tokens + catch_tokens
+                full_tokens = [t] + try_block_tokens + catch_tokens + finally_tokens
                 full_tokens = [tk for tk in full_tokens if not _is_empty_token(tk)]
                 
                 # Create the main try-catch block
@@ -744,7 +809,27 @@ class StructuralAnalyzer:
                             # Break if we've already completed the LET/CONST and this is an indexed assignment
                             if is_indexed_assignment and in_assignment and seen_assign:
                                 break
-                        # IDENT followed by LPAREN is a function call (already handled below, but listed for clarity)
+                        
+                        # Pattern 4: IDENT followed by LPAREN is a function call expression
+                        # This is a NEW statement if we're in LET/CONST and have seen the main assign
+                        # and the function call is on a new line (prevents absorbing next statement)
+                        elif tj.type == IDENT and j + 1 < n and tokens[j + 1].type == LPAREN:
+                            if stmt_tokens and in_assignment and seen_assign:
+                                last_token = stmt_tokens[-1]
+                                last_line = getattr(last_token, 'line', None)
+                                current_line = getattr(tj, 'line', None)
+                                if last_line is not None and current_line is not None and current_line > last_line:
+                                    # Safety: don't break if previous token is an infix operator
+                                    # (e.g., let x = foo() +\n bar() across two lines)
+                                    _infix_ops = {PLUS, MINUS, STAR, SLASH, MOD, AND, OR,
+                                                  EQ, NOT_EQ, LT, GT, LTE, GTE, POWER,
+                                                  DOT, COMMA, ASSIGN, QUESTION, NULLISH,
+                                                  PLUS_ASSIGN, MINUS_ASSIGN, STAR_ASSIGN,
+                                                  SLASH_ASSIGN, MOD_ASSIGN, POWER_ASSIGN,
+                                                  APPEND, IMPORT_OP}
+                                    if last_token.type not in _infix_ops:
+                                        # New line after completed assignment - this is a new statement
+                                        break
                     
                     # Detect colon-based block (tolerable syntax for action/function/if/while etc.)
                     if tj.type == COLON and nesting == 0 and t.type in {ACTION, FUNCTION, IF, WHILE, FOR}:
@@ -760,8 +845,10 @@ class StructuralAnalyzer:
                     # Track nesting level BEFORE dedent check (so we don't break inside {...} or [...] or (...))
                     if tj.type in {LPAREN, LBRACE, LBRACKET}:
                         # Only mark as brace block if NOT already in colon block (to distinguish code blocks from data literals)
+                        # ALSO: Don't mark as brace block for destructuring patterns in LET/CONST before '='
                         if tj.type == LBRACE and not found_colon_block:
-                            found_brace_block = True
+                            if not (in_assignment and not seen_assign):
+                                found_brace_block = True
                         nesting += 1
                     elif tj.type in {RPAREN, RBRACE, RBRACKET}:
                         nesting -= 1
@@ -792,10 +879,16 @@ class StructuralAnalyzer:
                                 # We're still parsing the condition - don't break yet
                                 pass
                             else:
-                                # For LET/CONST, allow FUNCTION, SANDBOX, SANITIZE as RHS (expressions)
+                                # For LET/CONST, allow FUNCTION, SANDBOX, SANITIZE, MATCH as RHS (expressions)
                                 # Also allow DEBUG when followed by ( for debug(x) function calls in assignments
                                 # Also allow IF when followed by THEN (if-then-else expression)
-                                allow_in_assignment = tj.type in {FUNCTION, SANDBOX, SANITIZE}
+                                allow_in_assignment = tj.type in {FUNCTION, SANDBOX, SANITIZE, MATCH}
+                                if in_assignment and allow_in_assignment and stmt_tokens:
+                                    prev_token = stmt_tokens[-1]
+                                    prev_line = getattr(prev_token, 'line', None)
+                                    current_line = getattr(tj, 'line', None)
+                                    if prev_line is not None and current_line is not None and current_line > prev_line:
+                                        allow_in_assignment = False
                                 allow_debug_call = tj.type == DEBUG and j + 1 < n and tokens[j + 1].type == LPAREN
                                 allow_if_then_else = False
                                 if tj.type == IF:
@@ -965,10 +1058,12 @@ class StructuralAnalyzer:
                                     # CRITICAL FIX: Don't break if the previous token was ASSIGN
                                     # This means the IDENT is the RHS value, not a new statement
                                     prev_tok = run_tokens[-1] if run_tokens else None
-                                    print(f"      prev_tok={prev_tok.literal if prev_tok else None}, type={prev_tok.type if prev_tok else None}")
+                                    if debug_enabled:
+                                        print(f"      prev_tok={prev_tok.literal if prev_tok else None}, type={prev_tok.type if prev_tok else None}")
                                     if prev_tok and prev_tok.type == ASSIGN:
                                         # This IDENT is the RHS of the assignment, not a new statement
-                                        print(f"      -> Continuing (RHS of assignment)")
+                                        if debug_enabled:
+                                            print("      -> Continuing (RHS of assignment)")
                                         pass  # Don't break, continue collecting
                                     else:
                                         # This is likely a new statement on a new line
@@ -1110,7 +1205,7 @@ class StructuralAnalyzer:
         stop_types = {SEMICOLON, RBRACE}
         # NOTE: SEND and RECEIVE removed - they can be used as function calls in expressions
         statement_starters = {
-              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, EXTERNAL, 
+              LET, CONST, DATA, PRINT, FOR, IF, WHILE, RETURN, CONTINUE, BREAK, THROW, ACTION, FUNCTION, TRY, FINALLY, EXTERNAL, 
               SCREEN, COLOR, CANVAS, GRAPHICS, ANIMATION, CLOCK,
               EXPORT, USE, DEBUG, ENTITY, CONTRACT, VERIFY, PROTECT, SEAL, AUDIT,
               RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE, BUFFER, SIMD,
@@ -1169,7 +1264,8 @@ class StructuralAnalyzer:
 
             # Export statement detection - collect export keyword + following declaration
             if t.type == EXPORT:
-                print(f"[DEBUG STRUCT] Found EXPORT token at index {i}")
+                if debug_enabled:
+                    print(f"[DEBUG STRUCT] Found EXPORT token at index {i}")
                 if cur:
                     results.append(cur)
                     cur = []
@@ -1179,9 +1275,11 @@ class StructuralAnalyzer:
                 i += 1
 
                 # Check if followed by const/let declaration (export const X = value)
-                print(f"[DEBUG STRUCT] Next token at {i}: {tokens[i].type if i < n else 'EOF'}, CONST={CONST}, LET={LET}")
+                if debug_enabled:
+                    print(f"[DEBUG STRUCT] Next token at {i}: {tokens[i].type if i < n else 'EOF'}, CONST={CONST}, LET={LET}")
                 if i < n and tokens[i].type in [CONST, LET]:
-                    print(f"[DEBUG STRUCT] Export followed by CONST/LET, collecting declaration")
+                    if debug_enabled:
+                        print(f"[DEBUG STRUCT] Export followed by CONST/LET, collecting declaration")
                     # Collect the entire declaration
                     while i < n and tokens[i].type not in stop_types:
                         export_tokens.append(tokens[i])

package/src/zexus/persistence.py

@@ -315,6 +315,19 @@ class PersistentStorage:
             cursor = self.conn.cursor()
             cursor.execute('DELETE FROM variables')
             self.conn.commit()
+
+    def _key_to_str(self, key):
+        """Convert a Zexus object key to a Python string for JSON serialization."""
+        if isinstance(key, String):
+            return key.value
+        if isinstance(key, Integer):
+            return str(key.value)
+        if isinstance(key, Float):
+            return str(key.value)
+        if isinstance(key, BooleanObj):
+            return str(key.value)
+        # Fallback for other types
+        return str(key)
     
     def _serialize(self, obj: Object) -> Dict[str, str]:
         """Serialize Zexus object to JSON"""
@@ -330,7 +343,8 @@ class PersistentStorage:
             serialized = [self._serialize(e) for e in obj.elements]
             return {'type': 'list', 'value': json.dumps(serialized)}
         elif isinstance(obj, Map):
-            serialized = {k: self._serialize(v) for k, v in obj.pairs.items()}
+            # Convert Zexus String keys to Python strings for JSON compatibility
+            serialized = {self._key_to_str(k): self._serialize(v) for k, v in obj.pairs.items()}
             return {'type': 'map', 'value': json.dumps(serialized)}
         elif obj is Null or obj is NULL:
             return {'type': 'null', 'value': json.dumps(None)}

package/src/zexus/renderer/__init__.py

@@ -43,4 +43,19 @@ __all__ = [
     "register_graphics",
     "render_screen",
     "set_theme",
+    # GUI backends
+    "TkBackend",
+    "WebBackend",
+    "create_tk_backend",
+    "create_web_backend",
 ]
+
+# Lazy imports for GUI backends (tkinter may not be installed)
+def __getattr__(name: str):
+    if name in ("TkBackend", "create_tk_backend"):
+        from .tk_backend import TkBackend, create_tk_backend
+        return TkBackend if name == "TkBackend" else create_tk_backend
+    if name in ("WebBackend", "create_web_backend"):
+        from .web_backend import WebBackend, create_web_backend
+        return WebBackend if name == "WebBackend" else create_web_backend
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

package/src/zexus/renderer/tk_backend.py

@@ -0,0 +1,208 @@
+"""
+Tk GUI Backend for the Zexus Renderer.
+
+Provides a real windowed GUI using Python's built-in ``tkinter``.
+The backend translates the existing ``Screen`` / ``Canvas`` / ``Component``
+model into Tk widgets.
+
+Usage from Zexus::
+
+    @zexus gui_backend = "tk"
+
+    screen main {
+        title: "My App"
+        width: 400
+        height: 300
+    }
+
+    component greeting label {
+        text: "Hello from Zexus!"
+        x: 50
+        y: 30
+    }
+
+    add greeting to main
+    show main
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+try:
+    import tkinter as tk
+    from tkinter import font as tkfont
+    TK_AVAILABLE = True
+except ImportError:
+    TK_AVAILABLE = False
+
+from .layout import Screen, ScreenComponent, ScreenRegistry, Button, Label, TextBox
+from .canvas import Canvas, CanvasRegistry
+from .color_system import RGBColor
+
+
+def _rgb_hex(color: Optional[RGBColor]) -> str:
+    """Convert ``RGBColor`` to Tk hex string."""
+    if color is None:
+        return "#000000"
+    return f"#{color.r:02x}{color.g:02x}{color.b:02x}"
+
+
+class TkBackend:
+    """Windowed GUI backend backed by tkinter.
+
+    The Tk event loop runs on a **dedicated thread** so the Zexus
+    evaluator thread isn't blocked.
+    """
+
+    def __init__(self, screen_registry: Optional[ScreenRegistry] = None,
+                 canvas_registry: Optional[CanvasRegistry] = None) -> None:
+        if not TK_AVAILABLE:
+            raise RuntimeError(
+                "tkinter is not available. On Ubuntu: sudo apt install python3-tk"
+            )
+        self.screen_registry = screen_registry or ScreenRegistry()
+        self.canvas_registry = canvas_registry or CanvasRegistry()
+        self._root: Optional[tk.Tk] = None
+        self._windows: Dict[str, tk.Toplevel] = {}
+        self._tk_canvases: Dict[str, tk.Canvas] = {}
+        self._event_handlers: Dict[str, Callable] = {}
+        self._thread: Optional[threading.Thread] = None
+        self._ready = threading.Event()
+
+    # -- Lifecycle ---------------------------------------------------------
+
+    def start(self) -> None:
+        """Launch the Tk main loop on a background thread."""
+        if self._thread and self._thread.is_alive():
+            return
+        self._thread = threading.Thread(target=self._run_mainloop, daemon=True)
+        self._thread.start()
+        self._ready.wait(timeout=5)
+
+    def stop(self) -> None:
+        """Destroy all windows and shut down the Tk loop."""
+        if self._root:
+            self._root.after(0, self._root.destroy)
+
+    def _run_mainloop(self) -> None:
+        self._root = tk.Tk()
+        self._root.withdraw()  # hide root window
+        self._ready.set()
+        self._root.mainloop()
+
+    # -- Screen rendering --------------------------------------------------
+
+    def show_screen(self, name: str) -> None:
+        """Render a registered ``Screen`` as a Tk window."""
+        screen = self.screen_registry.get_screen(name)
+        width = int(screen.get("width", 400))
+        height = int(screen.get("height", 300))
+        title = str(screen.get("title", name))
+        bg = str(screen.get("background", "#ffffff"))
+
+        def _create():
+            win = tk.Toplevel(self._root)
+            win.title(title)
+            win.geometry(f"{width}x{height}")
+            win.configure(bg=bg)
+            self._windows[name] = win
+
+            for child in screen.children:
+                self._render_component(win, child)
+
+        self._root.after(0, _create)
+
+    def close_screen(self, name: str) -> None:
+        win = self._windows.pop(name, None)
+        if win:
+            self._root.after(0, win.destroy)
+
+    # -- Component rendering -----------------------------------------------
+
+    def _render_component(self, parent: tk.Toplevel, comp: ScreenComponent) -> None:
+        x = int(comp.get("x", 10))
+        y = int(comp.get("y", 10))
+        fg = str(comp.get("color", "black"))
+        text = str(comp.get("text", comp.name))
+
+        if isinstance(comp, Button):
+            handler = self._event_handlers.get(f"{comp.name}:click")
+            btn = tk.Button(parent, text=text, fg=fg,
+                            command=handler if handler else lambda: None)
+            btn.place(x=x, y=y)
+
+        elif isinstance(comp, TextBox):
+            w = int(comp.get("width", 20))
+            entry = tk.Entry(parent, width=w, fg=fg)
+            entry.insert(0, text)
+            entry.place(x=x, y=y)
+
+        elif isinstance(comp, Label):
+            size = int(comp.get("fontSize", 12))
+            lbl = tk.Label(parent, text=text, fg=fg,
+                           font=("TkDefaultFont", size))
+            lbl.place(x=x, y=y)
+
+        else:
+            # Generic component → label
+            lbl = tk.Label(parent, text=text)
+            lbl.place(x=x, y=y)
+
+    # -- Canvas rendering --------------------------------------------------
+
+    def show_canvas(self, canvas_id: str) -> None:
+        """Render a ``Canvas`` in a new Tk window."""
+        canvas = self.canvas_registry.get(canvas_id)
+
+        def _create():
+            win = tk.Toplevel(self._root)
+            win.title(f"Canvas: {canvas_id}")
+            tk_c = tk.Canvas(win, width=canvas.width * 4,
+                             height=canvas.height * 4, bg="white")
+            tk_c.pack()
+            self._tk_canvases[canvas_id] = tk_c
+            self._draw_canvas(tk_c, canvas)
+
+        self._root.after(0, _create)
+
+    def _draw_canvas(self, tk_c: tk.Canvas, canvas: Canvas) -> None:
+        scale = 4
+        for op_type, args in canvas.operations:
+            if op_type == "line":
+                x1, y1, x2, y2 = args
+                tk_c.create_line(
+                    x1 * scale, y1 * scale,
+                    x2 * scale, y2 * scale,
+                    fill="black", width=2,
+                )
+            elif op_type == "text":
+                x, y, text = args
+                tk_c.create_text(x * scale, y * scale, text=text, anchor="nw")
+
+    # -- Event binding -----------------------------------------------------
+
+    def on(self, component_name: str, event: str, handler: Callable) -> None:
+        """Register an event handler for a component.
+
+        Example: ``backend.on("my_button", "click", my_handler)``
+        """
+        self._event_handlers[f"{component_name}:{event}"] = handler
+
+    # -- Utility -----------------------------------------------------------
+
+    def wait(self) -> None:
+        """Block until the Tk loop terminates (all windows closed)."""
+        if self._thread:
+            self._thread.join()
+
+
+# ---------------------------------------------------------------------------
+# Public factory
+# ---------------------------------------------------------------------------
+
+def create_tk_backend(**kwargs) -> TkBackend:
+    backend = TkBackend(**kwargs)
+    backend.start()
+    return backend