shell-lite 0.5.3.1__py3-none-any.whl → 0.5.3.3__py3-none-any.whl

shell_lite/interpreter.py

@@ -490,9 +490,9 @@ class Interpreter:
                 code_parts.append(colors[node.color.lower()])
             if code_parts:
                 ansi_code = "\033[" + ";".join(code_parts) + "m"
-                print(f"{ansi_code}{value}\033[0m")
+                print(f"{ansi_code}{value}\033[0m", flush=True)
                 return value
-        print(value)
+        print(value, flush=True)
         return value
     def visit_If(self, node: If):
         condition = self.visit(node.condition)
@@ -615,7 +615,6 @@ class Interpreter:
                      finally:
                          self.web.pop()
                  return result
-             return result
         try:
             func = self.current_env.get(node.name)
             if callable(func):
@@ -1504,7 +1503,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.1 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/main.py

@@ -150,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).")
@@ -443,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/parser_gbp.py

@@ -105,6 +105,8 @@ class GeometricBindingParser:
             return self.bind_return(node)
         elif head_type == 'REPEAT':
             return self.bind_repeat(node)
+        elif head_type == 'FOREVER':
+            return self.bind_forever(node)
         elif head_type == 'START':
             return self.bind_start(node)
         elif head_type == 'LISTEN':
@@ -139,6 +141,112 @@ class GeometricBindingParser:
         count = self.parse_expr_iterative(expr_tokens)
         body = [self.bind_node(child) for child in node.children]
         return Repeat(count, body)
+    
+    def bind_forever(self, node: GeoNode) -> Forever:
+        body = [self.bind_node(child) for child in node.children]
+        return Forever(body)
+
+    def bind_for(self, node: GeoNode) -> Node:
+        # 'for i in range 1 10' or 'for item in list'
+        # node.tokens starts with FOR/LOOP
+        # Next should be ID (var name)
+        if len(node.tokens) < 3: 
+             return None # Error?
+             
+        var_name = node.tokens[1].value
+        
+        # Check for 'IN'
+        in_index = -1
+        for i, t in enumerate(node.tokens):
+            if t.type == 'IN':
+                in_index = i
+                break
+        
+        if in_index == -1:
+             # Maybe 'loop 10 times'? No, that's Repeat (handled by bind_repeat if HEAD is REPEAT)
+             # But if HEAD is LOOP?
+             if node.head_token.type == 'LOOP':
+                 # loop 200 times
+                 # Delegated to bind_repeat logic if we can re-route, OR implement here
+                 # Look for TIMES
+                 if node.tokens[-1].type == 'TIMES':
+                     expr_tokens = self._extract_expr_tokens(node.tokens, start=1)
+                     expr_tokens.pop() # remove TIMES
+                     count = self.parse_expr_iterative(expr_tokens)
+                     body = [self.bind_node(child) for child in node.children]
+                     return Repeat(count, body)
+             return None
+
+        # It is a FOR loop
+        # Check for RANGE
+        range_index = -1
+        for i, t in enumerate(node.tokens):
+            if t.type == 'RANGE':
+                range_index = i
+                break
+                
+        if range_index != -1:
+             # for i in range 1 10
+             # Extract args after RANGE
+             args_tokens = node.tokens[range_index+1:]
+             # We need to split by space/comma? parse_expr_iterative might consume all?
+             # Range takes start, end, step.
+             # We can cheat and wrap them in a Call to 'range'?
+             # Or parse sub-expressions.
+             # Simplification: Assume numbers/vars separated by nothing (since lexer doesn't produce commas for spaces)
+             # But parse_expr_iterative consumes everything.
+             # We need to split manually if they are distinct expressions.
+             # Let's try to parse one expr, see where it ends? Not easy with shunting yard.
+             
+             # Fallback: Create a Call('range', ...)
+             # Actually, interpreter expects 'count' for For loop? 
+             # No, AST For node: For(count, body) -> interpreted as Repeat?
+             # Wait, AST For(count, body) vs ForIn(var_name, iterable, body)
+             
+             # Let's see AST definition.
+             pass 
+
+        # It is likely a ForIn
+        # iterable is everything after IN
+        iterable_tokens = self._extract_expr_tokens(node.tokens, start=in_index+1)
+        iterable = self.parse_expr_iterative(iterable_tokens)
+        body = [self.bind_node(child) for child in node.children]
+        
+        # Handle 'range 1 10' as an iterable (Call to range)
+        if node.tokens[in_index+1].type == 'RANGE':
+             # tokens: FOR i IN RANGE 1 10
+             # We want Call('range', [1, 10])
+             # Extract numbers after RANGE
+             args_tokens = self._extract_expr_tokens(node.tokens, start=in_index+2)
+             # Assumption: args are space separated expressions. 
+             # parse_expr_iterative consumes all. 
+             # We need to manually split if there are multiple args?
+             # But 'range 1 10' in ShellLite usually means two numbers.
+             # If we just Pass all tokens to parse_expr_iterative, it might just return the first one if not connected by operator.
+             # For 'range 1 10', we have NUMBER 1, NUMBER 10.
+             # We need to build a list of args.
+             range_args = []
+             k = 0
+             while k < len(args_tokens):
+                 # Try to parse one expression? 
+                 # This is hard with current parser structure.
+                 # SIMPLE HACK: Just take the next two tokens as numbers?
+                 # Or treat them as separate expression?
+                 if args_tokens[k].type in ('NUMBER', 'STRING', 'ID'):
+                     t = args_tokens[k]
+                     val = None
+                     if t.type == 'NUMBER':
+                         val = Number(int(t.value) if '.' not in t.value else float(t.value))
+                     elif t.type == 'STRING':
+                         val = String(t.value)
+                     elif t.type == 'ID':
+                         val = VarAccess(t.value)
+                     if val: range_args.append(val)
+                 k += 1
+             
+             iterable = Call('range', range_args)
+             
+        return ForIn(var_name, iterable, body)
     def bind_print(self, node: GeoNode) -> Print:
         expr_tokens = self._extract_expr_tokens(node.tokens, start=1)
         expr = self.parse_expr_iterative(expr_tokens)
