shell-lite 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

shell_lite/lexer.py

@@ -223,9 +223,16 @@ class Lexer:
                         'count': 'COUNT', 'many': 'MANY', 'how': 'HOW',
                         'field': 'FIELD', 'submit': 'SUBMIT', 'named': 'NAMED',
                         'placeholder': 'PLACEHOLDER',
-                        'app': 'APP', 'title': 'ID', 'size': 'ID',
-                        'column': 'ID', 'row': 'ID',
-                        'button': 'ID', 'heading': 'HEADING', 'text': 'ID',
+                        'app': 'APP', 'title': 'ID', 'size': 'SIZE',
+                        'column': 'COLUMN', 'row': 'ROW',
+                        'button': 'BUTTON', 'heading': 'HEADING', 'text': 'TEXT',
+                        'sum': 'SUM', 'upper': 'UPPER', 'lower': 'LOWER',
+                        'only': 'ONLY', 'letters': 'LETTERS', 
+                        'numbers': 'NUMBERS', 'digits': 'DIGITS',
+                        'that': 'THAT', 'are': 'ARE', 'prime': 'PRIME',
+                        'increment': 'INCREMENT', 'decrement': 'DECREMENT',
+                        'multiply': 'MULTIPLY', 'divide': 'DIVIDE',
+                        'be': 'BE', 'by': 'BY',
                     }
                     token_type = keywords.get(value, 'ID')
                     self.tokens.append(Token(token_type, value, self.line_number, current_col))

shell_lite/lexer_new.py

