কম্পাইলার ফেজ ওভারভিউ

১ · সোর্স কোড থেকে মেশিন কোড — পূর্ণাঙ্গ পাইপলাইন

L01-এ আমরা এই পাইপলাইনের একটি সংক্ষিপ্ত প্রিভিউ দেখেছিলাম — এখন সম্পূর্ণ নির্ভুলতার সাথে দেখা যাক। এই পাঠটি পুরো কোর্সের মানচিত্র — প্রতিটি ফেজ এই কোর্সের একটি ভবিষ্যৎ মডিউলের বিষয়বস্তু।

২ · প্রতিটি ফেজের সুনির্দিষ্ট ইনপুট ও আউটপুট

• ১. লেক্সিক্যাল অ্যানালাইসিস (M4): ইনপুট — raw ক্যারেক্টার স্ট্রিম; আউটপুট — টোকেন স্ট্রিম (L01/L16-এর টোকেনাইজার প্রিভিউ)।
• ২. সিনট্যাক্স অ্যানালাইসিস / পার্সিং (M5): ইনপুট — টোকেন স্ট্রিম; আউটপুট — পার্স ট্রি / অ্যাবস্ট্রাক্ট সিনট্যাক্স ট্রি (AST)।
• ৩. সিমান্টিক অ্যানালাইসিস (M6): ইনপুট — AST; আউটপুট — অ্যানোটেটেড/ডেকোরেটেড AST (সিম্বল টেবিল পপুলেটেড, টাইপ চেক করা, স্কোপ রেজলভড)।
• ৪. ইন্টারমিডিয়েট কোড জেনারেশন (M12/L51): ইনপুট — অ্যানোটেটেড AST; আউটপুট — একটি ইন্টারমিডিয়েট রিপ্রেজেন্টেশন (IR), সোর্স ভাষার চেয়ে সরল ও ইউনিফর্ম কিন্তু এখনও তুলনামূলক হাই-লেভেল/ মেশিন-স্বাধীন।
• ৫. কোড অপ্টিমাইজেশন (M12/L53): ইনপুট — IR; আউটপুট — উন্নত IR (সিমান্টিক্যালি সমতুল্য কিন্তু বেশি এফিশিয়েন্ট)।
• ৬. টার্গেট কোড জেনারেশন (M12/L52): ইনপুট — অপ্টিমাইজড IR; আউটপুট — একটি নির্দিষ্ট টার্গেট মেশিনের জন্য প্রকৃত মেশিন কোড বা অ্যাসেম্বলি (সরাসরি সংযোগ Computer Architecture কোর্সের ISA বিষয়বস্তুর সাথে)।

৩ · ফ্রন্ট-এন্ড বনাম ব্যাক-এন্ড

ফেজ ১-৩ কে বলা হয় ফ্রন্ট-এন্ডকম্পাইলারের ভাষা-নির্ভর অংশ — টার্গেট মেশিন থেকে সম্পূর্ণ স্বাধীন; একই ফ্রন্ট-এন্ড তাত্ত্বিকভাবে একাধিক টার্গেট মেশিন সাপোর্ট করতে পারে। — এটি ভাষা-নির্দিষ্ট, টার্গেট মেশিন থেকে স্বাধীন। ফেজ ৪-৬ কে বলা হয় ব্যাক-এন্ডকম্পাইলারের টার্গেট-মেশিন-নির্দিষ্ট অংশ — সোর্স ভাষার সিনট্যাক্স থেকে সম্পূর্ণ স্বাধীন; একই ব্যাক-এন্ড তাত্ত্বিকভাবে একাধিক সোর্স ভাষা সাপোর্ট করতে পারে। — এটি টার্গেট-মেশিন-নির্দিষ্ট, সোর্স ভাষার সিনট্যাক্স থেকে স্বাধীন। এই ফ্রন্ট-এন্ড/ব্যাক-এন্ড বিভাজনের কারণেই বাস্তব কম্পাইলার ইনফ্রাস্ট্রাকচার (যেমন LLVM, শুধু নাম হিসেবে উল্লেখ) একাধিক সোর্স ভাষা ও একাধিক টার্গেট মেশিন সমর্থন করতে পারে — নতুন একটি ভাষা যোগ করতে শুধু একটি নতুন ফ্রন্ট-এন্ড লিখলেই চলে, বিদ্যমান ব্যাক-এন্ডগুলো পুনর্ব্যবহার করা যায়, এবং উল্টোভাবেও।

