Create the Basic Compiler

Create a file named basic_compiler.py and add the following code:

pythonCopy codeclass Lexer:
def __init__(self, text):
    self.text = text
    self.position = 0
    self.current_char = self.text[self.position]
def error(self):
    raise Exception("Invalid character")
def advance(self):
    """Advance the 'position' pointer and set the 'current_char'."""
    self.position += 1
    if self.position > len(self.text) - 1:
        self.current_char = None  # Indicates the end of the input
    else:
        self.current_char = self.text[self.position]
def skip_whitespace(self):
    """Skip whitespace characters."""
    while self.current_char is not None and self.current_char.isspace():
        self.advance()
def variable(self):
    """Return a variable identifier."""
    result = ''
    while self.current_char is not None and self.current_char.isalnum():
        result += self.current_char
        self.advance()
    return result
def number(self):
    """Return a multi-digit integer."""
    result = ''
    while self.current_char is not None and self.current_char.isdigit():
        result += self.current_char
        self.advance()
    return int(result)
def get_next_token(self):
    """Tokenize the input string."""
    while self.current_char is not None:
        if self.current_char.isspace():
            self.skip_whitespace()
            continue
        if self.current_char.isalpha():
            return ('VARIABLE', self.variable())
        if self.current_char.isdigit():
            return ('NUMBER', self.number())
        if self.current_char == '+':
            self.advance()
            return ('PLUS', '+')
        if self.current_char == '-':
            self.advance()
            return ('MINUS', '-')
        if self.current_char == '=':
            self.advance()
            return ('EQUALS', '=')
        self.error()
    return ('EOF', None)

class Interpreter:
def __init__(self, lexer):
    self.lexer = lexer
    self.current_token = self.lexer.get_next_token()
    self.variables = {}
def error(self):
    raise Exception("Invalid syntax")
def eat(self, token_type):
    """Consume the current token if it matches the expected type."""
    if self.current_token[0] == token_type:
        self.current_token = self.lexer.get_next_token()
    else:
        self.error()
def factor(self):
    """Parse a factor."""
    token = self.current_token
    if token[0] == 'NUMBER':
        self.eat('NUMBER')
        return token[1]
    elif token[0] == 'VARIABLE':
        var_name = token[1]
        self.eat('VARIABLE')
        return self.variables.get(var_name, 0)
def term(self):
    """Parse a term (factor)."""
    result = self.factor()
    return result
def expression(self):
    """Parse an expression."""
    result = self.term()
    while self.current_token[0] in ('PLUS', 'MINUS'):
        token = self.current_token
        if token[0] == 'PLUS':
            self.eat('PLUS')
            result += self.term()
        elif token[0] == 'MINUS':
            self.eat('MINUS')
            result -= self.term()
    return result
def assignment(self):
    """Parse an assignment statement."""
    var_name = self.current_token[1]
    self.eat('VARIABLE')
    self.eat('EQUALS')
    value = self.expression()
    self.variables[var_name] = value
    return value

def main():
while True:
    try:
        text = input("Enter a statement (or 'exit' to quit): ")
        if text.lower() == 'exit':
            break
        lexer = Lexer(text)
        interpreter = Interpreter(lexer)
        result = interpreter.assignment()
        print(f"Result: {result}")
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
main()

Step 2: Running the Basic Compiler

1. Open your terminal (or command prompt).
2. Navigate to the directory where you saved basic_compiler.py.
3. Run the script using the command:bashCopy codepython basic_compiler.py

How It Works

• Lexer: The Lexer class tokenizes the input string into meaningful components like numbers, variables, and operators.
• Interpreter: The Interpreter class parses the tokens and evaluates expressions and assignments. It maintains a dictionary to store variable values.
• Input Handling: The user can enter statements to assign values to variables or evaluate expressions.