@@ -0,0 +1,252 @@
+import re
+from dataclasses import dataclass
+from typing import List, Optional
+@dataclass
+@dataclass
+class Token:
+    type: str
+    value: str
+    line: int
+    column: int = 1
+class Lexer:
+    def __init__(self, source_code: str):
+        self.source_code = source_code
+        self.tokens: List[Token] = []
+        self.current_char_index = 0
+        self.line_number = 1
+        self.indent_stack = [0]
+    def tokenize(self) -> List[Token]:
+        source = self._remove_multiline_comments(self.source_code)
+        lines = source.split('\n')
+        for line_num, line in enumerate(lines, 1):
+            self.line_number = line_num
+            stripped_line = line.strip()
+            if not stripped_line:
+                continue
+            indent_level = len(line) - len(line.lstrip())
+            if stripped_line.startswith('#'):
+                # self.tokens.append(Token('COMMENT', stripped_line, self.line_number, indent_level + 1))
+                # self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
+                continue
+            if indent_level > self.indent_stack[-1]:
+                self.indent_stack.append(indent_level)
+                self.tokens.append(Token('INDENT', '', self.line_number, indent_level + 1))
+            elif indent_level < self.indent_stack[-1]:
+                while indent_level < self.indent_stack[-1]:
+                    self.indent_stack.pop()
+                    self.tokens.append(Token('DEDENT', '', self.line_number, indent_level + 1))
+                if indent_level != self.indent_stack[-1]:
+                    raise IndentationError(f"Unindent does not match any outer indentation level on line {self.line_number}")
+            self.tokenize_line(stripped_line, indent_level + 1)
+            self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
+        while len(self.indent_stack) > 1:
+            self.indent_stack.pop()
+            self.tokens.append(Token('DEDENT', '', self.line_number, 1))
+        self.tokens.append(Token('EOF', '', self.line_number, 1))
+        return self.tokens
+    def _remove_multiline_comments(self, source: str) -> str:
+        result = []
+        i = 0
+        while i < len(source):
+            if source[i:i+2] == '/*':
+                end = source.find('*/', i + 2)
+                if end == -1:
+                    raise SyntaxError("Unterminated multi-line comment")
+                comment = source[i:end+2]
+                result.append('\n' * comment.count('\n'))
+                i = end + 2
+            else:
+                result.append(source[i])
+                i += 1
+        return ''.join(result)
+    def tokenize_line(self, line: str, start_col: int = 1):
+        pos = 0
+        while pos < len(line):
+            match = None
+            current_col = start_col + pos
+            if line[pos] == '#':
+                self.tokens.append(Token('COMMENT', line[pos:], self.line_number, current_col))
+                break
+            if line[pos].isspace():
+                pos += 1
+                continue
+            if line[pos].isdigit():
+                match = re.match(r'^\d+(\.\d+)?', line[pos:])
+                if match:
+                    value = match.group(0)
+                    self.tokens.append(Token('NUMBER', value, self.line_number, current_col))
+                    pos += len(value)
+                    continue
+            if line[pos:pos+3] in ('"""', "'''"):
+                 quote_char = line[pos:pos+3]
+                 pass
+            if line[pos] in ('"', "'"):
+                quote_char = line[pos]
+                end_quote = line.find(quote_char, pos + 1)
+                if end_quote == -1:
+                    raise SyntaxError(f"Unterminated string on line {self.line_number}")
+                value = line[pos+1:end_quote]
+                value = value.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r").replace("\\\"", "\"").replace("\\\'", "\'")
+                self.tokens.append(Token('STRING', value, self.line_number, current_col))
+                pos = end_quote + 1
+                continue
+            if line[pos:pos+3] == '...':
+                self.tokens.append(Token('DOTDOTDOT', '...', self.line_number, current_col))
+                pos += 3
+                continue
+            two_char = line[pos:pos+2]
+            two_char_tokens = {
+                '=>': 'ARROW', '==': 'EQ', '!=': 'NEQ',
+                '<=': 'LE', '>=': 'GE', '+=': 'PLUSEQ',
+                '-=': 'MINUSEQ', '*=': 'MULEQ', '/=': 'DIVEQ',
+                '%=': 'MODEQ'
+            }
+            if two_char in two_char_tokens:
+                self.tokens.append(Token(two_char_tokens[two_char], two_char, self.line_number, current_col))
+                pos += 2
+                continue
+            char = line[pos]
+            rest_of_line = line[pos:]
+            if rest_of_line.startswith('is at least '):
+                self.tokens.append(Token('GE', '>=', self.line_number, current_col))
+                pos += 12 
+                continue
+            elif rest_of_line.startswith('is exactly '):
+                self.tokens.append(Token('EQ', '==', self.line_number, current_col))
+                pos += 11
+                continue
+            elif rest_of_line.startswith('is less than '):
+                self.tokens.append(Token('LT', '<', self.line_number, current_col))
+                pos += 13
+                continue
+            elif rest_of_line.startswith('is more than '):
+                self.tokens.append(Token('GT', '>', self.line_number, current_col))
+                pos += 13
+                continue
+            if rest_of_line.startswith('the') and (len(rest_of_line) == 3 or not rest_of_line[3].isalnum()):
+                 pos += 3
+                 continue
+            if char == '/':
+                last_type = self.tokens[-1].type if self.tokens else None
+                is_division = False
+                if last_type in ('NUMBER', 'STRING', 'ID', 'RPAREN', 'RBRACKET'):
+                     is_division = True
+                if not is_division:
+                    end_slash = line.find('/', pos + 1)
+                    if end_slash != -1:
+                        pattern = line[pos+1:end_slash]
+                        flags = ""
+                        k = end_slash + 1
+                        while k < len(line) and line[k].isalpha():
+                            flags += line[k]
+                            k += 1
+                        self.tokens.append(Token('REGEX', pattern, self.line_number, current_col))
+                        pos = k
+                        continue
+            single_char_tokens = {
+                '+': 'PLUS', '-': 'MINUS', '*': 'MUL', '/': 'DIV',
+                '%': 'MOD', '=': 'ASSIGN', '>': 'GT', '<': 'LT',
+                '?': 'QUESTION', '(': 'LPAREN', ')': 'RPAREN',
+                '[': 'LBRACKET', ']': 'RBRACKET', ':': 'COLON',
+                '{': 'LBRACE', '}': 'RBRACE', ',': 'COMMA', '.': 'DOT'
+            }
+            if char in single_char_tokens:
+                self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
+                pos += 1
+                continue
+            if char.isalpha() or char == '_':
+                match = re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*', line[pos:])
+                if match:
+                    value = match.group(0)
+                    keywords = {
+                        'if': 'IF', 'else': 'ELSE', 'elif': 'ELIF',
+                        'for': 'FOR', 'in': 'IN', 'range': 'RANGE',
+                        'loop': 'LOOP', 'times': 'TIMES',
+                        'while': 'WHILE', 'until': 'UNTIL',
+                        'repeat': 'REPEAT', 'forever': 'FOREVER',
+                        'stop': 'STOP', 'skip': 'SKIP', 'exit': 'EXIT',
+                        'each': 'FOR',
+                        'unless': 'UNLESS', 'when': 'WHEN', 'otherwise': 'OTHERWISE',
+                        'then': 'THEN', 'do': 'DO',
+                        'print': 'PRINT', 'say': 'SAY', 'show': 'SAY',
+                        'input': 'INPUT', 'ask': 'ASK',
+                        'to': 'TO', 'can': 'TO',
+                        'return': 'RETURN', 'give': 'RETURN',
+                        'fn': 'FN',
+                        'structure': 'STRUCTURE', 'thing': 'STRUCTURE', 'class': 'STRUCTURE',
+                        'has': 'HAS', 'with': 'WITH',
+                        'is': 'IS', 'extends': 'EXTENDS', 'from': 'FROM',
+                        'make': 'MAKE', 'new': 'MAKE',
+                        'yes': 'YES', 'no': 'NO',
+                        'true': 'YES', 'false': 'NO',
+                        'const': 'CONST',
+                        'and': 'AND', 'or': 'OR', 'not': 'NOT',
+                        'try': 'TRY', 'catch': 'CATCH', 'always': 'ALWAYS',
+                        'use': 'USE', 'as': 'AS', 'share': 'SHARE',
+                        'execute': 'EXECUTE', 'run': 'EXECUTE',
+                        'alert': 'ALERT', 'prompt': 'PROMPT', 'confirm': 'CONFIRM',
+                        'spawn': 'SPAWN', 'await': 'AWAIT',
+                        'matches': 'MATCHES',
+                        'on': 'ON',
+                        'download': 'DOWNLOAD',
+                        'compress': 'COMPRESS', 'extract': 'EXTRACT', 'folder': 'FOLDER',
+                        'load': 'LOAD', 'save': 'SAVE', 'csv': 'CSV',
+                        'copy': 'COPY', 'paste': 'PASTE', 'clipboard': 'CLIPBOARD',
+                        'press': 'PRESS', 'type': 'TYPE', 'click': 'CLICK', 'at': 'AT',
+                        'notify': 'NOTIFY',
+                        'date': 'ID', 'today': 'ID', 'after': 'AFTER', 'before': 'BEFORE',
+                        'list': 'LIST', 'set': 'SET', 'unique': 'UNIQUE', 'of': 'OF',
+                        'wait': 'WAIT',
+                        'convert': 'CONVERT', 'json': 'JSON',
+                        'listen': 'LISTEN', 'port': 'PORT',
+                        'every': 'EVERY', 'minute': 'MINUTE', 'minutes': 'MINUTE',
+                        'second': 'SECOND', 'seconds': 'SECOND',
+                        'progress': 'PROGRESS',
+                        'bold': 'BOLD',
+                        'red': 'RED', 'green': 'GREEN', 'blue': 'BLUE', 
+                        'yellow': 'YELLOW', 'cyan': 'CYAN', 'magenta': 'MAGENTA',
+                        'serve': 'SERVE', 'static': 'STATIC',
+                        'write': 'WRITE', 'append': 'APPEND', 'read': 'READ', 'file': 'FILE',
+                        'write': 'WRITE', 'append': 'APPEND', 'read': 'READ', 'file': 'FILE',
+                        'db': 'DB', 'database': 'DB',
+                        'query': 'QUERY', 'open': 'OPEN', 'close': 'CLOSE', 'exec': 'EXEC',
+                        'middleware': 'MIDDLEWARE', 'before': 'BEFORE',
+                        'when': 'WHEN', 'someone': 'SOMEONE', 'visits': 'VISITS', 
+                        'submits': 'SUBMITS', 'start': 'START', 'server': 'SERVER',
+                        'files': 'FILES',
+                        'define': 'DEFINE', 'page': 'PAGE', 'called': 'CALLED',
+                        'using': 'USING', 'component': 'PAGE',
+                        'heading': 'HEADING', 'paragraph': 'PARAGRAPH',
+                        'image': 'IMAGE',
+                        'add': 'ADD', 'put': 'ADD', 'into': 'INTO',
+                        'count': 'COUNT', 'many': 'MANY', 'how': 'HOW',
+                        'field': 'FIELD', 'submit': 'SUBMIT', 'named': 'NAMED',
+                        'placeholder': 'PLACEHOLDER',
+                        'app': 'APP', 'title': 'ID', 'size': 'SIZE',
+                        'column': 'COLUMN', 'row': 'ROW',
+                        'button': 'BUTTON', 'heading': 'HEADING', 
+                        'sum': 'SUM', 'upper': 'UPPER', 'lower': 'LOWER',
+                        'increment': 'INCREMENT', 'decrement': 'DECREMENT',
+                        'multiply': 'MULTIPLY', 'divide': 'DIVIDE',
+                        'be': 'BE', 'by': 'BY',
+                        'plus': 'PLUS', 'minus': 'MINUS', 'divided': 'DIV',
+                        'greater': 'GREATER', 'less': 'LESS', 'equal': 'EQUAL',
+                        'define': 'DEFINE', 'function': 'FUNCTION',
+                        'contains': 'CONTAINS', 'empty': 'EMPTY',
+                        'remove': 'REMOVE',
+                        'than': 'THAN',
+                        'doing': 'DOING',
+                        'make': 'MAKE', 'be': 'BE',
+                        'as': 'AS', 'long': 'LONG',
+                        'otherwise': 'OTHERWISE',
+                        'ask': 'ASK',
+                    }
+                    token_type = keywords.get(value, 'ID')
+                    self.tokens.append(Token(token_type, value, self.line_number, current_col))
+                    pos += len(value)
+                    continue
+            if char in single_char_tokens:
+                self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
+                pos += 1
+                continue
+            raise SyntaxError(f"Illegal character '{char}' at line {self.line_number}")

