চূড়ান্ত প্রকল্প — একটি মিনি ইন্টারপ্রেটার বানানো

# ---------- ১) লেক্সার (M4/L20 স্টাইল) ----------
class Token:
    def __init__(self, type_, value):
        self.type = type_
        self.value = value
    def __repr__(self):
        return f"Token({self.type},{self.value!r})"

KEYWORDS = {"print"}

def tokenize(source):
    tokens = []
    i, n = 0, len(source)
    while i < n:
        ch = source[i]
        if ch in " \t":
            i += 1; continue
        if ch == "\n":
            tokens.append(Token("NEWLINE", "\\n")); i += 1; continue
        if ch.isdigit():
            start = i
            while i < n and source[i].isdigit():
                i += 1
            tokens.append(Token("NUMBER", int(source[start:i]))); continue
        if ch.isalpha() or ch == "_":
            start = i
            while i < n and (source[i].isalnum() or source[i] == "_"):
                i += 1
            word = source[start:i]
            tokens.append(Token("PRINT", word) if word in KEYWORDS else Token("IDENT", word))
            continue
        simple = {"+": "PLUS", "-": "MINUS", "*": "STAR", "/": "SLASH",
                  "(": "LPAREN", ")": "RPAREN", "=": "ASSIGN"}
        if ch in simple:
            tokens.append(Token(simple[ch], ch)); i += 1; continue
        raise ValueError(f"লেক্সিক্যাল এরর: অজানা ক্যারেক্টার {ch!r}, পজিশন {i}")
    tokens.append(Token("EOF", None))
    return tokens


# ---------- ২) স্কোপযুক্ত সিম্বল টেবিল (M6/L28-L29 স্টাইল) ----------
class SymbolTable:
    def __init__(self):
        self.scopes = [{}]   # স্কোপের স্ট্যাক -- এখানে শুধু গ্লোবাল স্কোপ ব্যবহৃত হচ্ছে

    def assign(self, name, value):
        for scope in reversed(self.scopes):
            if name in scope:
                scope[name] = value
                return
        self.scopes[-1][name] = value   # নতুন ভ্যারিয়েবল -- বর্তমান স্কোপে ঘোষিত হয়

    def lookup(self, name):
        for scope in reversed(self.scopes):
            if name in scope:
                return scope[name]
        raise NameError(f"অঘোষিত ভ্যারিয়েবল: {name!r}")


# ---------- ৩) রিকার্সিভ ডিসেন্ট পার্সার (M5/L22 গ্রামার) ----------
class ParseError(Exception):
    pass

class Parser:
    def __init__(self, tokens):
        self.tokens = tokens
        self.pos = 0

    def peek(self):
        return self.tokens[self.pos]

    def advance(self):
        tok = self.tokens[self.pos]; self.pos += 1; return tok

    def expect(self, type_):
        tok = self.peek()
        if tok.type != type_:
            raise ParseError(f"{type_} প্রত্যাশিত, পাওয়া গেছে {tok.type}")
        return self.advance()

    def skip_newlines(self):
        while self.peek().type == "NEWLINE":
            self.advance()

    def parse_program(self):
        statements = []
        self.skip_newlines()
        while self.peek().type != "EOF":
            statements.append(self.parse_statement())
            self.skip_newlines()
        return ("program", statements)

    def parse_statement(self):
        tok = self.peek()
        if tok.type == "IDENT":
            name = self.advance().value
            self.expect("ASSIGN")
            expr = self.parse_expr()
            if self.peek().type == "NEWLINE": self.advance()
            return ("assign", name, expr)
        if tok.type == "PRINT":
            self.advance(); self.expect("LPAREN")
            expr = self.parse_expr()
            self.expect("RPAREN")
            if self.peek().type == "NEWLINE": self.advance()
            return ("print", expr)
        raise ParseError(f"স্টেটমেন্টের শুরুতে অপ্রত্যাশিত টোকেন: {tok.type}")

    def parse_expr(self):
        node = self.parse_term()
        while self.peek().type in ("PLUS", "MINUS"):
            op = self.advance().type
            rhs = self.parse_term()
            node = ("binop", "+" if op == "PLUS" else "-", node, rhs)
        return node

    def parse_term(self):
        node = self.parse_factor()
        while self.peek().type in ("STAR", "SLASH"):
            op = self.advance().type
            rhs = self.parse_factor()
            node = ("binop", "*" if op == "STAR" else "/", node, rhs)
        return node

    def parse_factor(self):
        tok = self.peek()
        if tok.type == "NUMBER":
            self.advance(); return ("num", tok.value)
        if tok.type == "IDENT":
            self.advance(); return ("var", tok.value)
        if tok.type == "LPAREN":
            self.advance()
            node = self.parse_expr()
            self.expect("RPAREN")
            return node
        raise ParseError(f"factor-এ অপ্রত্যাশিত টোকেন: {tok.type}")


