সিনট্যাক্স এরর রিকভারি

# L22-এর রিকার্সিভ ডিসেন্ট গ্রামার + প্যানিক-মোড এরর রিকভারি

def tokenize(s):
    tokens = []
    names = {'+': 'PLUS', '-': 'MINUS', '*': 'STAR', '/': 'SLASH',
             '(': 'LPAREN', ')': 'RPAREN', ',': 'COMMA'}
    i = 0
    while i < len(s):
        ch = s[i]
        if ch.isspace():
            i += 1
        elif ch.isdigit():
            start = i
            while i < len(s) and s[i].isdigit():
                i += 1
            tokens.append(("NUMBER", s[start:i]))
        elif ch in names:
            tokens.append((names[ch], ch))
            i += 1
        else:
            raise ValueError(f"অজানা ক্যারেক্টার: {ch!r}")
    tokens.append(("EOF", ""))
    return tokens


class ParseError(Exception):
    """সিনট্যাক্স এরর -- এরর মেসেজ এবং এরর যেখানে ঘটেছে সেই পজিশন ধরে রাখে।"""
    def __init__(self, message, pos):
        super().__init__(message)
        self.pos = pos


# --- expr ::= term expr' | expr' ::= (+|-) term expr' | eps ---
# --- term ::= factor term' | term' ::= (*|/) factor term' | eps ---
# --- factor ::= NUMBER | ( expr ) ---  (বাম-রিকার্শন-মুক্ত, L22 অনুযায়ী)

def parse_factor(tokens, pos):
    kind, val = tokens[pos]
    if kind == "NUMBER":
        return ("num", int(val)), pos + 1
    if kind == "LPAREN":
        node, pos = parse_expr(tokens, pos + 1)
        kind2, val2 = tokens[pos]
        if kind2 != "RPAREN":
            raise ParseError(f"')' প্রত্যাশিত, পাওয়া গেছে {val2!r}", pos)
        return node, pos + 1
    raise ParseError(f"সংখ্যা বা '(' প্রত্যাশিত, পাওয়া গেছে {val!r}", pos)

def parse_term_prime(tokens, pos, left):
    kind, val = tokens[pos]
    if kind in ("STAR", "SLASH"):
        right, pos = parse_factor(tokens, pos + 1)
        return parse_term_prime(tokens, pos, ("binop", val, left, right))
    return left, pos

def parse_term(tokens, pos):
    left, pos = parse_factor(tokens, pos)
    return parse_term_prime(tokens, pos, left)

def parse_expr_prime(tokens, pos, left):
    kind, val = tokens[pos]
    if kind in ("PLUS", "MINUS"):
        right, pos = parse_term(tokens, pos + 1)
        return parse_expr_prime(tokens, pos, ("binop", val, left, right))
    return left, pos

def parse_expr(tokens, pos):
    left, pos = parse_term(tokens, pos)
    return parse_expr_prime(tokens, pos, left)

def evaluate(node):
    if node[0] == "num":
        return node[1]
    _, op, left, right = node
    lv, rv = evaluate(left), evaluate(right)
    return {"+": lv + rv, "-": lv - rv, "*": lv * rv, "/": lv / rv}[op]


SYNC_SET = {"COMMA", "EOF"}

def synchronize(tokens, pos):
    """সিঙ্ক্রোনাইজিং সেটের একটি টোকেন না মেলা পর্যন্ত ইনপুট বাদ দিতে থাকে।"""
    while tokens[pos][0] not in SYNC_SET:
        pos += 1
    return pos

def parse_expression_list(tokens):
    """কমা-বিভক্ত এক্সপ্রেশন তালিকা পার্স করে -- প্রতিটি এক্সপ্রেশনের এরর আলাদাভাবে রিকভার হয়।"""
    results, errors = [], []
    pos = 0
    while True:
        try:
            node, pos = parse_expr(tokens, pos)
            results.append(node)
        except ParseError as e:
            errors.append((str(e), e.pos))
            results.append(None)
            pos = synchronize(tokens, e.pos)
        kind, _ = tokens[pos]
        if kind == "COMMA":
            pos += 1
            continue
        break  # EOF
    return results, errors


# ইচ্ছাকৃতভাবে দুটো ভাঙা সাব-এক্সপ্রেশনসহ ইনপুট -- মাঝে বৈধ এক্সপ্রেশনও আছে
source = "2 + 3, * 5, 4 + ), 7 * 2"
print(f"সোর্স: {source!r}\n")

tokens = tokenize(source)
results, errors = parse_expression_list(tokens)

print(f"মোট এক্সপ্রেশন: {len(results)}, সফল: {sum(1 for r in results if r)}, এরর: {len(errors)}\n")

print("প্রতিটি এক্সপ্রেশনের ফলাফল:")
for i, node in enumerate(results, start=1):
    if node is not None:
        print(f"  এক্সপ্রেশন {i}: মান = {evaluate(node)}")
    else:
        print(f"  এক্সপ্রেশন {i}: (এরর -- স্কিপ করা হয়েছে)")

print("\nরিপোর্ট করা এরর:")
for msg, pos in errors:
    print(f"  পজিশন {pos}-এ: {msg}")