shell_lite/main.py

@@ -5,13 +5,18 @@ import urllib.request
 import zipfile
 import io
 import subprocess
-from .lexer import Lexer
-from .parser import Parser
-from .interpreter import Interpreter
+from .lexer_new import Lexer
+from .parser_new import Parser
+from .interpreter_new import Interpreter
 from .ast_nodes import *
 import json
 def execute_source(source: str, interpreter: Interpreter):
     lines = source.split('\n')
+    import sys
+    if 'shell_lite.interpreter' in sys.modules:
+        print(f"DEBUG: Loaded interpreter from {sys.modules['shell_lite.interpreter'].__file__}")
+    else:
+        print("DEBUG: shell_lite.interpreter not in sys.modules yet?")
     import difflib
     try:
         lexer = Lexer(source)
@@ -52,6 +57,12 @@ def run_file(filename: str):
     if not os.path.exists(filename):
         print(f"Error: File '{filename}' not found.")
         return
+    import sys
+    if 'shell_lite.interpreter' in sys.modules:
+        print(f"DEBUG: shell_lite.interpreter file: {sys.modules['shell_lite.interpreter'].__file__}")
+    from .interpreter_final import Interpreter
+    print(f"DEBUG: Interpreter class: {Interpreter}")
+    
     with open(filename, 'r', encoding='utf-8') as f:
         source = f.read()
     interpreter = Interpreter()