@@ -352,7 +460,39 @@ class GeometricBindingParser:
                 i = j # Advance past list
             elif t.type == 'ID':
                 if i+1 < len(tokens) and tokens[i+1].type == 'LPAREN':
-                    values.append(VarAccess(t.value))
+                     # Function call: ID(args)
+                     name = t.value
+                     
+                     # Find matching RPAREN
+                     depth = 1
+                     j = i + 2 # Skip ID and LPAREN
+                     elements_tokens = []
+                     current_elem = []
+                     
+                     arg_tokens_start = j
+                     # Check for empty call "func()"
+                     if j < len(tokens) and tokens[j].type == 'RPAREN':
+                         i = j # Advance to RPAREN
+                         values.append(Call(name, []))
+                     else:
+                         while j < len(tokens):
+                             if tokens[j].type == 'LPAREN': depth += 1
+                             elif tokens[j].type == 'RPAREN': depth -= 1
+                             
+                             if depth == 0:
+                                 if current_elem: elements_tokens.append(current_elem)
+                                 break
+                             
+                             if tokens[j].type == 'COMMA' and depth == 1:
+                                 elements_tokens.append(current_elem)
+                                 current_elem = []
+                             else:
+                                 current_elem.append(tokens[j])
+                             j += 1
+                         
+                         args = [self.parse_expr_iterative(elem) for elem in elements_tokens if elem]
+                         values.append(Call(name, args))
+                         i = j # Advance to RPAREN
                 else:
                     values.append(VarAccess(t.value))
             elif t.type == 'LPAREN':

{shell_lite-0.5.3.1.dist-info → shell_lite-0.5.3.3.dist-info}/METADATA

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

