parser.py

"""
Simple S-expression parser for Eva
"""

import re

def tokenize(program):
    """Convert program string into tokens"""
    # Remove comments (line by line to handle ; style comments too)
    lines = program.split('\n')
    cleaned_lines = []
    for line in lines:
        # Remove ; comments
        if ';' in line:
            line = line[:line.index(';')]
        cleaned_lines.append(line)
    program = '\n'.join(cleaned_lines)
    
    # Remove // and /* */ style comments
    program = re.sub(r'//.*', '', program)
    program = re.sub(r'/\*[\s\S]*?\*/', '', program)
    
    # Token patterns
    tokens = []
    i = 0
    while i < len(program):
        # Skip whitespace
        if program[i].isspace():
            i += 1
            continue
        
        # Parentheses
        if program[i] in '()':
            tokens.append(program[i])
            i += 1
            continue
        
        # Strings
        if program[i] == '"':
            j = i + 1
            while j < len(program) and program[j] != '"':
                j += 1
            tokens.append(program[i:j+1])
            i = j + 1
            continue
        
        # Numbers
        if program[i].isdigit():
            j = i
            while j < len(program) and program[j].isdigit():
                j += 1
            tokens.append(program[i:j])
            i = j
            continue
        
        # Symbols (including operators)
        if program[i] in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-+*=!<>/':
            j = i
            while j < len(program) and program[j] in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-+*=!<>/':
                j += 1
            tokens.append(program[i:j])
            i = j
            continue
        
        i += 1
    
    return tokens

def parse_tokens(tokens):
    """Parse tokens into AST"""
    if not tokens:
        raise Exception("Unexpected end of input")
    
    token = tokens.pop(0)
    
    # List
    if token == '(':
        result = []
        while tokens and tokens[0] != ')':
            result.append(parse_tokens(tokens))
        if not tokens:
            raise Exception("Expected ')' but got end of input")
        tokens.pop(0)  # Remove ')'
        return result
    
    # End of list (shouldn't happen)
    if token == ')':
        raise Exception("Unexpected ')'")
    
    # Number
    if token.isdigit():
        return int(token)
    
    # String
    if token.startswith('"'):
        return token[1:-1]  # Remove quotes
    
    # Symbol
    return token

def parse(program):
    """Parse Eva program into AST"""
    tokens = tokenize(program)
    if not tokens:
        return []
    return parse_tokens(tokens)

# AST Type Checkers

def is_number_ast(exp):
    """Check if expression is a number"""
    return isinstance(exp, int)

def is_string_ast(exp):
    """Check if expression is a string"""
    return isinstance(exp, str) and not is_symbol_ast(exp)

def is_symbol_ast(exp):
    """Check if expression is a symbol"""
    return isinstance(exp, str)

def is_list_ast(exp):
    """Check if expression is a list"""
    return isinstance(exp, list)

def is_tagged_list(exp, tag):
    """Check if expression is a list with specific tag"""
    return is_list_ast(exp) and len(exp) > 0 and exp[0] == tag