@@ -61,7 +72,7 @@ def run_repl():
     print("\n" + "="*40)
     print("  ShellLite REPL - English Syntax")
     print("="*40)
-    print("Version: v0.04.2 | Made by Shrey Naithani")
+    print("Version: v0.04.3 | Made by Shrey Naithani")
     print("Commands: Type 'exit' to quit, 'help' for examples.")
     print("Note: Terminal commands (like 'shl install') must be run in CMD/PowerShell, not here.")
 
@@ -192,7 +203,7 @@ def install_globally():
         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.04.1) is installed!")
+        print(f"\n[SUCCESS] ShellLite (v0.04.3) is installed!")
         print(f"Location: {install_dir}")
         print("\nIMPORTANT STEP REQUIRED:")
         print("1. Close ALL open terminal windows (CMD, PowerShell, VS Code).")

shell_lite/minimal_interpreter.py

@@ -0,0 +1,25 @@
+
+class Environment:
+    def __init__(self, parent=None):
+        self.variables = {}
+        self.parent = parent
+    def get(self, name):
+        if name in self.variables: return self.variables[name]
+        if self.parent: return self.parent.get(name)
+        raise NameError(f"Var '{name}' not found")
+    def set(self, name, val):
+        self.variables[name] = val
+
+class Interpreter:
+    def __init__(self):
+        print("DEBUG: MINIMAL INTERPRETER LOADED")
+        self.global_env = Environment()
+        self.current_env = self.global_env
+        self.functions = {}
+        self.builtins = {
+            'str': str,
+            'print': print
+        }
+    def visit(self, node):
+        print(f"Visiting {type(node).__name__}")
+        return None