৪ · কোডে সম্পূর্ণ পাইপলাইন চেইন করা

নিচের কোড সেলে একটি CompilerPipeline ক্লাস ছয়টি ফেজকেই চেইন করে চালায় — প্রতিটি ফেজ একটি সরল ডেটা স্ট্রাকচারকে (স্ট্রিং → টোকেন লিস্ট → নেস্টেড টাপল ট্রি → অ্যানোটেটেড টাপল → ইনস্ট্রাকশন লিস্ট → ছোট অপ্টিমাইজড লিস্ট → চূড়ান্ত মেশিন-কোড স্ট্রিং) রূপান্তর করে ও লগ করে।

# একটি টয় ইনপুট, ছয়টি ফেজের মধ্য দিয়ে ধাপে ধাপে চালানো হচ্ছে
class CompilerPipeline:
    def __init__(self):
        self.log = []

    def lexical_analysis(self, source):
        tokens = source.split()  # সরল -- স্পেস দিয়ে ভাগ (প্রকৃত লেক্সার M4-এ)
        self.log.append(("১. লেক্সিক্যাল অ্যানালাইসিস", tokens))
        return tokens

    def syntax_analysis(self, tokens):
        # ধরে নিচ্ছি ইনপুট সবসময় "operand op operand" প্যাটার্নের -- একটি নেস্টেড টাপল "ট্রি"
        tree = (tokens[1], tokens[0], tokens[2])
        self.log.append(("২. পার্সিং (সিনট্যাক্স অ্যানালাইসিস)", tree))
        return tree

    def semantic_analysis(self, tree):
        op, left, right = tree
        annotated = (op, left, "int", right, "int")  # টাইপ অ্যানোটেশন যোগ হলো
        self.log.append(("৩. সিমান্টিক অ্যানালাইসিস", annotated))
        return annotated

    def intermediate_code_generation(self, annotated):
        op, left, ltype, right, rtype = annotated
        ir = [f"LOAD {left}", f"LOAD {right}", f"{op.upper()} "]
        self.log.append(("৪. ইন্টারমিডিয়েট কোড জেনারেশন", ir))
        return ir

    def code_optimization(self, ir):
        # টয় অপ্টিমাইজেশন -- LOAD+LOAD+OP তিনটি ইনস্ট্রাকশনকে একটি COMPUTE-এ মার্জ করা হলো
        operand_a = ir[0].split()[1]
        operand_b = ir[1].split()[1]
        operator = ir[2].strip()
        optimized = [f"COMPUTE {operand_a} {operator} {operand_b}"]
        self.log.append(("৫. কোড অপ্টিমাইজেশন", optimized))
        return optimized

    def target_code_generation(self, optimized):
        machine_code = f"MOV R1, {optimized[0]}"
        self.log.append(("৬. টার্গেট কোড জেনারেশন", machine_code))
        return machine_code

    def run(self, source):
        tokens = self.lexical_analysis(source)
        tree = self.syntax_analysis(tokens)
        annotated = self.semantic_analysis(tree)
        ir = self.intermediate_code_generation(annotated)
        optimized = self.code_optimization(ir)
        machine_code = self.target_code_generation(optimized)
        return machine_code

pipeline = CompilerPipeline()
source = "a + b"
print(f"সোর্স ইনপুট: {source!r}\n")
result = pipeline.run(source)

for phase_name, output in pipeline.log:
    print(f"{phase_name}:")
    print(f"  {output}\n")

print(f"চূড়ান্ত আউটপুট (টার্গেট মেশিন কোড): {result}")