syntax_parser.py

# PL Assignment Python
# -*- coding: utf-8 -*-

MAX_VAR_LEN = 10  # Maximum length of variable name or number (10 chars)

tokens = []      # List to store tokens from input code
pos = 0          # Current token index for parsing state
outputs = []     # List to store results of executed print statements
symbols = {}     # Symbol table: dictionary mapping variable names to integer values

# Custom exception class (used for syntax errors)
class ParseError(Exception):
    pass

def error():
    """Raise ParseError exception when a syntax error occurs."""
    raise ParseError("Syntax Error!")

def get_symbol_value(name):
    """Return the value of variable 'name' from the symbol table (default 0 if not found)."""
    return symbols.get(name, 0)

def set_symbol_value(name, value):
    """Store or update the value of variable 'name' in the symbol table."""
    symbols[name] = value

def parseFactor():
    """
    Parse <factor>:
      <factor> → [ '-' ] ( <number> | <var> | '(' <expr> ')' )
    """
    global pos, tokens
    if pos < len(tokens) and tokens[pos] == "-":
        pos += 1
        return -parseFactor()
    elif pos < len(tokens) and tokens[pos] == "(":
        pos += 1
        value = parseExpr()
        if pos >= len(tokens) or tokens[pos] != ")":
            error()
        pos += 1
        return value
    elif pos < len(tokens) and tokens[pos][0].isdigit():
        if len(tokens[pos]) > MAX_VAR_LEN:
            error()
        for ch in tokens[pos]:
            if not ch.isdigit():
                error()
        value = int(tokens[pos])
        pos += 1
        return value
    elif pos < len(tokens) and tokens[pos][0].isalpha():
        if len(tokens[pos]) > MAX_VAR_LEN:
            error()
        for ch in tokens[pos]:
            if not ch.islower():
                error()
        varname = tokens[pos]
        pos += 1
        return get_symbol_value(varname)
    else:
        error()
        return 0

def parseTerm():
    """
    Parse <term>:
      <term> → <factor> { '-' <factor> }
    """
    global pos, tokens
    value = parseFactor()
    while pos < len(tokens) and tokens[pos] == "-":
        pos += 1
        rhs = parseFactor()
        value = value - rhs
    return value

def parseExpr():
    """
    Parse <expr>:
      <expr> → <term> { ('+' | '*') <term> }
    """
    global pos, tokens
    value = parseTerm()
    while pos < len(tokens) and tokens[pos] in ("+", "*"):
        op = tokens[pos]
        pos += 1
        rhs = parseTerm()
        if op == "+":
            value = value + rhs
        elif op == "*":
            value = value * rhs
    return value

def parseStatement():
    """
    Parse statement:
      1. print statement: "print <var> ;"
      2. assignment: "<var> = <expr> ;"
    """
    global pos, tokens, outputs, symbols
    if pos < len(tokens) and tokens[pos] == "print":
        pos += 1
        if pos >= len(tokens) or not tokens[pos][0].isalpha():
            error()
        if len(tokens[pos]) > MAX_VAR_LEN:
            error()
        for ch in tokens[pos]:
            if not ch.islower():
                error()
        varname = tokens[pos]
        pos += 1
        if pos >= len(tokens) or tokens[pos] != ";":
            error()
        pos += 1
        value = get_symbol_value(varname)
        outputs.append(value)
    elif pos < len(tokens) and tokens[pos][0].isalpha():
        if len(tokens[pos]) > MAX_VAR_LEN:
            error()
        for ch in tokens[pos]:
            if not ch.islower():
                error()
        varname = tokens[pos]
        pos += 1
        if pos >= len(tokens) or tokens[pos] != "=":
            error()
        pos += 1
        value = parseExpr()
        if pos >= len(tokens) or tokens[pos] != ";":
            error()
        pos += 1
        set_symbol_value(varname, value)
    else:
        error()

def main():
    """
    Main function:
    - Reads input line by line, tokenizes, parses, and executes.
    - Terminates when receiving an empty line.
    """
    while True:
        try:
            line = input()  # Read one line from user input
        except EOFError:
            break  # Exit on EOF

        # If input line is empty (or only whitespace), terminate program
        if line.strip() == "":
            break

        global tokens, pos, outputs, symbols
        tokens = line.split()  # Split tokens by whitespace
        pos = 0
        outputs = []
        symbols = {}  # Reset variables for each line

        try:
            # Parse statements while tokens remain
            while pos < len(tokens):
                parseStatement()
            if outputs:
                print(" ".join(str(o) for o in outputs))
        except ParseError:
            print("Syntax Error!")

if __name__ == '__main__':
    main()