shell_lite/parser.py

@@ -133,6 +133,16 @@ class Parser:
             return self.parse_heading()
         elif self.check('PARAGRAPH'):
             return self.parse_paragraph()
+        elif self.check('INCREMENT'):
+            return self.parse_increment()
+        elif self.check('DECREMENT'):
+            return self.parse_decrement()
+        elif self.check('MULTIPLY'):
+            return self.parse_multiply()
+        elif self.check('DIVIDE'):
+            return self.parse_divide()
+        elif self.check('SET'):
+            return self.parse_set()
         else:
             return self.parse_expression_stmt()
     def parse_alert(self) -> Alert:
@@ -307,9 +317,17 @@ class Parser:
         self.consume('NEWLINE')
         return node
 
-    def parse_make_expr(self) -> Make:
+    def parse_make_expr(self) -> Node:
         token = self.consume('MAKE')
         class_name = self.consume('ID').value
+        
+        if self.check('BE'):
+            self.consume('BE')
+            value = self.parse_expression()
+            node = Assign(class_name, value) # class_name is actually variable name here
+            node.line = token.line
+            return node
+
         args = []
         if self.check('LPAREN'):
             self.consume('LPAREN')
@@ -1087,6 +1105,16 @@ class Parser:
              return node
         first_expr = self.parse_expression()
         skip_formatted()
+        
+        if self.check('TO'):
+            self.consume('TO')
+            end_val = self.parse_expression()
+            skip_formatted()
+            self.consume('RBRACKET')
+            node = Call('range', [first_expr, end_val])
+            node.line = token.line
+            return node
+
         if self.check('FOR'):
             self.consume('FOR')
             var_name = self.consume('ID').value
@@ -1407,11 +1435,18 @@ class Parser:
              return node
         elif token.type == 'READ':
              token = self.consume('READ')
-             self.consume('FILE')
+             if self.check('FILE'):
+                 self.consume('FILE')
              path = self.parse_factor()
              node = FileRead(path)
              node.line = token.line
              return node
+        elif token.type == 'SUM':
+            return self.parse_sum()
+        elif token.type == 'UPPER':
+            return self.parse_upper()
+        elif token.type == 'NUMBERS':
+            return self.parse_numbers_range()
         elif token.type == 'DATE':
              token = self.consume('DATE')
              s = self.consume('STRING').value
@@ -1814,3 +1849,245 @@ class Parser:
         node = FileWrite(path, content, 'a')
         node.line = token.line
         return node