# ---------- ৪) ট্রি-ওয়াকিং ইভালুয়েটর (M6/L30, M9/L41 স্টাইল) ----------
class MiniInterpreter:
    def __init__(self):
        self.symtab = SymbolTable()
        self.output = []

    def run(self, source):
        tokens = tokenize(source)
        ast = Parser(tokens).parse_program()
        self.exec_node(ast)
        return tokens, ast, self.output

    def exec_node(self, node):
        kind = node[0]
        if kind == "program":
            for stmt in node[1]:
                self.exec_node(stmt)
        elif kind == "assign":
            _, name, expr = node
            self.symtab.assign(name, self.eval_expr(expr))
        elif kind == "print":
            _, expr = node
            value = self.eval_expr(expr)
            self.output.append(value)
            print(f"  >>> print আউটপুট: {value}")
        else:
            raise ValueError("অজানা স্টেটমেন্ট নোড: " + kind)

    def eval_expr(self, node):
        kind = node[0]
        if kind == "num":
            return node[1]
        if kind == "var":
            return self.symtab.lookup(node[1])       # M6/L28-এর lookup -- নাম-রেজোলিউশন
        if kind == "binop":
            _, op, l, r = node
            lv, rv = self.eval_expr(l), self.eval_expr(r)
            if op == "+": return lv + rv
            if op == "-": return lv - rv
            if op == "*": return lv * rv
            if op == "/": return lv // rv
        raise ValueError("অজানা এক্সপ্রেশন নোড: " + kind)


# ---------- সম্পূর্ণ পাইপলাইন চালানো ----------
source = "x = 3 + 4\ny = x * 2\nprint(y)\nprint(x + y)\n"
print("সোর্স প্রোগ্রাম:")
print(source)

interp = MiniInterpreter()
tokens, ast, output = interp.run(source)

print("== ধাপ ১: টোকেন স্ট্রিম (M4) ==")
for t in tokens:
    print(" ", t)

print("\n== ধাপ ২: AST (M5) ==")
print(" ", ast)

print("\n== ধাপ ৩: এক্সিকিউশন (উপরে print আউটপুট ইতিমধ্যে দেখানো হয়েছে) ==")
print("সংগ্রহ করা print আউটপুট:", output)

print("\n== চূড়ান্ত যাচাই ==")
print("x =", interp.symtab.lookup("x"), " y =", interp.symtab.lookup("y"))
assert interp.symtab.lookup("x") == 7
assert interp.symtab.lookup("y") == 14
assert output == [14, 21]
print("PASS -- x=7, y=14, print(y)->14, print(x+y)->21 -- সবকিছু সঠিক")

print("\n== অঘোষিত ভ্যারিয়েবলের এরর হ্যান্ডলিং (M5/L27, M6/L28 স্টাইল) ==")
try:
    MiniInterpreter().run("print(z)\n")
except NameError as e:
    print("সঠিকভাবে ধরা পড়েছে:", e)