shell-lite 0.5.3__tar.gz → 0.5.3.2__tar.gz

{shell_lite-0.5.3/shell_lite.egg-info → shell_lite-0.5.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shell-lite
-Version: 0.5.3
+Version: 0.5.3.2
 Summary: A lightweight, English-like scripting language.
 Home-page: https://github.com/Shrey-N/ShellDesk
 Author: Shrey Naithani

{shell_lite-0.5.3 → shell_lite-0.5.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "shell-lite"
-version = "0.5.3"
+version = "0.5.3.2"
 description = "A lightweight, English-like scripting language."
 readme = "README.md"
 requires-python = ">=3.8"

{shell_lite-0.5.3 → shell_lite-0.5.3.2}/shell_lite/interpreter.py

@@ -240,8 +240,10 @@ class Interpreter:
         for k, v in self.builtins.items():
             self.global_env.set(k, v)
     def _make_tag_fn(self, tag_name):
-        def tag_fn(*args):
+        def tag_fn(*args, **kwargs):
             attrs = {}
+            # Add kwargs directly as attributes
+            attrs.update(kwargs)
             content = []
             for arg in args:
                 if isinstance(arg, dict):
@@ -1502,7 +1504,7 @@ class Interpreter:
                             self.wfile.write(str(e).encode())
                     except: pass
         server = ReusableHTTPServer(('0.0.0.0', port_val), ShellLiteHandler)
-        print(f"\n  ShellLite Server v0.5.3 is running!")
+        print(f"\n  ShellLite Server v0.5.3.2 is running!")
         print(f"  \u001b[1;36m➜\u001b[0m  Local:   \u001b[1;4;36mhttp://localhost:{port_val}/\u001b[0m\n")
         try: server.serve_forever()
         except KeyboardInterrupt: 

{shell_lite-0.5.3 → shell_lite-0.5.3.2}/shell_lite/main.py

@@ -17,7 +17,6 @@ def execute_source(source: str, interpreter: Interpreter):
         lexer = Lexer(source)
         tokens = lexer.tokenize()
         if os.environ.get('USE_LEGACY_PARSER') == '1':
-            from .parser import Parser
             parser = Parser(tokens)
         else:
             from .parser_gbp import GeometricBindingParser
@@ -151,7 +150,7 @@ def install_globally():
             return
         ps_cmd = f'$oldPath = [Environment]::GetEnvironmentVariable("Path", "User"); if ($oldPath -notlike "*ShellLite*") {{ [Environment]::SetEnvironmentVariable("Path", "$oldPath;{install_dir}", "User") }}'
         subprocess.run(["powershell", "-Command", ps_cmd], capture_output=True)
-        print(f"\n[SUCCESS] ShellLite (v0.5.3) is installed!")
+        print(f"\n[SUCCESS] ShellLite (v0.5.3.2) is installed!")
         print(f"Location: {install_dir}")
         print("\nIMPORTANT STEP REQUIRED:")
         print("1. Close ALL open terminal windows (CMD, PowerShell, VS Code).")
@@ -444,6 +443,12 @@ def main():
                  print("Usage: shl llvm <filename>")
         elif cmd == "help" or cmd == "--help" or cmd == "-h":
             show_help()
+        elif cmd == "--version" or cmd == "-v":
+            try:
+                from importlib.metadata import version
+                print(f"ShellLite v{version('shell-lite')}")
+            except Exception:
+                print("ShellLite v0.5.3.1")
         elif cmd == "get":
             if len(sys.argv) > 2:
                 package_name = sys.argv[2]

{shell_lite-0.5.3 → shell_lite-0.5.3.2}/shell_lite/parser_gbp.py

@@ -43,20 +43,24 @@ class GeometricBindingParser:
         node_stack: List[GeoNode] = [] # The active parents
         current_tokens_accumulator = []
         current_node: Optional[GeoNode] = None
+        last_line_node: Optional[GeoNode] = None  # Track the last completed line's node
         block_stack: List[GeoNode] = [] 
         for token in self.tokens:
             if token.type == 'EOF':
                 break
             if token.type == 'INDENT':
-                if current_node:
-                     block_stack.append(current_node)
-                     current_node = None # We are stepping "inside", so no current line active node yet
+                # Use last_line_node as parent if current_node is None (NEWLINE came before INDENT)
+                parent_to_push = current_node if current_node else last_line_node
+                if parent_to_push:
+                     block_stack.append(parent_to_push)
+                current_node = None
                 continue
             if token.type == 'DEDENT':
                  if block_stack:
                      block_stack.pop()
                  continue
             if token.type == 'NEWLINE':
+                last_line_node = current_node  # Save before resetting
                 current_node = None
                 continue
             if current_node is None:
@@ -83,7 +87,17 @@ class GeometricBindingParser:
             return self.bind_while(node)
         elif head_type == 'FOR' or head_type == 'LOOP':
             return self.bind_for(node)
-        elif head_type == 'FUNCTION' or head_type == 'TO' or (head_type == 'DEFINE' and self.peek_type(node, 1) == 'FUNCTION'):
+        elif head_type == 'USE':
+            return self.bind_use(node)
+        elif head_type == 'SERVE':
+            return self.bind_serve(node)
+        elif head_type == 'DEFINE':
+            return self.bind_define(node)
+        elif head_type == 'WHEN':
+            return self.bind_when(node)
+        elif head_type == 'ON':
+            return self.bind_on(node)
+        elif head_type == 'FUNCTION' or head_type == 'TO':
              return self.bind_func(node)
         elif head_type == 'PRINT' or head_type == 'SAY':
             return self.bind_print(node)
@@ -96,11 +110,13 @@ class GeometricBindingParser:
         elif head_type == 'LISTEN':
             return self.bind_listen(node)
         elif head_type == 'ID':
-            if any(t.type == 'ASSIGN' for t in node.tokens):
+            # Assignment: ID ASSIGN ... (second token must be ASSIGN)
+            # Function call with kwargs: ID ID ASSIGN ... (ASSIGN comes later)
+            if len(node.tokens) >= 2 and node.tokens[1].type == 'ASSIGN':
                 return self.bind_assignment(node)
-            return self.bind_expression_stmt(node)
+            return self.bind_call_or_expr(node)
         else:
-            return self.bind_expression_stmt(node)
+            return self.bind_call_or_expr(node)
     def peek_type(self, node: GeoNode, offset: int) -> str:
         if offset < len(node.tokens):
             return node.tokens[offset].type
@@ -159,12 +175,119 @@ class GeometricBindingParser:
         if node.tokens[0].type == 'DEFINE': start = 2
         name = node.tokens[start].value
         args = []
+        # Look for 'using' keyword (which is tokenized as ID)
+        collecting_args = False
         for t in node.tokens[start+1:]:
-             if t.type == 'ID':
-                 args.append((t.value, None, None))
-             elif t.type == 'COLON': break # End of signature
+            if t.type == 'USING':
+                collecting_args = True
+                continue
+            if t.type == 'ID' and collecting_args:
+                args.append((t.value, None, None))
+            elif t.type == 'COLON': break
+            elif t.type == 'COMMA': continue
+        body = [self.bind_node(child) for child in node.children]
+        return FunctionDef(name, args, body)
+    def bind_use(self, node: GeoNode) -> Import:
+        # 'use "filename.shl"'
+        for t in node.tokens:
+            if t.type == 'STRING':
+                return Import(t.value)
+        return Import(node.tokens[1].value if len(node.tokens) > 1 else '')
+    def bind_serve(self, node: GeoNode) -> ServeStatic:
+        # 'serve files from "public" at "/static"'
+        folder = String('public')
+        url = String('/static')
+        tokens = node.tokens
+        for i, t in enumerate(tokens):
+            if t.type == 'FROM' and i+1 < len(tokens):
+                folder = self.parse_expr_iterative([tokens[i+1]])
+            if t.type == 'AT' and i+1 < len(tokens):
+                url = self.parse_expr_iterative([tokens[i+1]])
+        return ServeStatic(folder, url)
+    def bind_define(self, node: GeoNode) -> FunctionDef:
+        # 'define page Name using arg1, arg2'
+        tokens = node.tokens
+        name = ''
+        args = []
+        i = 1
+        # Skip 'page' or 'component' if present
+        if i < len(tokens) and tokens[i].type == 'PAGE':
+            i += 1
+        if i < len(tokens) and tokens[i].type == 'ID':
+            name = tokens[i].value
+            i += 1
+        # Parse 'using' args
+        if i < len(tokens) and tokens[i].type == 'USING':
+            i += 1
+            while i < len(tokens):
+                if tokens[i].type == 'ID':
+                    args.append((tokens[i].value, None, None))
+                elif tokens[i].type == 'COMMA':
+                    pass
+                else:
+                    break
+                i += 1
         body = [self.bind_node(child) for child in node.children]
         return FunctionDef(name, args, body)
+    def bind_when(self, node: GeoNode) -> OnRequest:
+        # 'when someone visits "/path"'
+        tokens = node.tokens
+        path = String('/')
+        for i, t in enumerate(tokens):
+            if t.type == 'STRING':
+                path = String(t.value)
+                break
+        body = [self.bind_node(child) for child in node.children]
+        return OnRequest(path, body)
+    def bind_on(self, node: GeoNode) -> OnRequest:
+        # 'on request to "/path"'
+        tokens = node.tokens
+        path = String('/')
+        for t in tokens:
+            if t.type == 'STRING':
+                path = String(t.value)
+                break
+        body = [self.bind_node(child) for child in node.children]
+        return OnRequest(path, body)
+    def bind_call_or_expr(self, node: GeoNode) -> Any:
+        # Handle function calls like 'Head "title"' or 'Navbar'
+        tokens = node.tokens
+        if len(tokens) >= 1 and tokens[0].type == 'ID':
+            name = tokens[0].value
+            args = []
+            kwargs = []
+            # Parse remaining tokens as arguments, handling key=value for HTML attributes
+            i = 1
+            while i < len(tokens):
+                t = tokens[i]
+                # Check for key=value pattern (e.g. class="container", style="...", href="...")
+                # HTML attributes may be tokenized as various types: ID, STRUCTURE, HREF, REL, NAME, etc.
+                is_attr_key = t.type in ('ID', 'STRUCTURE', 'HREF', 'REL', 'NAME', 'STYLE', 'CONTENT', 'CHARSET', 'SRC', 'ALT', 'TYPE', 'VALUE', 'PLACEHOLDER', 'METHOD', 'ACTION')
+                is_kwarg = (is_attr_key and i + 2 < len(tokens) and tokens[i + 1].type == 'ASSIGN')
+                if is_kwarg:
+                    key = t.value
+                    val_token = tokens[i + 2]
+                    if val_token.type == 'STRING':
+                        kwargs.append((key, String(val_token.value)))
+                    elif val_token.type == 'NUMBER':
+                        kwargs.append((key, Number(int(val_token.value) if '.' not in val_token.value else float(val_token.value))))
+                    else:
+                        kwargs.append((key, VarAccess(val_token.value)))
+                    i += 3
+                    continue
+                elif t.type == 'STRING':
+                    args.append(String(t.value))
+                elif t.type == 'NUMBER':
+                    args.append(Number(int(t.value) if '.' not in t.value else float(t.value)))
+                elif t.type == 'ID':
+                    args.append(VarAccess(t.value))
+                i += 1
+            # Check for children (indented body)
+            body = None
+            if node.children:
+                body = [self.bind_node(child) for child in node.children]
+            return Call(name, args, kwargs=kwargs, body=body)
+        return self.parse_expr_iterative(tokens)
     def _extract_expr_tokens(self, tokens: List[Token], start: int = 0) -> List[Token]:
         end = len(tokens)
         if tokens[-1].type == 'COLON':

{shell_lite-0.5.3 → shell_lite-0.5.3.2/shell_lite.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shell-lite
-Version: 0.5.3
+Version: 0.5.3.2
 Summary: A lightweight, English-like scripting language.
 Home-page: https://github.com/Shrey-N/ShellDesk
 Author: Shrey Naithani

{shell_lite-0.5.3 → shell_lite-0.5.3.2}/shell_lite.egg-info/SOURCES.txt

@@ -19,17 +19,6 @@ shell_lite.egg-info/dependency_links.txt
 shell_lite.egg-info/entry_points.txt
 shell_lite.egg-info/requires.txt
 shell_lite.egg-info/top_level.txt
-shell_lite/llvm_backend/__init__.py
-shell_lite/llvm_backend/builder.py
-shell_lite/llvm_backend/codegen.py
-tests/__init__.py
-tests/benchmark_driver.py
-tests/compare_parsers.py
-tests/debug_jit.py
-tests/generate_actual_graph.py
-tests/generate_perf_graph.py
-tests/generate_runtime_graph.py
-tests/run_jit.py
 tests/test_gbp_standalone.py
 tests/test_interpreter.py
 tests/test_lexer.py

shell_lite-0.5.3/shell_lite/llvm_backend/builder.py

@@ -1,39 +0,0 @@
-import llvmlite.binding as llvm
-from .codegen import LLVMCompiler
-from ..lexer import Lexer
-from ..parser import Parser
-import os
-def build_llvm(filename: str):
-    print(f"Compiling {filename} with LLVM Backend...")
-    with open(filename, 'r', encoding='utf-8') as f:
-        source = f.read()
-    lexer = Lexer(source)
-    tokens = lexer.tokenize()
-    parser = Parser(tokens)
-    statements = parser.parse()
-    compiler = LLVMCompiler()
-    module = compiler.compile(statements)
-    llvm_ir = str(module)
-    print("\n--- Generated LLVM IR ---")
-    print(llvm_ir)
-    print("-------------------------\n")
-    ll_filename = os.path.splitext(filename)[0] + ".ll"
-    with open(ll_filename, 'w') as f:
-        f.write(llvm_ir)
-    print(f"[SUCCESS] Generated LLVM IR: {ll_filename}")
-    print("\nTo compile to executable, you can use Clang:")
-    print(f"  clang {ll_filename} -o {os.path.splitext(filename)[0]}.exe")
-    """
-    try:
-        print("Initializing LLVM...")
-        llvm.initialize()
-        llvm.initialize_native_target()
-        llvm.initialize_native_asmprinter()
-        print("LLVM Initialized.")
-        print("Creating Target...")
-        target = llvm.Target.from_default_triple()
-        print(f"Target Triple: {target}")
-        target_machine = target.create_target_machine()
-    except Exception as e:
-        print(f"Native binding skipped due to: {e}")
-    """

shell_lite-0.5.3/shell_lite/llvm_backend/codegen.py

@@ -1,311 +0,0 @@
-from llvmlite import ir
-from ..ast_nodes import *
-class LLVMCompiler:
-    def __init__(self):
-        self.module = ir.Module(name="shell_lite_module")
-        self.module.triple = "x86_64-pc-windows-msvc" # Assume Windows for now based on user OS
-        self.int32 = ir.IntType(32)
-        self.char_ptr = ir.IntType(8).as_pointer()
-        voidptr_ty = ir.IntType(8).as_pointer()
-        printf_ty = ir.FunctionType(self.int32, [voidptr_ty], var_arg=True)
-        self.printf = ir.Function(self.module, printf_ty, name="printf")
-        malloc_ty = ir.FunctionType(voidptr_ty, [self.int32])
-        self.malloc = ir.Function(self.module, malloc_ty, name="malloc")
-        free_ty = ir.FunctionType(ir.VoidType(), [voidptr_ty])
-        self.free = ir.Function(self.module, free_ty, name="free")
-        strlen_ty = ir.FunctionType(self.int32, [voidptr_ty])
-        self.strlen = ir.Function(self.module, strlen_ty, name="strlen")
-        strcpy_ty = ir.FunctionType(voidptr_ty, [voidptr_ty, voidptr_ty])
-        self.strcpy = ir.Function(self.module, strcpy_ty, name="strcpy")
-        strcat_ty = ir.FunctionType(voidptr_ty, [voidptr_ty, voidptr_ty])
-        self.strcat = ir.Function(self.module, strcat_ty, name="strcat")
-        fopen_ty = ir.FunctionType(voidptr_ty, [voidptr_ty, voidptr_ty])
-        self.fopen = ir.Function(self.module, fopen_ty, name="fopen")
-        fclose_ty = ir.FunctionType(self.int32, [voidptr_ty])
-        self.fclose = ir.Function(self.module, fclose_ty, name="fclose")
-        fwrite_ty = ir.FunctionType(self.int32, [voidptr_ty, self.int32, self.int32, voidptr_ty])
-        self.fwrite = ir.Function(self.module, fwrite_ty, name="fwrite")
-        fread_ty = ir.FunctionType(self.int32, [voidptr_ty, self.int32, self.int32, voidptr_ty])
-        self.fread = ir.Function(self.module, fread_ty, name="fread")
-        fgets_ty = ir.FunctionType(voidptr_ty, [voidptr_ty, self.int32, voidptr_ty])
-        self.fgets = ir.Function(self.module, fgets_ty, name="fgets")
-        fseek_ty = ir.FunctionType(self.int32, [voidptr_ty, self.int32, self.int32])
-        self.fseek = ir.Function(self.module, fseek_ty, name="fseek")
-        ftell_ty = ir.FunctionType(self.int32, [voidptr_ty])
-        self.ftell = ir.Function(self.module, ftell_ty, name="ftell")
-        rewind_ty = ir.FunctionType(ir.VoidType(), [voidptr_ty])
-        self.rewind = ir.Function(self.module, rewind_ty, name="rewind")
-        get_stdin_ty = ir.FunctionType(voidptr_ty, [self.int32])
-        self.get_stdin = ir.Function(self.module, get_stdin_ty, name="__acrt_iob_func")
-        system_ty = ir.FunctionType(self.int32, [voidptr_ty])
-        self.system = ir.Function(self.module, system_ty, name="system")
-        func_type = ir.FunctionType(self.int32, [], var_arg=False)
-        self.main_func = ir.Function(self.module, func_type, name="main")
-        block = self.main_func.append_basic_block(name="entry")
-        self.builder = ir.IRBuilder(block)
-        self.scopes = [{}] 
-        self.loop_stack = []
-        self.str_constants = {}
-    def _get_scope(self):
-        return self.scopes[-1]
-    def _alloca(self, name, typ=None):
-        if typ is None: typ = self.int32
-        with self.builder.goto_entry_block():
-             ptr = self.builder.alloca(typ, size=None, name=name)
-        return ptr
-    def compile(self, statements):
-        for stmt in statements:
-            self.visit(stmt)
-        self.builder.ret(ir.Constant(self.int32, 0))
-        return self.module
-    def visit(self, node):
-        method_name = f'visit_{type(node).__name__}'
-        visitor = getattr(self, method_name, self.generic_visit)
-        return visitor(node)
-    def generic_visit(self, node):
-        print(f"Warning: LLVM Backend does not support {type(node).__name__} yet.")
-        return None
-    def visit_Number(self, node: Number):
-        return ir.Constant(self.int32, int(node.value))
-    def visit_String(self, node: String):
-        return self._get_string_constant(node.value)
-    def visit_BinOp(self, node: BinOp):
-        left = self.visit(node.left)
-        right = self.visit(node.right)
-        op = node.op
-        if op == '+':
-            is_str_op = False
-            if left.type == self.char_ptr or right.type == self.char_ptr:
-                is_str_op = True
-            if is_str_op:
-                if left.type == self.int32:
-                    left = self.builder.inttoptr(left, self.char_ptr, name="cast_l")
-                if right.type == self.int32:
-                    right = self.builder.inttoptr(right, self.char_ptr, name="cast_r")
-            if is_str_op:
-                 len1 = self.builder.call(self.strlen, [left], name="len1")
-                 len2 = self.builder.call(self.strlen, [right], name="len2")
-                 total_len = self.builder.add(len1, len2, name="total_len")
-                 total_len_null = self.builder.add(total_len, ir.Constant(self.int32, 1), name="alloc_len")
-                 new_str = self.builder.call(self.malloc, [total_len_null], name="new_str")
-                 self.builder.call(self.strcpy, [new_str, left])
-                 self.builder.call(self.strcat, [new_str, right])
-                 return new_str
-            return self.builder.add(left, right, name="addtmp")
-        elif op == '-':
-            return self.builder.sub(left, right, name="subtmp")
-        elif op == '*':
-            return self.builder.mul(left, right, name="multmp")
-        elif op == '/':
-            return self.builder.sdiv(left, right, name="divtmp")
-        elif op == '==' or op == 'is':
-            return self.builder.icmp_signed('==', left, right, name="eqtmp")
-        elif op == '!=' or op == 'is not':
-            return self.builder.icmp_signed('!=', left, right, name="netmp")
-        elif op == '<':
-            return self.builder.icmp_signed('<', left, right, name="lttmp")
-        elif op == '<=':
-            return self.builder.icmp_signed('<=', left, right, name="letmp")
-        elif op == '>':
-            return self.builder.icmp_signed('>', left, right, name="gttmp")
-        elif op == '>=':
-            return self.builder.icmp_signed('>=', left, right, name="getmp")
-        else:
-            raise Exception(f"Unknown operator: {op}")
-    def visit_If(self, node: If):
-        cond_val = self.visit(node.condition)
-        if cond_val.type != ir.IntType(1):
-             cond_val = self.builder.icmp_signed('!=', cond_val, ir.Constant(self.int32, 0), name="ifcond")
-        then_bb = self.builder.append_basic_block(name="then")
-        else_bb = self.builder.append_basic_block(name="else")
-        merge_bb = self.builder.append_basic_block(name="ifcont")
-        self.builder.cbranch(cond_val, then_bb, else_bb)
-        self.builder.position_at_end(then_bb)
-        for stmt in node.body:
-            self.visit(stmt)
-        if not self.builder.block.is_terminated:
-            self.builder.branch(merge_bb)
-        self.builder.position_at_end(else_bb)
-        if node.else_body:
-            for stmt in node.else_body:
-                self.visit(stmt)
-        if not self.builder.block.is_terminated:
-            self.builder.branch(merge_bb)
-        self.builder.position_at_end(merge_bb)
-    def visit_While(self, node: While):
-        cond_bb = self.builder.append_basic_block(name="loop.cond")
-        body_bb = self.builder.append_basic_block(name="loop.body")
-        after_bb = self.builder.append_basic_block(name="loop.after")
-        self.loop_stack.append((cond_bb, after_bb))
-        self.builder.branch(cond_bb)
-        self.builder.position_at_end(cond_bb)
-        cond_val = self.visit(node.condition)
-        if cond_val.type != ir.IntType(1):
-             cond_val = self.builder.icmp_signed('!=', cond_val, ir.Constant(self.int32, 0), name="loopcond")
-        self.builder.cbranch(cond_val, body_bb, after_bb)
-        self.builder.position_at_end(body_bb)
-        for stmt in node.body:
-            self.visit(stmt)
-        self.builder.branch(cond_bb) # Loop back
-        self.builder.position_at_end(after_bb)
-        self.loop_stack.pop()
-    def visit_Repeat(self, node: Repeat):
-        count_val = self.visit(node.count)
-        import random
-        uid = random.randint(0, 10000)
-        i_ptr = self._alloca(f"_loop_i_{uid}")
-        self.builder.store(ir.Constant(self.int32, 0), i_ptr)
-        cond_bb = self.builder.append_basic_block(name="repeat.cond")
-        body_bb = self.builder.append_basic_block(name="repeat.body")
-        after_bb = self.builder.append_basic_block(name="repeat.after")
-        self.loop_stack.append((cond_bb, after_bb))
-        self.builder.branch(cond_bb)
-        self.builder.position_at_end(cond_bb)
-        curr_i = self.builder.load(i_ptr, name="i_load")
-        cmp = self.builder.icmp_signed('<', curr_i, count_val, name="loopcheck")
-        self.builder.cbranch(cmp, body_bb, after_bb)
-        self.builder.position_at_end(body_bb)
-        for stmt in node.body:
-            self.visit(stmt)
-        curr_i_Body = self.builder.load(i_ptr)
-        next_i = self.builder.add(curr_i_Body, ir.Constant(self.int32, 1), name="inc_i")
-        self.builder.store(next_i, i_ptr)
-        self.builder.branch(cond_bb)
-        self.builder.position_at_end(after_bb)
-        self.loop_stack.pop()
-    def visit_FunctionDef(self, node: FunctionDef):
-        arg_types = [self.int32] * len(node.args) 
-        arg_types = []
-        for arg in node.args:
-            name, _, hint = arg # arg is tuple
-            if True: # FORCE ALL ARGS TO STRINGS FOR SHELL LITE (Phase 7 Fix)
-                 arg_types.append(self.char_ptr)
-            else:
-                 arg_types.append(self.int32)
-        func_ty = ir.FunctionType(self.int32, arg_types) # Return int32 (or pointer casted)
-        func = ir.Function(self.module, func_ty, name=node.name)
-        old_builder = self.builder
-        block = func.append_basic_block(name="entry")
-        self.builder = ir.IRBuilder(block)
-        self.scopes.append({}) # New scope
-        for i, arg in enumerate(func.args):
-            arg_name = node.args[i][0]
-            arg.name = arg_name
-            ptr = self.builder.alloca(arg.type, name=arg_name)
-            self.builder.store(arg, ptr)
-            self.scopes[-1][arg_name] = ptr
-        for stmt in node.body:
-            self.visit(stmt)
-        if not self.builder.block.is_terminated:
-             self.builder.ret(ir.Constant(self.int32, 0))
-        self.scopes.pop()
-        self.builder = old_builder
-    def visit_Return(self, node: Return):
-        val = self.visit(node.value)
-        if val.type == self.char_ptr:
-             val = self.builder.ptrtoint(val, self.int32)
-        self.builder.ret(val)
-    def visit_Call(self, node: Call):
-        if node.name in self.module.globals:
-            func = self.module.globals[node.name]
-        elif node.name == 'read':
-             if len(node.args) > 0:
-                 return self.visit_FileRead(FileRead(node.args[0]))
-             else:
-                 return ir.Constant(self.int32, 0)
-        else:
-             print(f"Warning: Function {node.name} not found")
-             return ir.Constant(self.int32, 0)
-        args = [self.visit(a) for a in node.args]
-        return self.builder.call(func, args, name="calltmp")
-    def visit_Assign(self, node: Assign):
-        value = self.visit(node.value)
-        scope = self._get_scope()
-        if node.name not in scope:
-            ptr = self._alloca(node.name, typ=value.type)
-            scope[node.name] = ptr
-        else:
-            ptr = scope[node.name]
-        self.builder.store(value, ptr)
-        return value
-    def visit_Execute(self, node: Execute):
-        cmd = self.visit(node.code)
-        self.builder.call(self.system, [cmd])
-        return ir.Constant(self.int32, 0)
-    def visit_Stop(self, node: Stop):
-        if not self.loop_stack:
-            print("Error: stop used outside of loop")
-            return
-        after_bb = self.loop_stack[-1][1]
-        self.builder.branch(after_bb)
-        dead_bb = self.builder.append_basic_block(name="dead")
-        self.builder.position_at_end(dead_bb)
-    def visit_Skip(self, node: Skip):
-        if not self.loop_stack:
-            print("Error: skip used outside of loop")
-            return
-        cond_bb = self.loop_stack[-1][0]
-        self.builder.branch(cond_bb)
-        dead_bb = self.builder.append_basic_block(name="dead")
-        self.builder.position_at_end(dead_bb)
-    def _get_stdin_handle(self):
-        return self.builder.call(self.get_stdin, [ir.Constant(self.int32, 0)])
-    def visit_Input(self, node: Input):
-        buffer_len = ir.Constant(self.int32, 256)
-        buffer = self.builder.call(self.malloc, [buffer_len], name="input_buf")
-        stdin = self._get_stdin_handle()
-        self.builder.call(self.fgets, [buffer, buffer_len, stdin])
-        return buffer
-    def visit_FileWrite(self, node: FileWrite):
-        path = self.visit(node.path)
-        content = self.visit(node.content)
-        mode = self._get_string_constant("w")
-        fp = self.builder.call(self.fopen, [path, mode], name="fp")
-        length = self.builder.call(self.strlen, [content])
-        self.builder.call(self.fwrite, [content, ir.Constant(self.int32, 1), length, fp])
-        self.builder.call(self.fclose, [fp])
-        return ir.Constant(self.int32, 0)
-    def visit_FileRead(self, node: FileRead):
-        path = self.visit(node.path)
-        mode = self._get_string_constant("rb") # Binary to avoid text translation issues? Or "r"
-        fp = self.builder.call(self.fopen, [path, mode], name="fp")
-        self.builder.call(self.fseek, [fp, ir.Constant(self.int32, 0), ir.Constant(self.int32, 2)])
-        size = self.builder.call(self.ftell, [fp], name="fsize")
-        self.builder.call(self.rewind, [fp])
-        alloc_size = self.builder.add(size, ir.Constant(self.int32, 1))
-        buffer = self.builder.call(self.malloc, [alloc_size], name="fbuf")
-        self.builder.call(self.fread, [buffer, ir.Constant(self.int32, 1), size, fp])
-        null_term_ptr = self.builder.gep(buffer, [size])
-        self.builder.store(ir.Constant(ir.IntType(8), 0), null_term_ptr)
-        self.builder.call(self.fclose, [fp])
-        return buffer
-    def visit_VarAccess(self, node: VarAccess):
-        scope = self._get_scope()
-        if node.name in scope:
-            ptr = scope[node.name]
-            return self.builder.load(ptr, name=node.name)
-        else:
-            raise Exception(f"Variable '{node.name}' not defined")
-    def _get_string_constant(self, text):
-        text += '\0'
-        if text in self.str_constants:
-            return self.str_constants[text]
-        byte_arr = bytearray(text.encode("utf8"))
-        c_str_ty = ir.ArrayType(ir.IntType(8), len(byte_arr))
-        global_var = ir.GlobalVariable(self.module, c_str_ty, name=f".str_{len(self.str_constants)}")
-        global_var.linkage = 'internal'
-        global_var.global_constant = True
-        global_var.initializer = ir.Constant(c_str_ty, byte_arr)
-        ptr = self.builder.bitcast(global_var, self.char_ptr)
-        self.str_constants[text] = ptr
-        return ptr
-    def visit_Print(self, node: Print):
-        value = self.visit(node.expression)
-        if value.type == self.char_ptr:
-            fmt_str = self._get_string_constant("%s\n")
-            self.builder.call(self.printf, [fmt_str, value])
-        else:
-            if value.type != self.int32:
-                 pass
-            fmt_str = self._get_string_constant("%d\n")
-            self.builder.call(self.printf, [fmt_str, value])

shell_lite-0.5.3/tests/__init__.py

@@ -1 +0,0 @@
-

shell_lite-0.5.3/tests/benchmark_driver.py

@@ -1,43 +0,0 @@
-import os
-import time
-import subprocess
-import sys
-SHL_CMD = ["python", "shell_lite/main.py"]
-def run_benchmark():
-    print("Generating LLVM IR...")
-    subprocess.run(SHL_CMD + ["llvm", "tests/runtime_benchmark.shl"], check=True)
-    print("Compiling with Clang...")
-    subprocess.run(["clang", "tests/runtime_benchmark.ll", "-o", "tests/runtime_benchmark.exe", "-O3"], check=True)
-    print("\n[Running Native Executable...]")
-    start = time.perf_counter()
-    subprocess.run(["tests/runtime_benchmark.exe"], check=True)
-    native_time = time.perf_counter() - start
-    print(f"Native Time: {native_time:.4f}s")
-    print("\n[Running Interpreter (GBP)...]")
-    env = os.environ.copy()
-    env["USE_GBP"] = "1"
-    start = time.perf_counter()
-    subprocess.run(SHL_CMD + ["run", "tests/runtime_benchmark.shl"], env=env, check=True)
-    interp_time = time.perf_counter() - start
-    print(f"Interpreter Time: {interp_time:.4f}s")
-    print("\n[Running Python Equivalent...]")
-    py_code = """
-i = 0
-sum = 0
-count = 100000000
-while i < count:
-    sum = sum + 1
-    i = i + 1
-print("Done")
-print(sum)
-"""
-    start = time.perf_counter()
-    exec(py_code)
-    py_time = time.perf_counter() - start
-    print(f"Python Time: {py_time:.4f}s")
-    print("\n" + "="*30)
-    print(f"Native Speedup vs Interpreter: {interp_time/native_time:.2f}x")
-    print(f"Native Speedup vs Python:      {py_time/native_time:.2f}x")
-    print("="*30)
-if __name__ == "__main__":
-    run_benchmark()

shell_lite-0.5.3/tests/compare_parsers.py

@@ -1,31 +0,0 @@
-import sys
-import os
-import time
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser import Parser
-from shell_lite.parser_gbp import GeometricBindingParser
-def benchmark(filename):
-    with open(filename, 'r') as f:
-        source = f.read()
-    long_source = source * 500 
-    print(f"Benchmarking on {len(long_source)} chars of code...")
-    lexer = Lexer(long_source)
-    tokens = lexer.tokenize()
-    tokens_copy = list(tokens)
-    start = time.perf_counter()
-    p_old = Parser(list(tokens)) # fresh copy? Parser consumes? yes
-    ast_old = p_old.parse()
-    end = time.perf_counter()
-    t_old = end - start
-    print(f"Recursive Descent: {t_old:.4f}s")
-    start = time.perf_counter()
-    p_new = GeometricBindingParser(list(tokens))
-    ast_new = p_new.parse()
-    end = time.perf_counter()
-    t_new = end - start
-    print(f"Geometric-Binding: {t_new:.4f}s")
-    diff = t_old / t_new if t_new > 0 else 0
-    print(f"Speedup: {diff:.2f}x")
-if __name__ == "__main__":
-    benchmark("tests/benchmark.shl")

shell_lite-0.5.3/tests/debug_jit.py

@@ -1,49 +0,0 @@
-import llvmlite.binding as llvm
-import sys
-def debug():
-    try:
-        llvm.initialize()
-        llvm.initialize_native_target()
-        llvm.initialize_native_asmprinter()
-        print("LLVM Initialized.")
-    except Exception as e:
-        print(f"Init Failed: {e}")
-        return
-    print("Available in llvm.binding:")
-    ops = [x for x in dir(llvm) if 'create' in x or 'jit' in x.lower() or 'engine' in x.lower()]
-    print(ops)
-    try:
-        mod = llvm.parse_assembly('define i32 @answer() { ret i32 42 }')
-        mod.verify()
-        print("Module parsed.")
-        target = llvm.Target.from_default_triple()
-        target_machine = target.create_target_machine()
-        engine = None
-        if hasattr(llvm, 'create_mcjit_compiler'):
-            print("Attempting MCJIT...")
-            try:
-                engine = llvm.create_mcjit_compiler(mod, target_machine)
-                print("MCJIT Created!")
-            except Exception as e:
-                print(f"MCJIT Failed: {e}")
-        if not engine and hasattr(llvm, 'create_execution_engine'):
-             print("Attempting create_execution_engine...")
-             try:
-                engine = llvm.create_execution_engine()
-                engine.add_module(mod)
-                print("ExecEngine Created!")
-             except Exception as e:
-                print(f"ExecEngine Failed: {e}")
-        if engine:
-            engine.finalize_object()
-            print("Engine Finalized.")
-            addr = engine.get_function_address("answer")
-            print(f"Function Address: {addr}")
-            import ctypes
-            cfunc = ctypes.CFUNCTYPE(ctypes.c_int)(addr)
-            res = cfunc()
-            print(f"Result: {res}")
-    except Exception as e:
-        print(f"Module/Engine Error: {e}")
-if __name__ == "__main__":
-    debug()

shell_lite-0.5.3/tests/generate_actual_graph.py

@@ -1,84 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-import subprocess
-import llvmlite.binding as llvm
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-try:
-    from tests.run_jit import compile_and_run_jit
-except ImportError:
-    sys.path.append(os.path.join(os.path.dirname(__file__)))
-    from run_jit import compile_and_run_jit
-def run_benchmark():
-    counts = [1000000, 10000000, 50000000, 100000000, 200000000] 
-    t_interp = []
-    t_python = []
-    t_llvm = []
-    print("Running Massive Runtime Benchmark...")
-    for n in counts:
-        print(f"\n--- n = {n} ---")
-        if n <= 100000: # Reduced limit for massive scale run
-            shl_code = f"i = 0\nwhile i < {n}:\n    i = i + 1\n"
-            shl_file = f"tests/temp_{n}.shl"
-            with open(shl_file, "w") as f: f.write(shl_code)
-            env = os.environ.copy()
-            env["USE_GBP"] = "1"
-            start = time.perf_counter()
-            try:
-                subprocess.run(["python", "shell_lite/main.py", "run", shl_file], env=env, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-                dur = time.perf_counter() - start
-            except subprocess.CalledProcessError as e:
-                print(f"Interp failed: {e.stderr.decode()}")
-                dur = None
-            except Exception as e:
-                print(f"Interp failed: {e}")
-                dur = None
-            t_interp.append(dur)
-            if os.path.exists(shl_file): os.remove(shl_file)
-            if dur is not None:
-                print(f"Interpreter: {dur:.4f}s")
-            else:
-                 print("Interpreter: Failed")
-        else:
-            t_interp.append(None) 
-            print("Interpreter: Skipped (Too Slow)")
-        start = time.perf_counter()
-        i = 0
-        while i < n:
-            i += 1
-        dur = time.perf_counter() - start
-        t_python.append(dur)
-        print(f"Python: {dur:.6f}s")
-        jit_code = f"""
-        i = 0
-        count = {n}
-        while i < count:
-            i = i + 1
-        """
-        try:
-             _, dur, _ = compile_and_run_jit(jit_code)
-             if dur < 1e-7: dur = 1e-7 
-             t_llvm.append(dur)
-             print(f"LLVM JIT: {dur:.8f}s")
-        except Exception as e:
-             print(f"JIT Failed: {e}")
-             t_llvm.append(None)
-    plt.figure(figsize=(10, 6))
-    x_interp = [x for x, y in zip(counts, t_interp) if y is not None]
-    y_interp = [y for y in t_interp if y is not None]
-    if x_interp:
-        plt.plot(x_interp, y_interp, label='ShellLite Interpreter', marker='o', color='orange')
-    plt.plot(counts, t_python, label='Python Native', marker='s', color='green')
-    plt.plot(counts, t_llvm, label='LLVM JIT', marker='^', color='purple', linestyle='-')
-    plt.xlabel('Iterations')
-    plt.ylabel('Time (seconds)')
-    plt.title('GBP+LLVM Runtime Performance (Massive Scale)')
-    plt.yscale('log')
-    plt.legend()
-    plt.grid(True, which="both", ls="-", alpha=0.2)
-    output_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'benchmark_final.png'))
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-if __name__ == "__main__":
-    run_benchmark()

shell_lite-0.5.3/tests/generate_perf_graph.py

@@ -1,68 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser import Parser
-from shell_lite.parser_gbp import GeometricBindingParser
-HAS_LLVM = False
-try:
-    from shell_lite.llvm_backend.codegen import LLVMCompiler
-    HAS_LLVM = True
-except ImportError:
-    print("LLVM backend (llvmlite) not found. Skipping LLVM benchmark.")
-def generate_large_file(lines=1000):
-    code = "x = 0\n"
-    for i in range(lines):
-        code += f"if x < {i}:\n"
-        code += f"    x = x + 1\n"
-    return code
-def run_benchmark():
-    sizes = [1000, 5000, 10000, 20000, 50000]
-    times_old = []
-    times_gbp = []
-    times_py = []
-    times_llvm = []
-    for size in sizes:
-        print(f"Benchmarking size: {size} lines...")
-        source_shl = generate_large_file(size)
-        source_py = source_shl.replace("x = x + 1", "x += 1")
-        start = time.perf_counter()
-        l = Lexer(source_shl)
-        toks = l.tokenize()
-        Parser(toks).parse()
-        times_old.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        l = Lexer(source_shl)
-        toks = l.tokenize()
-        GeometricBindingParser(toks).parse()
-        times_gbp.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        compile(source_py, '<string>', 'exec')
-        times_py.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        if HAS_LLVM:
-            l = Lexer(source_shl)
-            toks = l.tokenize()
-            ast = GeometricBindingParser(toks).parse()
-            LLVMCompiler().compile(ast)
-            times_llvm.append(time.perf_counter() - start)
-        else:
-            times_llvm.append(0)
-    plt.figure(figsize=(10, 6))
-    plt.plot(sizes, times_old, label='Old Parser', marker='o', color='red')
-    plt.plot(sizes, times_gbp, label='GBP Parser', marker='s', color='blue')
-    plt.plot(sizes, times_py, label='Python Native', marker='^', color='green')
-    if HAS_LLVM and any(times_llvm):
-        plt.plot(sizes, times_llvm, label='LLVM Compile (via GBP)', marker='x', color='purple', linestyle='--')
-    plt.xlabel('Lines of Code')
-    plt.ylabel('Time (seconds)')
-    plt.title('Parsing/Compilation Speed vs Code Size')
-    plt.legend()
-    plt.grid(True)
-    output_path = os.path.join(os.path.dirname(__file__), 'benchmark_scaling.png')
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-if __name__ == "__main__":
-    run_benchmark()

shell_lite-0.5.3/tests/generate_runtime_graph.py

@@ -1,58 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-import subprocess
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-def run_benchmark():
-    iterations = 1000000 # 1 Million
-    print(f"Benchmarking Runtime (Count: {iterations})...")
-    shl_code = f"""
-i = 0
-while i < {iterations}:
-    i = i + 1
-"""
-    shl_file = "tests/temp_loop.shl"
-    with open(shl_file, "w") as f:
-        f.write(shl_code)
-    env = os.environ.copy()
-    env["USE_GBP"] = "1"
-    start = time.perf_counter()
-    try:
-        subprocess.run(["python", "shell_lite/main.py", "run", shl_file], env=env, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-    except subprocess.CalledProcessError as e:
-        print(f"Interpreter Crash:\n{e.stderr.decode()}")
-        t_interp = 10.0 # Dummy
-    else:
-        t_interp = time.perf_counter() - start
-    print(f"Interpreter: {t_interp:.4f}s")
-    start = time.perf_counter()
-    i = 0
-    while i < iterations:
-        i = i + 1
-    t_python = time.perf_counter() - start
-    print(f"Python: {t_python:.4f}s")
-    t_llvm_est = t_python / 20.0 
-    print(f"LLVM (Est): {t_llvm_est:.4f}s")
-    labels = ['ShellLite Interpreter', 'Python Native', 'LLVM Native (Projected)']
-    times = [t_interp, t_python, t_llvm_est]
-    colors = ['orange', 'green', 'purple']
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(labels, times, color=colors)
-    plt.ylabel('Execution Time (seconds)')
-    plt.title(f'Runtime Speed Comparison ({iterations} Iterations)')
-    plt.yscale('log') # Log scale because difference is massive
-    for bar in bars:
-        height = bar.get_height()
-        plt.text(bar.get_x() + bar.get_width()/2., height,
-                 f'{height:.4f}s',
-                 ha='center', va='bottom')
-    plt.figtext(0.5, 0.01, 
-                "Note: Logarithmic Scale used due to massive speed difference.", 
-                ha="center", fontsize=10)
-    output_path = os.path.join(os.path.dirname(__file__), 'benchmark_runtime.png')
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-    if os.path.exists(shl_file): os.remove(shl_file)
-if __name__ == "__main__":
-    run_benchmark()

shell_lite-0.5.3/tests/run_jit.py

@@ -1,70 +0,0 @@
-import sys
-import os
-import time
-import ctypes
-import llvmlite.binding as llvm
-try:
-    from llvmlite.binding.orcjit import create_lljit_compiler, JITLibraryBuilder
-except ImportError:
-    import llvmlite.binding.orcjit as orc
-    create_lljit_compiler = orc.create_lljit_compiler
-    JITLibraryBuilder = orc.JITLibraryBuilder
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser_gbp import GeometricBindingParser
-from shell_lite.llvm_backend.codegen import LLVMCompiler
-def compile_and_run_jit(source_code):
-    llvm.initialize_native_target()
-    llvm.initialize_native_asmprinter()
-    start_compile = time.perf_counter()
-    lexer = Lexer(source_code)
-    tokens = lexer.tokenize()
-    ast = GeometricBindingParser(tokens).parse()
-    compiler = LLVMCompiler()
-    ir_module = compiler.compile(ast)
-    llvm_ir = str(ir_module)
-    start_jit = time.perf_counter()
-    lljit = create_lljit_compiler()
-    builder = JITLibraryBuilder()
-    builder.add_ir(llvm_ir)
-    tracker = builder.link(lljit, "shell_lite_lib")
-    try:
-        addr = tracker["main"]
-    except KeyError:
-        try:
-             addr = tracker["_main"]
-        except KeyError:
-             print("Error: Could not find 'main' symbol.")
-             return 0, 0, -1
-    jit_time = time.perf_counter() - start_jit
-    cfunc = ctypes.CFUNCTYPE(ctypes.c_int)(addr)
-    start_run = time.perf_counter()
-    res = cfunc()
-    run_time = time.perf_counter() - start_run
-    return start_jit - start_compile, run_time, res
-if __name__ == "__main__":
-    code = """
-    sum = 0
-    i = 0
-    count = 10000000
-    while i < count:
-        sum = sum + 1
-        i = i + 1
-    print sum
-    """
-    print("Running JIT Speed Test (10M iterations)...")
-    try:
-        c_time, r_time, res = compile_and_run_jit(code)
-        print(f"Result: {res}")
-        print(f"JIT Exec Time: {r_time:.6f}s")
-        start_py = time.perf_counter()
-        s, i, c = 0, 0, 10000000
-        while i < c:
-            s += 1
-            i += 1
-        py_time = time.perf_counter() - start_py
-        print(f"Python Exec:   {py_time:.6f}s")
-        print(f"Speedup: {py_time / r_time:.2f}x")
-    except Exception as e:
-        import traceback
-        traceback.print_exc()