+
+
+    def parse_increment(self) -> Assign:
+
+        token = self.consume('INCREMENT')
+
+        name = self.consume('ID').value
+
+        amount = Number(1)
+
+        if self.check('BY'):
+
+            self.consume('BY')
+
+            amount = self.parse_expression()
+
+        self.consume('NEWLINE')
+
+        node = Assign(name, BinOp(VarAccess(name), '+', amount))
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_decrement(self) -> Assign:
+
+        token = self.consume('DECREMENT')
+
+        name = self.consume('ID').value
+
+        amount = Number(1)
+
+        if self.check('BY'):
+
+            self.consume('BY')
+
+            amount = self.parse_expression()
+
+        self.consume('NEWLINE')
+
+        node = Assign(name, BinOp(VarAccess(name), '-', amount))
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_multiply(self) -> Assign:
+
+        token = self.consume('MULTIPLY')
+
+        name = self.consume('ID').value
+
+        self.consume('BY')
+
+        amount = self.parse_expression()
+
+        self.consume('NEWLINE')
+
+        node = Assign(name, BinOp(VarAccess(name), '*', amount))
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_divide(self) -> Assign:
+
+        token = self.consume('DIVIDE')
+
+        name = self.consume('ID').value
+
+        self.consume('BY')
+
+        amount = self.parse_expression()
+
+        self.consume('NEWLINE')
+
+        node = Assign(name, BinOp(VarAccess(name), '/', amount))
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_set(self) -> Assign:
+
+        token = self.consume('SET')
+
+        name = self.consume('ID').value
+
+        self.consume('TO')
+
+        value = self.parse_expression()
+
+        self.consume('NEWLINE')
+
+        node = Assign(name, value)
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_sum(self) -> Node:
+
+        token = self.consume('SUM')
+
+        self.consume('OF')
+
+        
+
+        # Check for 'numbers from ...'
+
+        if self.check('NUMBERS'):
+
+             range_node = self.parse_numbers_range()
+
+             # range_node is Call('range_list', ...)
+
+             # We want Call('sum', [range_node])
+
+             node = Call('sum', [range_node])
+
+             node.line = token.line
+
+             return node
+
+             
+
+        expr = self.parse_expression()
+
+        node = Call('sum', [expr])
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_upper(self) -> Node:
+
+        token = self.consume('UPPER')
+
+        expr = self.parse_expression()
+
+        only_letters = Boolean(False)
+
+        if self.check('ONLY'):
+
+            self.consume('ONLY')
+
+            if self.check('LETTERS'):
+
+                self.consume('LETTERS')
+
+            only_letters = Boolean(True)
+
+        node = Call('upper', [expr, only_letters])
+
+        node.line = token.line
+
+        return node
+
+
+
+    def parse_numbers_range(self) -> Node:
+
+        token = self.consume('NUMBERS')
+
+        self.consume('FROM')
+
+        start = self.parse_expression()
+
+        self.consume('TO')
+
+        end = self.parse_expression()
+
+        
+
+        condition = None
+
+        if self.check('THAT'):
+
+            self.consume('THAT')
+
+            self.consume('ARE')
+
+            if self.check('PRIME'):
+
+                self.consume('PRIME')
+
+                condition = String('prime')
+
+            elif self.check('DIGITS'):
+
+                self.consume('DIGITS')
+
+                condition = String('digits')
+
+        elif self.check('WHEN'):
+
+             self.consume('WHEN')
+
+             # 'when even' -> check for ID 'even' or expression?
+
+             # User example: 'when even'. Implicit variable?
+
+             # Let's verify repro: 'when even'
+
+             if self.check('ID') and self.peek().value == 'even':
+
+                 self.consume()
+
+                 condition = String('even')
+
+             elif self.check('ID') and self.peek().value == 'odd':
+
+                 self.consume()
+
+                 condition = String('odd')
+
+             else:
+
+                 # TODO: handle generic expression filter if needed
+
+                 pass
+
+                 
+
+        node = Call('range_list', [start, end, condition if condition else Boolean(False)])
+
+        node.line = token.line
+
+        return node
+