shell_lite-0.5.3.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+shell_lite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+shell_lite/ast_nodes.py,sha256=W2oefXuRjqnQybR5ZcdPU0qC5gxHZHcotQc3LAVDLM0,6129
+shell_lite/cli.py,sha256=14Kq1ohSXS3p-xdh0DPi7eXskUtSX81huSyGhktoOMA,250
+shell_lite/compiler.py,sha256=t2Imae9h03v3GIIKrCo16qCDDLKSxrpjrp83tv0SzUQ,24982
+shell_lite/interpreter.py,sha256=8DMbNZ9zFizJ8mpBDKjPUDf-1Nhxm7NtME9c-XVvxB8,75960
+shell_lite/js_compiler.py,sha256=yEGIkkIvHGU7o1htHEqlQr6BE0wL35PtL5PssNld9fc,5606
+shell_lite/lexer.py,sha256=cNLk_N59a7eKQaQp7Mqcnxy1um64-QgtDEi2eAsAWKE,14913
+shell_lite/main.py,sha256=Vg-BUReR3JsK-sdcwFYUIx5vy8AkSLmqfsOQRWAVFdU,20150
+shell_lite/parser.py,sha256=qsR2wQUWjUPXbXgnmv8pmOgfX99lYYH6tpxKH3PEnfQ,88471
+shell_lite/parser_gbp.py,sha256=M1wlJITxnkonVp8Z9ypuEVJ8k9Hg_C95TwzZoADvkBY,23229
+shell_lite/runtime.py,sha256=pSjBeA1dTQ-a94q3FLdv9lqZurdd6MJmfhFGHhOoQEM,16057
+shell_lite-0.5.3.3.dist-info/LICENSE,sha256=LlK8rVgwqMiti6NfaXa8xfvXAwfYe5SVrvcz3YpwHgg,37277
+shell_lite-0.5.3.3.dist-info/METADATA,sha256=mGfmA3oWVbJXargaZhSQw-iLR_HXciBPE2CQoDNXcoU,10586
+shell_lite-0.5.3.3.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
+shell_lite-0.5.3.3.dist-info/entry_points.txt,sha256=tglL8tjyPIh1W85j6zFpNZjMpQe_xC-k-7BOhHLWfxc,45
+shell_lite-0.5.3.3.dist-info/top_level.txt,sha256=hIln5ltrok_Mn3ijlQeqMFF6hHBHCyhzqCO7KL358cg,11
+shell_lite-0.5.3.3.dist-info/RECORD,,

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/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.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-shell_lite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-shell_lite/ast_nodes.py,sha256=W2oefXuRjqnQybR5ZcdPU0qC5gxHZHcotQc3LAVDLM0,6129
-shell_lite/cli.py,sha256=14Kq1ohSXS3p-xdh0DPi7eXskUtSX81huSyGhktoOMA,250
-shell_lite/compiler.py,sha256=t2Imae9h03v3GIIKrCo16qCDDLKSxrpjrp83tv0SzUQ,24982
-shell_lite/interpreter.py,sha256=2vpfYWSx14wmxYxUrDc-6oRXRDDFRbSUnLJxspbKpWs,75964
-shell_lite/js_compiler.py,sha256=yEGIkkIvHGU7o1htHEqlQr6BE0wL35PtL5PssNld9fc,5606
-shell_lite/lexer.py,sha256=cNLk_N59a7eKQaQp7Mqcnxy1um64-QgtDEi2eAsAWKE,14913
-shell_lite/main.py,sha256=bxgVbrRXFAb3s2WGL4I5ukX3HEw-9CiTs9-pLQxN400,19887
-shell_lite/parser.py,sha256=qsR2wQUWjUPXbXgnmv8pmOgfX99lYYH6tpxKH3PEnfQ,88471
-shell_lite/parser_gbp.py,sha256=IV5lD1IipDOqgoC6UdVpFnuWQBb73WmEAYMigDGTfcQ,16555
-shell_lite/runtime.py,sha256=pSjBeA1dTQ-a94q3FLdv9lqZurdd6MJmfhFGHhOoQEM,16057
-shell_lite/llvm_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shell_lite/llvm_backend/builder.py,sha256=WjDj65DePu8LPpOpnjfS2XREy9vQt7aySAqRYvBMq5w,1434
-shell_lite/llvm_backend/codegen.py,sha256=sTpYxSdrOOqyjf9lj7TLQ5ZFOUM17RykL1QNeariZZM,15875
-shell_lite-0.5.3.1.dist-info/LICENSE,sha256=LlK8rVgwqMiti6NfaXa8xfvXAwfYe5SVrvcz3YpwHgg,37277
-shell_lite-0.5.3.1.dist-info/METADATA,sha256=Ly4VwyWR4VmeX7ybGVT2LZHnl-ot6m0JbcpzUkg2dzw,10586
-shell_lite-0.5.3.1.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
-shell_lite-0.5.3.1.dist-info/entry_points.txt,sha256=tglL8tjyPIh1W85j6zFpNZjMpQe_xC-k-7BOhHLWfxc,45
-shell_lite-0.5.3.1.dist-info/top_level.txt,sha256=hIln5ltrok_Mn3ijlQeqMFF6hHBHCyhzqCO7KL358cg,11
-shell_lite-0.5.3.1.dist-info/RECORD,,