সরাসরি পর্বে যান
পর্ব ২৭ · ৮৬-এর মধ্যে · মডিউল ৫

Control flow — selection, iteration, goto আর structured programming

Control Flow — Selection, Iteration, goto and Structured Programming

Taught in Bangla, this lesson shows that every control structure ends as jumps. It writes big-step rules for if and while, lowers them with backpatching in in-page Python and runs the result, and explains dangling else. Real Clang -O2 output shows one switch as a comparison chain, a jump table and a lookup table, with C fall-through as a trap. It covers loops, the for-to-while continue trap, Python and JavaScript iterator protocols, break and continue added to Haat, and where goto remains valid.

এই পর্বে যা শিখবেন

  • if আর while-এর অর্থ নিয়মে (big-step rule) লেখা, আর compiler কীভাবে backpatching দিয়ে তাদের লাফে নামায় তা হাতে চালানো
  • Dangling else কোন ভাষা কীভাবে মেটায়, আর switch-এর fall-through, jump table ও lookup table সত্যিকারের Clang-এ চেনা
  • Counter-controlled আর logic-controlled loop, C-র for-কে while-এ নামানোর ফাঁদ, আর for-each-এর iterator protocol
  • break, continue আর labelled break-এর অর্থ ও বাস্তবায়ন, Haat-এর বর্ধিত রূপে এদের যোগ করা
  • goto কোথায় এখনো বৈধ, আর structured কোড কেন compiler-এর জন্যও ভালো

১ · Control flow — পর্ব ০৭-এর পরে কী বাকি

রিকশায় করে বাজারঘরের অর্ডার পৌঁছাতে বেরিয়েছেন একজন ডেলিভারিকর্মী। হাতে একটি তালিকা: “মোড়ে পৌঁছে দেখুন, রাস্তা খোলা থাকলে ডানে, নইলে বাঁয়ে।” “ঝুড়িতে পার্সেল থাকা পর্যন্ত পরের ঠিকানায় যান।” “কোনো বাড়িতে তালা থাকলে বাকি গলি বাদ দিয়ে পরের গলিতে যান।” প্রথমটি নির্বাচন, দ্বিতীয়টি পুনরাবৃত্তি, তৃতীয়টি loop থেকে আগেভাগে বেরোনো। Program-এ কোন নির্দেশের পর কোনটি চলবে, তার পুরো ব্যবস্থার নাম control flow.

পর্ব ০৭-এ (Imperative আর procedural programming) গল্পের প্রথম অর্ধেক দেখেছেন: goto থেকে structured programming, Böhm–Jacopini-এর ফল (ক্রম, নির্বাচন আর পুনরাবৃত্তিই যথেষ্ট), Dijkstra-র ১৯৬৮ সালের চিঠি, আর Haat-এর একটি while-এর bytecode. সেগুলো এখানে আর বলা হবে না। এই পর্বে তিনটি নতুন প্রশ্ন:

  1. অর্থ: প্রতিটি গঠনের নিখুঁত অর্থ কী? else কোন if-এর, switch-এ break না থাকলে কী হয়, loop-এর ভেতরে list বদলালে কী হয়?
  2. নকশা: ভাষাগুলো কেন আলাদা পথ নেয়? C-র fall-through, Python-এর for…else, Java আর JavaScript-এর labelled break, Haat-এর বাধ্যতামূলক বন্ধনী।
  3. বাস্তবায়ন: compiler প্রতিটি গঠনকে কীভাবে লাফে নামায়, আর কখন কোন কৌশল বাছে।

Haat v1-এ control flow-এর গঠন অল্প: if/else (সঙ্গে else if), while, return, আর expression-এর ভেতরে short-circuit করা && ও ||. switch, for, break, continue কিছুই নেই। ইচ্ছা করেই: ছোট core-এর বাস্তবায়ন সহজ, আর বাকিগুলো এই core-এ নামানো যায়। এই নামানোর কাজকে compiler-এর ভাষায় বলে lowering: উঁচু স্তরের গঠনকে নিচু স্তরের সরল গঠনে বদলানো, অর্থ না বদলে। নিচের ছবিতে Haat-এর দুটি মূল গঠন লাফে নামানোর পরে কেমন দেখায়:

ছবি ২৭.১ — if/else আর while, লাফে নামানোর পরে

বাক্সের সংখ্যা Haat reference-এর সত্যিকারের dis থেকে (zone.haat, অংশ ৩)

Lowered control flow: if/else as a diamond with a jump over the else branch; while as a test at the top, a body, a back edge and an exit jump if / else while km <= 3 ? 8–11 then 12–16 else 17–20 join 21 km<=10? 4–7 body 8–25 exit 26 সত্য মিথ্যা JUMP21 সত্য JUMP 4 মিথ্যা মিথ্যা-তীর = JUMP_IF_FALSE, বাকি পথ = পরের নির্দেশ
ছবি ২৭.১ — বাঁয়ে if/else-এর “হীরা”: শর্ত মিথ্যা হলে JUMP_IF_FALSE সরাসরি else-এ যায়, আর then-এর শেষে একটি JUMP else-কে ডিঙিয়ে join-এ যায়। ডানে while: শর্ত ওপরে, মিথ্যা হলে বাইরে লাফ, body-র শেষে পেছনের লাফ (back edge). এই ছবিগুলোই control-flow graph-এর সবচেয়ে ছোট টুকরো; প্রতিটি বাক্স একটি basic block.

২ · Selection — if, else if আর dangling else

নির্বাচনের সবচেয়ে সরল রূপ দুই-পথের if. বেশি পথ দরকার হলে else if-এর শিকল: ওপর থেকে নিচে প্রথম যে শর্ত সত্য, সেই শাখাটিই চলে, বাকিগুলো পরীক্ষাই হয় না। Haat reference-এর parser else if-কে আলাদা গঠন হিসেবে দেখে না: AST-তে If-এর else_ ঘরে আরেকটি If বসে (README-এর AST টেবিল)। অর্থাৎ শিকলটি আসলে nested if, শুধু লেখার সুবিধার জন্য সমতল দেখায়।

একটি else, দুটি if — কার সঙ্গে যাবে?

C-তে বন্ধনী ঐচ্ছিক। বাজারঘরের এক প্রোগ্রামার লিখলেন: অর্ডার ১০০০ টাকা বা বেশি হলে সদস্যদের ডেলিভারি ফ্রি, আর ১০০০-এর কম হলে চার্জ ৬০। Indentation দেখে মনে হয় else বাইরের if-এর। সত্যিকারের run (Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8, Windows-এ):

int total = 500, member = 0;
int fee = 0;
if (total >= 1000)
    if (member) fee = 0;
else
    fee = 60;          /* লেখকের ইচ্ছা: 1000-এর কম হলে 60 */
printf("fee = %d\n", fee);
~/cf $ zig cc -Wall -Wextra dangle.c -o dangle.exe
dangle.c:8:5: warning: add explicit braces to avoid dangling else [-Wdangling-else]
    8 |     else
      |     ^
1 warning generated.
~/cf $ ./dangle.exe
fee = 0

ফল fee = 0, ৬০ নয়। C-র নিয়মে else যায় সবচেয়ে কাছের জোড়াহীন if-এর সঙ্গে, তাই এটি আসলে if (member) … else fee = 60;, আর বাইরের শর্ত মিথ্যা বলে কিছুই চলেনি। এই সমস্যার নাম dangling else. Grammar-এর দিক থেকে এটি একটি ambiguity: একই লেখার দুটি parse tree. তত্ত্বটি গণনার তত্ত্ব কোর্সের পর্ব ২৭-এ (ambiguity), আর LR parser কেন shift বেছে নিয়ে ঠিক এই নিয়মটিই পায়, তা পর্ব ৩৯-এ (LR parsing). এখানে ভাষা নকশার দিকটি দেখি। Clang 22.1.8-এ -Wdangling-else আলাদা করে চালু করতে হয়নি; কোনো flag ছাড়া compile করেও একই warning এসেছে।

পথভাষামূল্য
নিয়ম: else কাছের if-এরC, C++, Java, JavaScriptgrammar ছোট থাকে; ফাঁদটি প্রোগ্রামারের ঘাড়ে
শাখার শেষ চিহ্ন বাধ্যতামূলকAda, Modula-2 (end if, END), shell-এর fiদ্ব্যর্থতা নেই; লেখা একটু লম্বা
বন্ধনী বাধ্যতামূলকRust, Go, Swift, Haatদ্ব্যর্থতা নেই; শর্তের চারপাশে ( ) লাগে না
Indentation-ই গঠনPythonযা দেখা যায়, তা-ই অর্থ

Haat একই কাজ লিখতে বাধ্য করে বন্ধনী দিয়ে, তাই লেখকের ইচ্ছা লেখাতেই স্পষ্ট। C-র মতো বন্ধনী ছাড়া লিখলে reference-এর parser সঙ্গে সঙ্গে থামায়: if a > 0 if b > 0 { … }-এর জন্য সত্যিকারের বার্তা 3:10: error: expected '{' after if condition. বন্ধনীসহ সঠিক রূপ (if total >= 1000 { if member { print(0); } } else { print(60); }) চালালে reference ছাপে 60. Rust আর Go-র নকশাকারেরাও একই কারণ দেখিয়েছেন: শর্তের বন্ধনী বাদ দিয়ে শাখার বন্ধনী বাধ্যতামূলক করলে লেখার খরচ প্রায় একই থাকে, অথচ একটি পুরো ভুলের শ্রেণি মুছে যায়।

পোস্ট অফিসের খামে ঠিকানা লেখার কথা ভাবুন। “বাড়ি ১২, রোড ৩” লিখে নিচে “অথবা ফেরত দিন” লিখলে কোন অংশের জন্য সেই বিকল্প, তা অস্পষ্ট। C-র নিয়ম যেন ডাকঘরের ঘোষণা: “অস্পষ্ট হলে শেষের লাইনের সঙ্গে ধরা হবে।” Haat আর Rust বলে: প্রতিটি বিকল্পের চারপাশে দাগ টানুন, তবেই খাম নেওয়া হবে।

৩ · অর্থের নিয়ম, তারপর লাফে নামানো

if আর while-এর অর্থ নিয়মে লেখা যায় operational semantics-এর big-step রূপে। ⟨s, σ⟩ ⇓ σ′ পড়ুন: “statement s-কে অবস্থা σ থেকে চালালে শেষ অবস্থা σ′”, যেখানে σ হলো program state, প্রতিটি variable-এর মান। ⟨c, σ⟩ ⇓ true মানে শর্ত c-এর মান σ-তে true. দাগের ওপরে শর্ত (premise), নিচে সিদ্ধান্ত। সরল রাখতে return আর runtime error বাদ; পূর্ণ পদ্ধতি পর্ব ৪০-এ (Operational semantics).

⟨c, σ⟩ ⇓ true    ⟨s1, σ⟩ ⇓ σ′
⟨if c {s1} else {s2}, σ⟩ ⇓ σ′
(E-IfT)
⟨c, σ⟩ ⇓ false    ⟨s2, σ⟩ ⇓ σ′
⟨if c {s1} else {s2}, σ⟩ ⇓ σ′
(E-IfF)
⟨c, σ⟩ ⇓ false
⟨while c {s}, σ⟩ ⇓ σ
(E-WhileF)
⟨c, σ⟩ ⇓ true    ⟨s, σ⟩ ⇓ σ′    ⟨while c {s}, σ′⟩ ⇓ σ″
⟨while c {s}, σ⟩ ⇓ σ″
(E-WhileT)

E-WhileT-এর দাগের ওপরে আবার সেই while-ই আছে, শুধু নতুন অবস্থা σ′ থেকে। নিয়মটি তাই বলে: while c {s} আর if c {s; while c {s}} else {} একই অর্থের। Loop যদি কখনো না থামে, তবে কোনো সসীম derivation গাছ নেই, তাই কোনো σ″-ও নেই: big-step রূপে অসীম loop মানে “ফল নেই”।

Compiler-এর কাজ — backpatching

নিয়মে সব পরিষ্কার, কিন্তু যন্ত্রে loop বা if নেই, আছে শুধু লাফ। Haat reference-এর compiler.py-র এই অংশটি (লাইন ১১৪–১৩৪) ঠিক ছবি ২৭.১-এর আকার বানায়:

        elif isinstance(s, If):
            self.expr(s.cond)
            to_else = self.emit("JUMP_IF_FALSE", None, s)
            self.stmt(s.then)
            if s.else_ is None:
                self.patch(to_else)
            elif always_returns(s.then.stmts):  # no jump needed after a return
                self.patch(to_else)
                self.stmt(s.else_)
            else:
                to_end = self.emit("JUMP", None, s)
                self.patch(to_else)
                self.stmt(s.else_)
                self.patch(to_end)
        elif isinstance(s, While):
            top = len(self.code.instrs)
            self.expr(s.cond)
            to_end = self.emit("JUMP_IF_FALSE", None, s)
            self.stmt(s.body)
            self.emit("JUMP", top, s)
            self.patch(to_end)

সমস্যাটি হলো সামনের দিকের লাফ: JUMP_IF_FALSE লেখার মুহূর্তে compiler জানে না else বা loop-এর শেষ কোথায়, কারণ সেই কোড এখনো তৈরিই হয়নি। তাই লক্ষ্যের ঘর ফাঁকা (None) রেখে নির্দেশটির index মনে রাখা হয়, আর পরে লক্ষ্য জানা হলে patch সেই ঘর ভরে দেয়। এই কৌশলের নাম backpatching. পেছনের লাফের (JUMP top) সমস্যা নেই: loop-এর শুরু আগেই দেখা হয়ে গেছে। নিচের program-এ একটি while-এর ভেতরে একটি if/else; stepper-এ দেখুন compiler কোন মুহূর্তে কী লেখে আর কোন ঘর পরে ভরে।

1var km = 2;2var paid = 0;3while km <= 10 {4    if km <= 3 {5        paid = paid + 40;6    } else {7        paid = paid + 60;8    }9    km = km + 4;10}11print(paid);
Compiler-এর খাতা
নতুন নির্দেশ
ভরা হলো
ফাঁকা ঘর
  1. while শুরু। এখন পর্যন্ত ৪টি নির্দেশ (০–৩, দুটি var), তাই top = 4 মনে রাখা হলো। শর্ত km <= 10 হলো 4–6, তারপর 7-এ JUMP_IF_FALSE, লক্ষ্য অজানা: ঘর ৭ ফাঁকা।
  2. if-এর শর্ত। body-র প্রথম statement একটি if. শর্ত 8–10, তারপর 11-এ আরেকটি ফাঁকা JUMP_IF_FALSE. এখন দুটি ঘর অপেক্ষায়।
  3. then-শাখা। paid = paid + 40 হলো 12–15. then-এর শেষে else ডিঙানোর JUMP (16), লক্ষ্য অজানা। এখন else ঠিক পরের নির্দেশ ১৭ থেকে শুরু হবে, তাই ঘর ১১ ভরা হলো ১৭ দিয়ে।
  4. else-শাখা। 17–20. else শেষ, if-ও শেষ: পরের নির্দেশ ২১ হলো join, তাই ঘর ১৬ ভরা হলো ২১ দিয়ে।
  5. body-র বাকি অংশ আর পেছনের লাফ। km = km + 4 হলো 21–24, তারপর 25-এ JUMP 4. লক্ষ্য আগে থেকেই জানা (top), তাই কিছু ফাঁকা রাখতে হলো না।
  6. loop শেষ। পরের নির্দেশ ২৬ হবে loop-এর পরের কোড, তাই ঘর ৭ ভরা হলো ২৬ দিয়ে। আর কোনো ঘর ফাঁকা নেই।
  7. বাকি program. print(paid) হলো 26–27. চারটি লাফের লক্ষ্য (7→26, 11→17, 16→21, 25→4) reference-এর সত্যিকারের python haat.py dis zone.haat-এর সঙ্গে হুবহু মেলে; reference শেষে আরও দুটি নির্দেশ (CONST (), RETURN) যোগ করে।

এবার একই কাজ নিজে চালিয়ে দেখুন। নিচের block reference-এর দুটি নাম (emit, patch) রেখে একটি ছোট compiler লেখে; AST এখানে tuple দিয়ে, যাতে কোড ছোট থাকে (পূর্ণ রূপ reference-এর compiler.py). reference-এর মতো এটি সব if-এ else-ডিঙানোর JUMP দেয়, শুধু “then-শাখা সবসময় return করে” ক্ষেত্রের ছোট optimization-টি বাদ।

# Haat-এর while আর if-কে লাফে নামানো (reference-এর compiler.py-র ছোট রূপ)
code = []                                  # [opcode, arg]-এর তালিকা
def emit(op, arg=None):
    code.append([op, arg]); return len(code) - 1
def patch(at):                             # লাফের লক্ষ্য = পরের নির্দেশ
    code[at][1] = len(code)
def expr(e):
    if e[0] == "num": emit("CONST", e[1])
    elif e[0] == "var": emit("LOAD", e[1])
    else: expr(e[1]); expr(e[2]); emit({"<=": "LE", "+": "ADD"}[e[0]])
def stmt(s):
    if s[0] == "set": expr(s[2]); emit("STORE", s[1])
    elif s[0] == "print": expr(s[1]); emit("PRINT")
    elif s[0] == "if":                     # if c { t } else { f }
        expr(s[1]); to_else = emit("JUMP_IF_FALSE")
        for t in s[2]: stmt(t)
        to_end = emit("JUMP"); patch(to_else)
        for t in s[3]: stmt(t)
        patch(to_end)
    elif s[0] == "while":                  # while c { body }
        top = len(code); expr(s[1]); to_end = emit("JUMP_IF_FALSE")
        for t in s[2]: stmt(t)
        emit("JUMP", top); patch(to_end)

km, paid = ("var", "km"), ("var", "paid")
prog = [("set", "km", ("num", 2)), ("set", "paid", ("num", 0)),
        ("while", ("<=", km, ("num", 10)), [
            ("if", ("<=", km, ("num", 3)),
                [("set", "paid", ("+", paid, ("num", 40)))],
                [("set", "paid", ("+", paid, ("num", 60)))]),
            ("set", "km", ("+", km, ("num", 4)))]),
        ("print", paid)]
for s in prog: stmt(s)
print(len(code), "instructions; jumps:",
      [(i, op, arg) for i, (op, arg) in enumerate(code) if "JUMP" in op])

আসল আউটপুট (ব্রাউজারের Python):

28 instructions; jumps: [(7, 'JUMP_IF_FALSE', 26), (11, 'JUMP_IF_FALSE', 17), (16, 'JUMP', 21), (25, 'JUMP', 4)]

চারটি লাফ stepper আর reference-এর dis-এর সঙ্গে হুবহু এক। এটি একটি ছোট differential testing: দুটি স্বাধীন বাস্তবায়ন একই উত্তর দিল। patch কতটা সরল, খেয়াল করুন: “এখন কোড যত লম্বা, সেটিই লক্ষ্য”। এটি কাজ করে কারণ লক্ষ্যটি সবসময় “ঠিক এখন পরের যে নির্দেশ আসবে”।

এবার তৈরি কোডটি চালানো যাক। পরের block আগের block-এর code তালিকাটিই নেয় (দুটি block একই namespace ভাগ করে), একটি ছোট stack VM দিয়ে চালায়, আর প্রতিটি নেওয়া লাফ লিখে রাখে।

# আগের block-এর code চালানো: একটি ছোট stack VM, সঙ্গে নেওয়া লাফের হিসাব
def run(code):
    pc, stack, env = 0, [], {}
    steps, taken = 0, []
    while pc < len(code):
        op, arg = code[pc]; here = pc; pc += 1; steps += 1
        if op == "CONST": stack.append(arg)
        elif op == "LOAD": stack.append(env[arg])
        elif op == "STORE": env[arg] = stack.pop()
        elif op in ("LE", "ADD"):
            b, a = stack.pop(), stack.pop()
            stack.append(a <= b if op == "LE" else a + b)
        elif op == "PRINT": print(stack.pop())
        elif op == "JUMP":
            pc = arg; taken.append(f"{here}->{arg}")
        elif op == "JUMP_IF_FALSE":
            if not stack.pop():
                pc = arg; taken.append(f"{here}->{arg}")
    return steps, taken

steps, taken = run(code)
print("executed:", steps, "instructions")
print("jumps taken:", " ".join(taken))

আসল আউটপুট (ব্রাউজারের Python):

160
executed: 62 instructions
jumps taken: 16->21 25->4 11->17 25->4 11->17 25->4 7->26

ফল ১৬০, reference-এর run আর vm দুটিরই সত্যিকারের উত্তরের সমান (km = 2-এ ৪০, km = 6 আর 10-এ ৬০ করে)। লাফের তালিকাটি program-এর গল্প বলে: প্রথম round-এ km = 2, তাই if-এর শর্ত সত্য, then চলে আর 16->21 else ডিঙায়; পরের দুই round-এ শর্ত মিথ্যা, তাই 11->17 সরাসরি else-এ; প্রতিটি round-এর শেষে 25->4; আর km = 14-এ 7->26 loop থেকে বের করে। JUMP_IF_FALSE যখন লাফ দেয় না (শর্ত সত্য), তখন তালিকায় আসে না, কিন্তু নির্দেশটি তবুও চলে: প্রতিটি পূর্ণ round-এ দুটি লাফের নির্দেশ চলে।

নামানো ঠিক হলো কি না — একটি প্রমাণের রূপরেখা

দাবি। ধরুন c আর s-এর কোড সঠিক: c-এর কোড σ-তে শুরু হলে stack-এ c-এর মান রেখে শেষ হয়, আর s-এর কোড σ থেকে σ′-এ নেয় (যখন ⟨s, σ⟩ ⇓ σ′)। তাহলে ⟨while c {s}, σ⟩ ⇓ σ″ হলে, while-এর কোড top-এ σ নিয়ে শুরু করে end-এ σ″ নিয়ে পৌঁছায়।

প্রমাণের রূপরেখা (derivation গাছের উচ্চতার ওপর induction):

  1. শেষ নিয়ম E-WhileF হলে: c-এর কোড false রাখে, JUMP_IF_FALSE তা তুলে end-এ লাফ দেয়; কোনো variable বদলায়নি, তাই অবস্থা σ, যা নিয়মের ফলের সমান।
  2. শেষ নিয়ম E-WhileT হলে: c-এর কোড true রাখে, লাফ হয় না, s-এর কোড শুরু হয় σ নিয়ে আর ধরে নেওয়া শর্তে শেষ হয় σ′ নিয়ে।
  3. তারপর JUMP top আবার শুরুতে নেয়, এবার σ′ নিয়ে। ⟨while c {s}, σ′⟩ ⇓ σ″-এর derivation গাছটি ছোট, তাই induction-এর অনুমানে কোডটি end-এ σ″ নিয়ে পৌঁছায়। ∎

উল্টো দিকও সত্য: loop না থামলে কোডও end-এ পৌঁছায় না। একই কাঠামোর যুক্তি if-এর জন্যও খাটে। বাস্তব compiler-এর প্রমাণিত সংস্করণ, যেমন CompCert, এই ধরনের উপপাদ্য যন্ত্রে যাচাই করে (পর্ব ৪৪-এ)।

৪ · switch — অর্থ, fall-through আর তিন রকম বাস্তবায়ন

বহু-পথের নির্বাচনের আরেক রূপ switch statement: একটি মান একবার হিসাব হয়, আর মিলে যাওয়া case-এ লাফ। C, C++ আর পুরোনো Java-তে case আসলে একটি label, block নয়। তাই একটি case-এর কাজ শেষে break না থাকলে নিয়ন্ত্রণ পরের case-এর কোডে গড়িয়ে যায়: fall-through. সত্যিকারের run (Clang 22.1.8):

for (int zone = 1; zone <= 3; zone++) {
    int fee = 0;
    switch (zone) {
    case 1: fee += 40;          /* break ভুলে গেছেন */
    case 2: fee += 20; break;
    case 3: fee = 120; break;
    }
    printf("zone %d: fee %d\n", zone, fee);
}
~/cf $ zig cc -Wall -Wextra fall.c -o fall2.exe        (কোনো warning নেই)
~/cf $ zig cc -Wall -Wextra -Wimplicit-fallthrough fall.c -o fall.exe
fall.c:8:9: warning: unannotated fall-through between switch labels [-Wimplicit-fallthrough]
fall.c:8:9: note: insert '__attribute__((fallthrough));' to silence this warning
fall.c:8:9: note: insert 'break;' to avoid fall-through
~/cf $ ./fall.exe
zone 1: fee 60
zone 2: fee 20
zone 3: fee 120

zone 1-এর চার্জ ৪০ হওয়ার কথা, হলো ৬০: case 1-এর পরে case 2-এর fee += 20-ও চলেছে। লক্ষ্য করুন, এই Clang-এ -Wall -Wextra-ও চুপ ছিল; warning এসেছে শুধু -Wimplicit-fallthrough আলাদা করে দিলে (note-এর লাইনগুলোর নিচের কোড-চিহ্নিত অংশ এখানে বাদ)। ইচ্ছাকৃত fall-through চিহ্নিত করতে C23 আর C++17-এ [[fallthrough]]; লেখা যায়; -std=c23 দিলে এই Clang note-এ সেটিই প্রস্তাব করে।

পরের ভাষাগুলো এই ফাঁদ নানাভাবে বন্ধ করেছে। C#-এ কোনো case-এর কোড থেকে পরের case-এ গড়িয়ে যাওয়া compile error; Go আর Swift-এ গড়িয়ে যাওয়া হয় না, চাইলে fallthrough লিখতে হয়; Java 14 থেকে স্থায়ী arrow-রূপ case 1 -> …-এ fall-through নেই, আর switch একটি মানও দিতে পারে। Python দীর্ঘদিন switch রাখেনি (২০০৬ সালে PEP 3103 প্রত্যাখ্যাত), পরে Python 3.10-এ match এসেছে, যা আসলে pattern matching (পর্ব ২৪)। C-র switch আর ভাষাভেদে এর বাক্যগঠন C কোর্সের পর্ব ১১-এ আর Java কোর্সের পর্ব ১০-এ.

সত্যিকারের Clang -O2 — একই switch, তিন রকম যন্ত্রকোড

switch-কে compiler কীভাবে নামাবে, তা নির্ভর করে case-এর মানগুলো কতটা ঘন আর প্রতিটি case কী করে তার ওপর। তিনটি function এক ফাইলে লিখে x86-64 Linux-এর জন্য compile করা হলো (সত্যিকারের run: zig cc --target=x86_64-linux-gnu -O2 -g0 -S -masm=intel, Clang 22.1.8; .cfi directive আর কিছু register-সংরক্ষণের লাইন বাদ)।

int step(int s, int id) {          /* ঘন: 0..5, প্রতিটি আলাদা কাজ */
    switch (s) {
    case 0: return pack(id);   case 1: return wrap(id);
    case 2: return ship(id);   case 3: return hold(id);
    case 4: return drop(id);   case 5: return pack(id) + ship(id);
    default: return log_other(id);
    }
}
int zone_fee(int zone) {           /* ঘন: 0..5, প্রতিটি শুধু ধ্রুবক */
    switch (zone) {
    case 0: return 40;  case 1: return 60;  case 2: return 60;
    case 3: return 90;  case 4: return 120; case 5: return 150;
    default: return -1;
    }
}
int promo(int code, int id) {      /* পাতলা: 7, 120, 1500, 20000, 90000 */
    switch (code) { case 7: return pack(id); /* … বাকি চারটি … */ }
}
step:
        cmp     edi, 5
        ja      .LBB0_8                  # default
        mov     eax, edi
        lea     rcx, [rip + .LJTI0_0]
        movsxd  rax, dword ptr [rcx + 4*rax]
        add     rax, rcx
        jmp     rax
.LBB0_5:                                 # case 3
        mov     edi, ebx
        …
        jmp     hold@PLT                 # TAILCALL
.LJTI0_0:
        .long   .LBB0_2-.LJTI0_0         # 0: pack
        .long   .LBB0_3-.LJTI0_0         # 1: wrap
        .long   .LBB0_4-.LJTI0_0         # 2: ship
        .long   .LBB0_5-.LJTI0_0         # 3: hold
        .long   .LBB0_6-.LJTI0_0         # 4: drop
        .long   .LBB0_7-.LJTI0_0         # 5: pack + ship
zone_fee:
        mov     eax, -1
        cmp     edi, 5
        ja      .LBB1_2
        mov     eax, edi
        lea     rcx, [rip + .Lswitch.table.zone_fee]
        mov     eax, dword ptr [rcx + 4*rax]
.LBB1_2:
        ret
.Lswitch.table.zone_fee:
        .long   40
        .long   60
        .long   60
        .long   90
        .long   120
        .long   150
promo:
        cmp     edi, 1499
        jle     .LBB2_1
        cmp     edi, 1500
        je      .LBB2_9
        cmp     edi, 20000
        je      .LBB2_10
        cmp     edi, 90000
        jne     .LBB2_11
        mov     edi, esi
        jmp     drop@PLT                 # TAILCALL
.LBB2_1:
        cmp     edi, 7
        je      .LBB2_8
        cmp     edi, 120
        jne     .LBB2_11
        …

তিনটি কৌশল:

  • Jump table (step): মেমরিতে প্রতিটি case-এর কোডের ঠিকানার একটি টেবিল (.LJTI0_0), মান দিয়ে index করে ঠিকানা পড়া, তারপর jmp rax, যা একটি indirect jump. case যতই থাকুক, খরচ একই।
  • Lookup table (zone_fee): প্রতিটি case শুধু একটি ধ্রুবক দেয়, তাই ঠিকানার বদলে সরাসরি মানগুলোর টেবিল। কোনো লাফই নেই, শুধু একটি মেমরি পড়া। LLVM-এ এই রূপান্তর হয় IR-এর স্তরেই, টেবিলের নাম switch.table থেকে বোঝা যায়।
  • তুলনার গাছ (promo): মানগুলো দূরে দূরে, টেবিল বানালে ৯০০০০টি ঘরের প্রায় সবই default হতো। Compiler তাই প্রথমে মাঝখানে ভাগ করে (cmp edi, 1499), তারপর প্রতিটি অর্ধেকে সরাসরি তুলনা: binary search-এর মতো, n-টি case-এ মোটামুটি log n তুলনা।

কখন টেবিল? এই Clang-এ ছোট পরীক্ষা চালিয়ে দেখা গেল (প্রতিটি case আলাদা function ডাকে): ৩টি case (0, 1, 2)-এ টেবিল হয়নি, ৪টিতে (0..3) হয়েছে; 0, 10, 20, 30 (৩১ ঘরে ৪টি case, প্রায় ১৩%)-এ -O2-তে টেবিল হয়েছে কিন্তু -Os-এ হয়নি; 0, 25, 50, 75-এ (৭৬ ঘরে ৪টি, প্রায় ৫%) কোনোটিতেই হয়নি। এটি LLVM-এর পরিচিত দুটি সীমার সঙ্গে মেলে: অন্তত ৪টি case, আর ঘনত্ব সাধারণ optimization-এ অন্তত ১০%, আকার কমানোর (-Os) সময় ৪০%; সংখ্যাগুলো LLVM-এর version ভেদে বদলাতে পারে, আর GCC-র নিজের হিসাব আছে। case-এর মান ১০০ থেকে শুরু হলে compiler আগে ১০০ বিয়োগ করে নেয় (সত্যিকারের আউটপুটে add edi, -100), তারপর একই টেবিল।

নিচের stepper-এ step(3, id) আর step(-1, id)-এর পথ ধরে ধরে দেখুন। বিশেষভাবে খেয়াল করুন সীমা পরীক্ষাটি: একটিমাত্র তুলনায় “0-এর কম” আর “5-এর বেশি” দুটিই ধরা হয়।

1cmp    edi, 52ja     .LBB0_8      # default3mov    eax, edi4lea    rcx, [rip + .LJTI0_0]5movsxd rax, [rcx + 4*rax]6add    rax, rcx7jmp    rax
Register-এর অবস্থা
edi (s)
rcx
rax
  1. সীমা পরীক্ষা। cmp edi, 5 মান ৩-কে ৫-এর সঙ্গে তুলনা করে। পরের ja (jump if above) তুলনাটিকে unsigned হিসেবে পড়ে; এটিই এই কৌশলের চাবি।
  2. default নয়। 3 > 5 মিথ্যা, তাই ja লাফ দেয় না। এখন নিশ্চিত যে মানটি 0..5-এর মধ্যে, টেবিলের বাইরে পড়ার ভয় নেই।
  3. Index আর টেবিল। eax-এ index 3, rcx-এ টেবিল .LJTI0_0-এর ঠিকানা (ধরুন T). rip-ভিত্তিক ঠিকানা মানে program যেখানেই load হোক, কোড কাজ করবে।
  4. টেবিল পড়া। প্রতিটি ঘর ৪ byte, তাই ঠিকানা T + 4 × 3. ঘরে আছে .LBB0_5 - .LJTI0_0: পূর্ণ ঠিকানা নয়, টেবিল থেকে দূরত্ব। movsxd সেটিকে চিহ্নসহ ৬৪ বিটে বড় করে।
  5. পূর্ণ ঠিকানা। দূরত্বের সঙ্গে T যোগ করলে case 3-এর কোডের আসল ঠিকানা .LBB0_5.
  6. লাফ। jmp rax: register থেকে ঠিকানা নিয়ে লাফ। .LBB0_5-এ hold ডাকা হয় jmp দিয়ে (Clang-এর মন্তব্যে TAILCALL), কারণ এটিই function-এর শেষ কাজ; এর বিস্তার পর্ব ৩২-এ (Recursion আর tail call).
  7. s = -1 হলে। -1-এর বিট-রূপ 0xFFFFFFFF; unsigned হিসেবে এটি 4294967295, যা ৫-এর চেয়ে বড়। তাই একই ja default-এ পাঠায়। একটি তুলনাতেই দুই দিকের সীমা পরীক্ষা হলো; RISC-V-তে একই কাজ করে bltu (সত্যিকারের riscv64 আউটপুটেও তা-ই)।

Hardware-এর দিক থেকে jump table, indirect jump আর তাদের branch prediction-এর খরচ Computer Architecture কোর্সের পর্ব ২৯-এ RISC-V দিয়ে আছে; এখানে আমরা দেখলাম ভাষার একটি গঠন থেকে compiler কীভাবে বাছাই করে।

৫ · Iteration — গোনা loop, শর্তের loop আর for-এর আসল অর্থ

পুনরাবৃত্তির নকশায় ভাষাগুলো দুটি প্রশ্নের উত্তর দেয়: কতবার ঘুরবে, তা কে ঠিক করে? আর শর্ত পরীক্ষা হয় কোথায়?

গুনে ঘোরা

Counter-controlled loop: একটি গণক শুরু থেকে শেষ পর্যন্ত যায়। FORTRAN-এর DO, Pascal আর Ada-র for i in 1..n. অনেক ভাষায় কতবার ঘুরবে তা শুরুতেই একবার হিসাব হয়, আর body-তে গণক বদলানো নিষেধ।

Ada, Pascal, Python-এর range

শর্তে ঘোরা

Logic-controlled loop: প্রতিবার একটি শর্ত পরীক্ষা। শর্ত ওপরে (pre-test, while) হলে body শূন্যবারও চলতে পারে; নিচে (post-test, C-র do … while) হলে অন্তত একবার।

Haat-এর while, C-র do-while

Python-এর for i in range(n) গোনা loop-এর মতো আচরণ করে, কারণ range(n) একবারই তৈরি হয়: body-তে n = 10 লিখলেও ঘোরা তিনবারই (অংশ ৬-এর block-এর শেষ লাইন)। C-র for (init; cond; step) নামে গোনা loop হলেও আসলে শর্তের loop: শর্ত প্রতিবার নতুন করে হিসাব হয়, আর body-তে i বা সীমা বদলালে ঘোরার সংখ্যাও বদলায়। Rust আবার loop-কে expression বানিয়েছে: let x = loop { … break value; };, যেখানে break-এর সঙ্গে দেওয়া মানটিই loop-এর মান।

for-কে while-এ নামানো — continue-এর ফাঁদ

পাঠ্যবইয়ে প্রায়ই লেখা থাকে for (init; cond; step) body মানে init; while (cond) { body; step; }. প্রায় ঠিক, কিন্তু body-তে continue থাকলে নয়। C-তে for-এর continue লাফ দেয় step-এ, অথচ ওপরের while-রূপে continue step-কে ডিঙিয়ে সরাসরি শর্তে যায়। সত্যিকারের run (Clang 22.1.8, ভুল রূপে একটি পাহারা-গণক বসিয়ে, যাতে program আটকে না থাকে):

~/cf $ ./fd.exe
0 1 3 4 | for
0 1 stuck: i = 2 | naive while

সঠিক নামানো: continue যেন step-এর ঠিক আগের একটি label-এ লাফ দেয়, init; while (cond) { body′; next: step; }, যেখানে body′ মানে body-র প্রতিটি continue-এর জায়গায় goto next. compiler-এর কাছে এটি স্বাভাবিক: সে loop ধরে রাখে দুটি label দিয়ে, “continue কোথায় যাবে” আর “break কোথায় যাবে”। পূর্ণ সমাধান অনুশীলন ২-এ। এই ধরনের নামানো, যেখানে বড় ভাষার গঠন ছোট core-এ বদলায়, তার সাধারণ নাম desugaring; পর্ব ৫৫-এ (Desugaring আর lowering) এর বিস্তার।

while কত লাফ খায়? Haat-এর নামানোয় প্রতিটি পূর্ণ round-এ দুটি লাফের নির্দেশ চলে: ওপরের JUMP_IF_FALSE (না নিলেও চলে) আর নিচের JUMP. অনেক optimizing compiler loop-কে উল্টে সাজায়: শুরুতে একবার পাহারা-পরীক্ষা, আর শর্ত নিচে, যাতে প্রতি round-এ একটিই শর্তসহ লাফ থাকে। এর নাম loop rotation; RISC-V assembly-তে এর রূপ Computer Architecture কোর্সের পর্ব ২৯-এ, আর loop optimization-এর পূর্ণ আলোচনা পর্ব ৬৬-এ।

৬ · for-each আর iterator protocol

আধুনিক ভাষায় সবচেয়ে বেশি লেখা loop হলো for-each: “এই সংগ্রহের প্রতিটি জিনিসের জন্য”। Index নেই, সীমা নেই, তাই off-by-one ভুলের সুযোগও নেই। কিন্তু loop জানে কীভাবে, পরের জিনিস কোনটি? উত্তর: সংগ্রহের সঙ্গে loop-এর একটি চুক্তি, যার নাম iterator protocol. বাজারের ফর্দের কথা ভাবুন: দোকানি ফর্দ হাতে নিয়ে একটি পেনসিলের দাগ রাখেন কোন জিনিস পর্যন্ত দেওয়া হলো। ফর্দটি সংগ্রহ, পেনসিলের দাগটি iterator.

ভাষাloop শুরুতেপ্রতি round-এশেষের সংকেত
Python (PEP 234, ২০০১)iter(xs)next(it)StopIteration exception
JavaScript (ES2015)xs[Symbol.iterator]()it.next() → {value, done}done: true
Java (Java 5, ২০০৪)xs.iterator()hasNext(), তারপর next()hasNext() false
C++11 range-forbegin(xs), end(xs)*it, তারপর ++itit == end

Java-র বর্ণনা ভাষার specification (JLS-এর enhanced for)-এ এভাবেই লেখা: Iterable-এর জন্য একটি লুকানো iterator variable আর hasNext-এর শর্তে একটি সাধারণ for loop; array হলে একটি index loop. Python-এর for item in cart:-এর desugared রূপ ধাপে ধাপে:

1it = iter(cart)2while True:3    try: item = next(it)4    except StopIteration: break5    print("body:", item)
অবস্থা
it.i
item
  1. শুরুতে একবার। iter(cart) ঝুড়ির __iter__ ডাকে, ফেরত আসে একটি নতুন iterator, যার গণক i = 0. ঝুড়ি নিজে বদলায় না; অবস্থা থাকে iterator-এ।
  2. প্রথম next. next(it) দেয় 'chal', গণক 1. মান বসল loop variable item-এ।
  3. Body. body চলে item = 'chal' নিয়ে।
  4. আবার next. 'dal', গণক 2.
  5. Body. body: dal.
  6. শেষের সংকেত। গণক 2 = তালিকার দৈর্ঘ্য, তাই __next__ StopIteration তোলে। এটি ভুল নয়, স্বাভাবিক শেষের সংকেত।
  7. Loop শেষ। desugared রূপে except সেটি ধরে break করে। আসল for-এ CPython-এর FOR_ITER নির্দেশ ভেতরেই এই কাজ করে, কোনো exception object সাধারণত তৈরিই হয় না (নিচের dis দেখুন)।

নিচের block-এ দুটি রূপ পাশাপাশি চলে, প্রতিটি ডাক ছাপা হয়। শেষে দুটি পরিচিত বিস্ময়: loop চলার সময় list থেকে মুছে ফেলা, আর range-এর সীমা বদলানো।

# for-each আসলে iterator protocol-এর ডাক: __iter__ একবার, __next__ বারবার
class Cart:                                # বাজারঘরের ঝুড়ি
    def __init__(self, items): self.items = items
    def __iter__(self):
        print("  iter()")
        return CartIter(self.items)
class CartIter:
    def __init__(self, items): self.items, self.i = items, 0
    def __next__(self):
        if self.i == len(self.items):
            print("  next() -> StopIteration"); raise StopIteration
        x = self.items[self.i]; self.i += 1
        print(f"  next() -> {x!r}"); return x
cart = Cart(["chal", "dal"])
print("for item in cart:")
for item in cart:
    print("    body:", item)

print("desugared:")
it = iter(cart)                            # for-এর প্রথম কাজ
while True:
    try:
        item = next(it)
    except StopIteration:
        break
    print("    body:", item)

xs = [2, 4, 6, 7]                          # loop চলার সময় list বদলালে
for x in xs:
    if x % 2 == 0: xs.remove(x)
print("after removing evens:", xs)
n = 3
for i in range(n): n = 10                  # range একবারই হিসাব হয়
print("i =", i, " n =", n)

আসল আউটপুট (ব্রাউজারের Python):

for item in cart:
  iter()
  next() -> 'chal'
    body: chal
  next() -> 'dal'
    body: dal
  next() -> StopIteration
desugared:
  iter()
  next() -> 'chal'
    body: chal
  next() -> 'dal'
    body: dal
  next() -> StopIteration
after removing evens: [4, 7]
i = 2  n = 10

দুই রূপের ডাকের ক্রম হুবহু এক: for-each সত্যিই এই চুক্তির ওপর একটি পাতলা আবরণ। তারপর বিস্ময় ১: জোড় সংখ্যা মুছতে গিয়ে 4 রয়ে গেল। list-এর iterator শুধু একটি index রাখে; 2 মোছার পরে সবাই এক ঘর বাঁয়ে সরে, index 1-এ এখন 6, তাই 4 ডিঙিয়ে যায়। Python এটি নিষেধ করে না, কিন্তু dict-এর ক্ষেত্রে আকার বদলালে RuntimeError দেয়; Java-র অনেক collection তখন ConcurrentModificationException দেয়। বিস্ময় ২: n = 10 করেও loop তিনবারই ঘুরেছে, কারণ range(3) শুরুতেই তৈরি।

CPython 3.14.4-এর নিজের dis (সত্যিকারের run) দেখায় for-each কোন নির্দেশে নামে:

def total(cart):
    s = 0
    for q in cart:
        s = s + q
    return s

  4           LOAD_FAST_BORROW         0 (cart)
              GET_ITER
      L1:     FOR_ITER                11 (to L2)
              STORE_FAST               2 (q)
  5           LOAD_FAST_BORROW_LOAD_FAST_BORROW 18 (s, q)
              BINARY_OP                0 (+)
              STORE_FAST               1 (s)
              JUMP_BACKWARD           13 (to L1)
  4   L2:     END_FOR
              POP_ITER

GET_ITER হলো iter(), আর FOR_ITER একসাথে দুটি কাজ করে: next() ডাকে, আর জিনিস ফুরালে L2-তে লাফ দেয়। অর্থাৎ Haat-এর JUMP_IF_FALSE-এর জায়গায় এখানে “পরের জিনিস না থাকলে লাফ”। JUMP_BACKWARD ঠিক Haat-এর JUMP top. Python-এ generator দিয়ে iterator লেখা অনেক সহজ, যার ভেতরের কৌশল পর্ব ৩১-এ (Generator, coroutine আর async/await); Python-এর দিক থেকে পূর্ণ আলোচনা Python কোর্সের পর্ব ৩৬-এ, আর JavaScript-এর JavaScript কোর্সের পর্ব ২৭-এ.

৭ · break, continue, labelled break আর goto

break সবচেয়ে ভেতরের loop (বা switch) থামিয়ে তার পরে নিয়ে যায়; continue এই round-এর বাকি অংশ বাদ দিয়ে পরের round-এ নেয়। দুটিই আসলে নির্দিষ্ট গন্তব্যের goto, তাই structured programming-এর “এক প্রবেশ, এক প্রস্থান” নিয়ম একটু শিথিল করে। কিন্তু গন্তব্য সবসময় loop-এর সীমানায়, তাই কোড পড়া কঠিন হয় না।

দুই স্তরের loop-এ ভেতর থেকে বাইরের loop থামাতে C-তে লাগে একটি flag বা goto. Java আর JavaScript দেয় labelled break আর continue: loop-এর সামনে একটি নাম, তারপর break name; বা continue name;. Rust-এ একই কাজ 'outer: দিয়ে। Python-এ label নেই; পথ হলো function থেকে return, flag, অথবা loop else: for … else-এর else অংশ চলে শুধু loop break ছাড়া শেষ হলে।

break-এর একটি সূক্ষ্ম দিক for-each-এর সঙ্গে জড়িত। iterator যদি কোনো resource (ফাইল, network সংযোগ) ধরে রাখে, তবে loop আগেভাগে থামলে কে সেটি বন্ধ করবে? JavaScript-এর চুক্তিতে উত্তর আছে: break হলে for…of নিজেই iterator-এর ঐচ্ছিক return() method ডাকে। নিচে দুটিই চালিয়ে দেখুন:

// for...of = [Symbol.iterator]() একবার, তারপর next() বারবার
const cart = {
  items: ["chal", "dal", "tel"],
  [Symbol.iterator]() {
    let i = 0;
    const items = this.items;
    console.log("[Symbol.iterator]()");
    return {
      next() {
        const r = i < items.length ? { value: items[i++], done: false }
                                   : { value: undefined, done: true };
        console.log("next() ->", JSON.stringify(r));
        return r;
      },
      return() {                      // break হলে loop নিজেই এটি ডাকে
        console.log("return() called");
        return { done: true };
      },
    };
  },
};
for (const x of cart) {
  if (x === "dal") break;
  console.log("  body:", x);
}
// labelled continue/break: ভেতরের loop থেকে বাইরের loop-কে নির্দেশ
const shelves = [[5, 0, 7], [3, 4, 2], [1, 9, 0]];   // প্রতি তাকে মজুদ
shelf: for (let s = 0; s < shelves.length; s++) {
  for (let k = 0; k < shelves[s].length; k++) {
    const q = shelves[s][k];
    if (q === 0) { console.log(`shelf ${s}: empty slot ${k}`); continue shelf; }
    if (q > 8) { console.log(`shelf ${s}: overstock, stop`); break shelf; }
  }
  console.log(`shelf ${s}: ok`);
}

আসল আউটপুট (ব্রাউজারের JavaScript; লেখকের Node 24.15.0-এও একই):

[Symbol.iterator]()
next() -> {"value":"chal","done":false}
  body: chal
next() -> {"value":"dal","done":false}
return() called
shelf 0: empty slot 1
shelf 1: ok
shelf 2: overstock, stop

প্রথম অংশে "dal" পাওয়ার পরে break, আর সঙ্গে সঙ্গে return() called: ভাষা নিজে iterator-কে “আর লাগবে না” জানিয়ে দিল। tel-এর জন্য next() আর ডাকাই হয়নি। দ্বিতীয় অংশে তাক ০-এর ঘর ১ খালি, তাই continue shelf ভেতরের loop-এর বাকি ঘর (৭) বাদ দিয়ে সরাসরি তাক ১-এ গেল; সেজন্য “shelf 0: ok” ছাপা হয়নি। তাক ১ পুরোটা ঠিক। তাক ২-এ ৯ পেয়ে break shelf দুটি loop-ই একসাথে থামাল, শেষ ঘরের ০ দেখাই হয়নি। Python-এ generator-এর ক্ষেত্রে একই ভূমিকা নেয় close(), আর with statement; exception-এর পথে resource ছাড়ার পূর্ণ গল্প পর্ব ২৮-এ।

Haat-এর বর্ধিত রূপ — break আর continue যোগ করা

Haat v1-এ break নেই; লিখলে reference শব্দটিকে একটি নাম ভাবে; while true { … }-এর ভেতরে চতুর্থ লাইনে if i == 3 { break; } লিখে চালালে সত্যিকারের বার্তা আসে 4:17: error: undefined variable 'break' (README-এর সিদ্ধান্ত ৬-এর মতোই, keyword-এর তালিকায় যা নেই তা সাধারণ নাম)। যোগ করতে চাইলে lexer-এ দুটি keyword, parser-এ দুটি statement, আর compiler-এ একটি নতুন জিনিস লাগে: খোলা loop-গুলোর একটি stack. প্রতিটি loop মনে রাখে নিজের শুরু (continue-এর গন্তব্য) আর এমন break-গুলোর তালিকা, যাদের লক্ষ্য loop শেষ হলে ভরা হবে। Loop-এর বাইরে break হলে নতুন error, reference-এর ধাঁচে: 'break' outside of a loop. নিচের stepper-এ একটি প্রস্তাবিত compiler (লেখকের Python খসড়া, অনুশীলন ১-এ পুরো কোড) এই program নামাচ্ছে:

1var i = 0;2while i < 6 {3    i = i + 1;4    if i == 2 { continue; }5    if i == 4 { break; }6    print(i);7}8print(i);
Compiler-এর খাতা
নতুন নির্দেশ
loop stack
ভরা হলো
  1. Loop খোলা। top = 2; শর্ত 2–4, 5-এ ফাঁকা JUMP_IF_FALSE. stack-এ এই loop-এর একটি খাতা: শুরু 2, break-এর তালিকা খালি।
  2. সাধারণ কাজ। i = i + 1 হলো 6–9; loop stack-এর কিছু বদলায় না।
  3. continue. if-এর শর্ত 10–12, ফাঁকা লাফ 13. ভেতরের continue stack-এর ওপরের loop-এর শুরু পড়ে নেয়: JUMP 2 (14), কোনো ফাঁকা ঘর ছাড়াই। if শেষ, তাই 13 ভরা হলো 15 দিয়ে।
  4. break. শর্ত 15–17, ফাঁকা লাফ 18. break লেখে JUMP ? (19), কারণ loop-এর শেষ এখনো অজানা; index 19 ঢুকল loop-এর break-তালিকায়। 18 ভরা হলো 20 দিয়ে।
  5. Loop-এর শেষ। print 20–21, পেছনের লাফ JUMP 2 (22). এখন loop-এর পরের নির্দেশ 23, তাই শর্ত-মিথ্যার লাফ 5 ভরা হলো 23 দিয়ে।
  6. Loop বন্ধ। stack থেকে খাতাটি তুলে তার প্রতিটি break (এখানে 19) ভরা হলো 23 দিয়ে। nested loop হলে প্রতিটি break নিজের loop-এর খাতায় থাকে, তাই কখনো ভুল loop-এ যায় না।
  7. চালানো। 23–24 শেষের print. লেখকের ছোট VM-এ চালালে আউটপুট 1, 3, 4: i = 2-এ continue print বাদ দিল, i = 4-এ break loop থামাল, তারপর বাইরের print(i) ছাপল 4.

goto আজ কোথায় বৈধ

goto-র ইতিহাস আর Dijkstra-Knuth বিতর্ক পর্ব ০৭-এ। আজকের বাস্তবে C-তে goto-র সবচেয়ে প্রচলিত ব্যবহার goto cleanup: কয়েকটি resource পরপর নেওয়া, যেকোনো ধাপে ব্যর্থ হলে একটি label-এ লাফ দিয়ে উল্টো ক্রমে সব ছাড়া (C কোর্সের পর্ব ৩০)। দ্বিতীয় ব্যবহার তৈরি করা কোড: lexer বা parser generator-এর বানানো state machine প্রায়ই goto দিয়ে লেখা, কারণ মানুষ সেটি পড়ে না। Go-তে goto আছে, কিন্তু নিয়ম কড়া: কোনো variable-এর ঘোষণা ডিঙিয়ে বা অন্য block-এর ভেতরে লাফ দেওয়া যায় না। Java-তে goto একটি সংরক্ষিত শব্দ, কিন্তু কোনো কাজ নেই। Haat v1-এ goto নেই, আর থাকবেও না: break, continue আর return-ই যথেষ্ট।

৮ · Compiler-এর চোখে — শর্ত, লাফের ওপর লাফ আর reducible graph

if-এর শর্তে && থাকলে কী হয়? Haat-এ && নিজেই লাফ দিয়ে নামানো (short-circuit; expression-এর দিক থেকে পূর্ণ আলোচনা পর্ব ২৬-এ)। সত্যিকারের python haat.py dis, এই program-এ: if total >= 1000 && !express { fee = 0; } (total = 1200, express = true; reference চালালে ছাপে 60):

   6  LOAD_GLOBAL    0     ; total
   7  CONST          3     ; 1000
   8  GE
   9  JUMP_IF_FALSE  13
  10  LOAD_GLOBAL    1     ; express
  11  NOT
  12  JUMP           14
  13  CONST          4     ; false
  14  JUMP_IF_FALSE  17
  15  CONST          5     ; 0
  16  STORE_GLOBAL   2     ; fee
  17  LOAD_GLOBAL    2     ; fee

reference প্রথমে &&-কে একটি Bool মানে বানায় (9–13), তারপর if সেই মান দেখে আবার লাফ দেয় (14). বাঁ পাশ মিথ্যা হলে পথটি দেখুন: 9 থেকে 13-এ লাফ, false push, আর 14-এ সেটি দেখে আবার 17-এ লাফ। ফল ঠিক, কিন্তু একটি অপ্রয়োজনীয় ঘুরপথ: 9-এর লক্ষ্য সরাসরি 17 হলেই চলত। একটি লাফ যদি এমন জায়গায় পৌঁছায় যার ফল আগেই জানা, তবে লক্ষ্যটি সরিয়ে শেষ গন্তব্যে বসানোর optimization-এর নাম jump threading. Dragon Book নামে পরিচিত Aho, Lam, Sethi, Ullman-এর পাঠ্যবইয়ে আরেকটি পথ আছে: শর্তের প্রেক্ষাপটে &&-কে মান না বানিয়ে সরাসরি “সত্য হলে এখানে, মিথ্যা হলে ওখানে” লাফে নামানো, যার ঠিকানাও backpatching দিয়ে ভরা হয়। Reference ইচ্ছা করেই সরল পথ নিয়েছে, যাতে সব expression একই নিয়মে compile হয়।

Structured কোড কেন বিশ্লেষণে সহজ

while, if, break আর continue থেকে যত CFG তৈরি হয়, তাদের প্রতিটি loop-এ ঢোকার পথ একটিই: loop-এর শর্তের block. এমন graph-কে বলে reducible flow graph. এর সুবিধা অনেক: loop চেনা সহজ (back edge খুঁজলেই হয়), dataflow analysis দ্রুত স্থির হয় (পর্ব ৬৪), আর loop optimization নিরাপদে চলে। অবাধ goto দিয়ে দুই দিক থেকে একটি loop-এর মাঝখানে ঢোকা যায়; তখন graph irreducible, আর compiler-কে block কপি করে (node splitting) বা বিশেষ পদ্ধতিতে সামলাতে হয়। Dijkstra-র যুক্তি তাই শুধু মানুষের বোঝার জন্য নয়; compiler-এর বোঝার জন্যও খাটে।

আরও গভীরে: WebAssembly-তে (২০১৭) কোনো goto নেই; control flow শুধু nested block, loop, if আর নির্দিষ্ট গভীরতার বাইরে বেরোনোর br দিয়ে, অনেকটা labelled break-এর মতো। তাই C-কে Wasm-এ compile করতে হলে compiler-কে যেকোনো CFG থেকে আবার structured গঠন বের করতে হয়। Emscripten-এর জন্য Alon Zakai ২০১১ সালে এর একটি পদ্ধতি প্রকাশ করেন, “Relooper” নামে; LLVM-এর WebAssembly back end নিজের একটি pass দিয়ে কাজটি করে, আর irreducible অংশ আগে আলাদা ধাপে ঠিক করে নেয়। Haat-এর Wasm back end পর্ব ৭৩-এ ঠিক এই সমস্যায় পড়বে না, কারণ Haat-এর সব graph-ই reducible.

পরীক্ষা ও ইন্টারভিউতে: বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন প্রায়ই আসে:

  • Dangling else কী, C কীভাবে মেটায়? একটি else-এর দুই সম্ভাব্য if; C-তে else কাছের জোড়াহীন if-এর সঙ্গে যায়।
  • while (c) s-এর three-address code? L1: ifFalse c goto L2; s; goto L1; L2:.
  • switch কখন jump table হয়? case-এর মান ঘন হলে (আর যথেষ্ট case থাকলে); পাতলা হলে তুলনার শিকল বা binary search.
  • break আর continue-এর পার্থক্য? break loop থেকে বের করে, continue এই round-এর বাকি অংশ বাদ দেয় (C-র for-এ step চলে)।
  • Backpatching কেন লাগে? সামনের লাফের লক্ষ্য লেখার সময় অজানা; ঘর ফাঁকা রেখে পরে ভরা হয়।

৯ · AI-এর যুগে control flow

Loop আর শর্ত লেখায় AI assistant সবচেয়ে দ্রুত, কিন্তু এই বিষয়ের ভুলগুলো চুপচাপ থাকে, কারণ ভুল কোড প্রায়ই compile হয় আর বেশিরভাগ input-এ ঠিক উত্তরও দেয়:

AI-এর ভুলকীভাবে ধরবেন
এক ভাষার নিয়ম অন্য ভাষায়: “Go-তেও switch-এ break লাগে”, “Python-এ labelled break আছে”সেই ভাষার specification পড়া; সেই version-এর compiler বা interpreter-এ চালানো
C switch-এ break বাদ পড়া, অথবা ইচ্ছাকৃত fall-through চিহ্ন ছাড়া-Wimplicit-fallthrough চালু করা (এই Clang-এ -Wall যথেষ্ট নয়); প্রতিটি case-এর test
for-কে while-এ বদলানোর সময় continue-এর গন্তব্য ভুল, ফলে অসীম loopcontinue-ওয়ালা input দিয়ে দুই রূপ পাশাপাশি চালানো (differential test)
Loop চলার সময় একই list থেকে মোছা বা যোগ করাকপির ওপর loop, বা নতুন list বানানো; সীমার মান দিয়ে test
“-O2-তে switch সবসময় jump table হয়” ধরনের নিশ্চিত দাবি, বা অস্তিত্বহীন flagসত্যিকারের -S আউটপুট পড়া; flag-এর নাম compiler-এর documentation-এ খোঁজা
Off-by-one: <= আর < গুলিয়ে ফেলা, শেষ জিনিস বাদ বা একবার বেশিশূন্য, এক আর দুই জিনিসের input-এ হাতে হিসাব মিলিয়ে দেখা

AI-কে ভালোভাবে কাজে লাগাতে ভাষা আর version বলে দিন, আর প্রতিটি দাবির যাচাইয়ের উপায় চান:

আমি C17 (Clang) আর Python 3.14-এ একটি দোকানের ডেলিভারি-চার্জের কোড লিখছি। zone 0 থেকে 5, প্রতিটির চার্জ আলাদা। ১. C-তে একটি switch লেখো, প্রতিটি case-এ break সহ; কোথাও fall-through ইচ্ছাকৃত হলে [[fallthrough]] চিহ্ন দাও আর কেন, বলো। ২. Clang -O2 এই switch-কে jump table, lookup table না তুলনার শিকলে নামাবে বলে তুমি মনে করো? অনুমান বলো, কিন্তু কোন কমান্ডে (-S) আমি নিজে যাচাই করব তা-ও দাও। এমন কোনো flag লিখবে না যার অস্তিত্ব তুমি নিশ্চিত নও। ৩. একই কাজ Python-এ, তারপর দুটির জন্য একই test input-এর তালিকা দাও: -1, 0, 5, 6 আর একটি বড় মান। ৪. কোনো loop-এ break বা continue থাকলে সেটি কোন loop-এ যায়, প্রতিটির পাশে মন্তব্যে লেখো।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Dijkstra-র চিঠির অর্ধশতাব্দী পরেও C আর Go-তে goto কেন আছে, অথচ Java আর Python-এ নেই?

১৯৬৮ সালের চিঠির মূল দাবি ছিল: program-এর লেখার গঠন আর চলার পথের মিল থাকলে আমরা কোড বুঝতে পারি, আর অবাধ goto সেই মিল ভাঙে। কিন্তু দাবিটি ছিল অবাধ goto নিয়ে। ১৯৭৪ সালে Donald Knuth “Structured Programming with go to Statements” প্রবন্ধে দেখান, কিছু নির্দিষ্ট ধাঁচে goto কোডকে সহজই করে: loop-এর মাঝখান থেকে বেরোনো, আর ভুল হলে এক জায়গায় পরিষ্কার করা।

C-র নকশা ১৯৭০-এর দশকের শুরুতে, যখন exception বা RAII-এর মতো ব্যবস্থা মূলধারায় ছিল না। C-তে একটি function পরপর মেমরি, ফাইল আর lock নিলে, যেকোনো ধাপের ব্যর্থতায় আগেরগুলো উল্টো ক্রমে ছাড়তে হয়। goto ছাড়া এর বিকল্প হলো গভীর nested if, বা প্রতিটি ব্যর্থতার জায়গায় একই cleanup কোডের কপি, যেখানে একটি কপি ভুলে গেলেই resource leak. তাই Linux kernel-এর মতো বড় C প্রকল্পে goto out; একটি স্বীকৃত রীতি। তৈরি করা কোডেও goto স্বাভাবিক: lexer generator যে state machine বানায়, তা মানুষ পড়ে না, তাই সরাসরি লাফই সবচেয়ে সরল।

Go (২০০৯) goto রেখেছে, কিন্তু Dijkstra-র মূল আপত্তি মেনে কড়া নিয়মে: কোনো variable-এর ঘোষণা ডিঙিয়ে লাফ দেওয়া যায় না, আর বাইরে থেকে কোনো block-এর ভেতরে ঢোকা যায় না। ফলে goto দিয়েও “অর্ধেক তৈরি variable” বা loop-এর মাঝখানে ঢোকার মতো বিপদ তৈরি হয় না। Go-তে defer থাকায় cleanup-এর জন্য goto-র দরকারও কমেছে।

Java (১৯৯৫) আর Python (১৯৯১) অন্য পথ নিয়েছে। দুটিতেই exception আর finally (পরে Python-এ with, Java-তে try-with-resources) cleanup সামলায়; Java-র labelled break nested loop থেকে বেরোনো সামলায়। goto-র প্রতিটি বৈধ ব্যবহারের জন্য একটি নির্দিষ্ট, সীমিত গঠন থাকলে অবাধ গঠনটির দরকার থাকে না। Java goto-কে সংরক্ষিত শব্দ করে রেখেছে, যাতে কেউ variable-এর নাম হিসেবে ব্যবহার না করে আর ভবিষ্যতে বিভ্রান্তি না হয়।

মূল উপলব্ধি: goto-র সমস্যা লাফ নয়, লাফের স্বাধীনতা; প্রতিটি বৈধ ব্যবহারের জন্য সীমিত গঠন (break, return, finally, defer) দিলে goto অপ্রয়োজনীয় হয়, আর যেখানে তা নেই (C), সেখানে নিয়ন্ত্রিত goto টিকে থাকে।

প্র ০২C-র switch-এ fall-through কি একটি নকশার ভুল ছিল? পরের ভাষাগুলো কী শিখল?

C-তে case একটি label, আর switch হলো “মান দেখে সেই label-এ goto”. একবার label-এ পৌঁছানোর পরে কোড স্বাভাবিকভাবে নিচের দিকে চলে, যেমন যেকোনো label-এর পরে চলে। এই মডেল যন্ত্রের কাছাকাছি আর বাস্তবায়নে সরল: compiler শুধু ঠিকানার টেবিল বানায়। এর একটি সুবিধাও আছে: কয়েকটি case একই কাজ করলে case 1: case 2: … পরপর লেখা যায়।

সবচেয়ে বিখ্যাত ইচ্ছাকৃত fall-through হলো Duff's device (Tom Duff, ১৯৮৩ সালের দিকে): একটি do-while loop-এর ভেতরে switch-এর case ছড়িয়ে দিয়ে loop unrolling-এর বাকি অংশ সামলানো। কোডটি বৈধ C, কিন্তু প্রথম দেখায় প্রায় সবাই অবাক হন; এটি দেখায় যে switch আসলে লাফের টেবিল, block নয়।

বাস্তবে কিন্তু fall-through-এর বেশিরভাগ ঘটনা ভুল: break ভুলে যাওয়া। অংশ ৪-এর run-এ zone 1-এর চার্জ ৬০ হয়ে গেল, আর Clang 22.1.8 -Wall -Wextra-তেও চুপ ছিল। GCC 7 থেকে -Wimplicit-fallthrough -Wextra-এর অংশ; Clang-এ এটি আলাদা করে চালু করতে হয়। C++17 আর C23 ইচ্ছাকৃত fall-through চিহ্নিত করার জন্য [[fallthrough]] attribute এনেছে, যাতে warning চালু রেখেও ইচ্ছাকৃত জায়গাগুলো চুপ রাখা যায়।

পরের ভাষাগুলো ডিফল্ট উল্টে দিয়েছে। C# পুরো নিষেধ করেছে: কোনো case-এর কোড থেকে পরের case-এ গড়ানো compile error, চাইলে goto case লিখতে হয়। Go আর Swift-এ ডিফল্টে গড়ায় না, চাইলে fallthrough লিখতে হয়: বিরল কাজটি লম্বা, সাধারণ কাজটি ছোট। Java 14-এর arrow-রূপে fall-through নেই, আর switch মান দিতে পারে। Rust-এর match, Kotlin-এর when আর Python-এর match-এ fall-through-এর ধারণাই নেই, কারণ সেখানে প্রতিটি arm একটি আলাদা block.

মূল উপলব্ধি: ভাষার ডিফল্ট আচরণ হওয়া উচিত সাধারণ কাজের; বিরল কাজের জন্য স্পষ্ট চিহ্ন। C-র ডিফল্ট উল্টো ছিল, তাই পরের প্রায় সব ভাষা তা উল্টে দিয়েছে।

প্র ০৩External আর internal iteration কী? কোন ভাষা কোনটি বেছে নিল, আর কেন?

অংশ ৬-এর iterator protocol হলো external iteration: loop-এর নিয়ন্ত্রণ ব্যবহারকারীর হাতে। সে নিজে next() ডাকে, কখন থামবে ঠিক করে, চাইলে দুটি iterator একসাথে এগিয়ে নেয় (যেমন দুটি সাজানো তালিকা মেলানো)। Python, Java-র Iterator, C++-এর iterator, Rust-এর Iterator trait সবাই এই ধাঁচের।

উল্টো ধাঁচ internal iteration: সংগ্রহ নিজেই loop চালায়, আর প্রতিটি জিনিসের জন্য আপনার দেওয়া একটি function ডাকে। Smalltalk-এর do:, Ruby-র each, JavaScript-এর forEach, Java 8-এর forEach আর stream. সুবিধা: সংগ্রহ জানে নিজের ভেতরের গঠন, তাই একটি গাছের সব node ঘোরা সহজ recursion দিয়েই লেখা যায়; library চাইলে কাজ ভাগ করে সমান্তরালে চালাতে পারে। অসুবিধা: আগেভাগে থামা কঠিন (JavaScript-এর forEach-এ break কাজ করে না), আর দুটি সংগ্রহ একসাথে ঘোরা প্রায় অসম্ভব।

external iteration-এর বড় অসুবিধা হলো iterator লেখার কষ্ট: গাছের in-order iterator লিখতে হলে recursion-এর বদলে হাতে একটি stack রাখতে হয়। এই সমস্যার সমাধান এসেছে ১৯৭০-এর দশকের মাঝামাঝি MIT-তে Barbara Liskov-এর দলের CLU ভাষা থেকে: iterator একটি বিশেষ procedure, যা yield দিয়ে একটি একটি মান দেয় আর পরের ডাকে সেখান থেকেই আবার চলে। Python আর JavaScript-এর generator এই ধারণার উত্তরসূরি: লেখা হয় internal iteration-এর মতো সহজ রূপে, কিন্তু ব্যবহার হয় external-এর মতো। এর বাস্তবায়ন, অর্থাৎ compiler কীভাবে একটি function-কে “মাঝপথে থামানো” যায় এমন state machine-এ বদলায়, পর্ব ৩১-এর বিষয়।

Haat-এর কোনো সংগ্রহ নেই, তাই v1-এ প্রশ্নটি ওঠে না। array যোগ হলে (Haat-এর বর্ধিত রূপ) প্রথম সহজ পথ হবে for-each-কে একটি index-এর while-এ desugar করা, ঠিক Java যেমন array-র জন্য করে।

মূল উপলব্ধি: external iteration ব্যবহারকারীকে নিয়ন্ত্রণ দেয়, internal iteration লেখককে সরলতা দেয়; generator দুটির ভালো দিক একসাথে আনে।

প্র ০৪if আর loop কি statement হওয়া উচিত, না expression? Haat, C, Rust আর Kotlin-এর পছন্দ তুলনা করুন।

C, Java আর Haat-এ if একটি statement: এটি কিছু করে, কোনো মান দেয় না। মান বাছতে C দেয় আলাদা একটি operator, c ? a : b; Python দেয় a if c else b (Python 2.5, ২০০৬)। Rust, Kotlin, Scala আর ML-পরিবারে if নিজেই একটি expression: let fee = if total >= 1000 { 0 } else { 60 };. Rust-এ loop-ও মান দিতে পারে, break-এর সঙ্গে।

expression হলে ভাষা ছোট হয়: আলাদা ternary operator লাগে না, আর “একবার মান বসিয়ে আর বদলাব না” (Haat-এর let) সহজে লেখা যায়। কিন্তু type checker-এর কাজ বাড়ে। দুই শাখার type এক হতে হবে, আর else না থাকলে মান কী? Rust-এর উত্তর: else ছাড়া if-এর type (), Haat-এর Unit-এর মতো, তাই এমন if-কে মান হিসেবে ব্যবহার করলে type error. Typing rule-এর ভাষায়: Γ ⊢ c : Bool, Γ ⊢ e1 : τ আর Γ ⊢ e2 : τ হলে Γ ⊢ if c {e1} else {e2} : τ. এর পূর্ণ পদ্ধতি পর্ব ৩৪-এ।

Haat v1 statement-এর পথ নিয়েছে, আর reference-এর সিদ্ধান্তগুলো সেই দিকেই: print একটি statement (সিদ্ধান্ত ৮), assignment একটি statement (সিদ্ধান্ত ৯)। এর একটি ফল সিদ্ধান্ত ২১-এর missing-return নিয়ম: যেহেতু if কোনো মান দেয় না, function-এর প্রতিটি পথে return আছে কি না তা গঠন দেখে যাচাই করতে হয়, আর while কখনো “return করে” বলে গণ্য হয় না, এমনকি while true-ও না। expression-ভিত্তিক ভাষায় এই নিয়মের জায়গা নেয় type: শেষ expression-এর type-ই function-এর ফেরত type.

expression-এর পথে একটি খরচও আছে: পড়ার সময় বোঝা কঠিন হতে পারে, যদি একটি বড় block-এর শেষ লাইনটি নিঃশব্দে মান হয়ে যায়। Rust এজন্য সেমিকোলন দিয়ে পার্থক্য করে: { x + 1 }-এর মান x + 1, কিন্তু { x + 1; }-এর মান ().

মূল উপলব্ধি: if-কে expression বানালে ভাষা ছোট আর immutability সহজ হয়, বিনিময়ে type নিয়ম আর “শেষ লাইনই মান” ধরনের সূক্ষ্মতা আসে; Haat-এর statement-ভিত্তিক নকশা সেই জটিলতা ছাড়া missing-return-এর মতো syntactic নিয়মে কাজ চালায়।

প্র ০৫structured programming কি শুধু মানুষের জন্য, না compiler-এর জন্যও লাভজনক? reducible graph আর WebAssembly কী শেখায়?

Böhm–Jacopini দেখিয়েছিলেন goto ছাড়া সব লেখা যায়, আর Dijkstra বলেছিলেন goto ছাড়া বোঝা সহজ। compiler-এর দিক থেকে তৃতীয় একটি কথা আছে: structured কোড থেকে তৈরি CFG-এর একটি বিশেষ আকার থাকে। প্রতিটি loop-এর প্রবেশপথ একটিই block, যা loop-এর বাকি সব block-কে dominate করে (পর্ব ৬৩-এ dominator). এমন graph reducible: back edge বাদ দিলে চক্রহীন হয়, আর loop-গুলো সুন্দরভাবে একটির ভেতরে আরেকটি বসে। ১৯৭০-এর দশকে Allen, Cocke, Hecht আর Ullman-এর মতো গবেষকদের কাজে এই ধারণা গড়ে ওঠে।

এতে কী লাভ? loop চেনা সহজ: যে edge কোনো dominator-এর দিকে ফেরে, সেটিই back edge, আর তা থেকে loop-এর body. dataflow analysis-এর fixpoint হিসাব reducible graph-এ ভালো ক্রমে block ঘুরলে কয়েক pass-এই স্থির হয় (পর্ব ৬৪)। loop-invariant code motion বা strength reduction-এর মতো optimization (পর্ব ৬৬) “loop-এর শুরুর আগে একটি জায়গা”-র ওপর নির্ভর করে, যা একক প্রবেশপথ থাকলেই নিশ্চিত। irreducible graph-এ এসব কঠিন: compiler-কে block কপি করে (node splitting) graph-কে reducible বানাতে হয়, যাতে কোড বড় হয়, অথবা দুর্বল বিশ্লেষণে সন্তুষ্ট থাকতে হয়।

WebAssembly এই শিক্ষাকে নিয়ম বানিয়েছে। Wasm-এ কোনো goto নেই, শুধু nested block, loop, if আর বাইরের কোনো স্তরে বেরোনোর br. এর ফলে browser-এর engine একটি pass-এ কোড যাচাই (validation) আর দ্রুত compile করতে পারে, কারণ গঠন থেকেই stack-এর অবস্থা জানা। দাম দিতে হয় source-compiler-কে: C-র যেকোনো goto-ওয়ালা CFG থেকে structured গঠন ফিরিয়ে আনতে হয়। Emscripten-এর Relooper (Alon Zakai, ২০১১) আর LLVM-এর WebAssembly back end-এর নিজের পদ্ধতি এই কাজ করে; irreducible অংশ থাকলে আগে একটি বাড়তি ধাপে তা ঠিক করা হয়।

মূল উপলব্ধি: structured control flow মানুষের বোঝা, compiler-এর বিশ্লেষণ আর virtual machine-এর যাচাই, তিনটিকেই সহজ করে; Wasm-এর নকশা দেখায় এই সুবিধা এত বড় যে একটি আধুনিক bytecode goto-কে পুরো বাদ দিয়েছে।

অনুশীলন

প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run দিয়ে যাচাই করা।

  1. নকশা ও বাস্তবায়ন — Haat-এর বর্ধিত রূপে break আর continue: অংশ ৩-এর ছোট compiler-এ (tuple-AST, emit, patch) ("break", pos) আর ("continue", pos) statement যোগ করুন। nested loop-এ প্রতিটি break নিজের loop-এ যেতে হবে, আর loop-এর বাইরে হলে <pos>: error: 'break' outside of a loop জমা হবে। অংশ ৭-এর stepper-এর program দিয়ে যাচাই করুন। Reference-এর কোন সিদ্ধান্তটি বদলাতে হবে?
    # Haat-এর বর্ধিত রূপ (নকশার খসড়া, reference-এ নেই)
    loops, errors = [], []          # খোলা loop-এর stack
    
    def stmt(s):
        k = s[0]
        # … set, print আগের মতো …
        if k == "if":                              # else ছাড়া if
            expr(s[1]); to_end = emit("JUMP_IF_FALSE")
            for t in s[2]: stmt(t)
            patch(to_end)
        elif k == "while":
            top = len(code); expr(s[1]); to_end = emit("JUMP_IF_FALSE")
            loops.append({"top": top, "breaks": []})
            for t in s[2]: stmt(t)
            emit("JUMP", top); patch(to_end)
            for b in loops.pop()["breaks"]: patch(b)   # সব break loop-এর ঠিক পরে
        elif k in ("break", "continue"):
            if not loops:
                errors.append(f"{s[1]}: error: '{k}' outside of a loop"); return
            if k == "continue": emit("JUMP", loops[-1]["top"])
            else: loops[-1]["breaks"].append(emit("JUMP"))

    লেখকের CPython 3.14.4-এ চালানো হলো (সঙ্গে < আর ==-এর opcode আর একটি ছোট VM). তৈরি কোডের লাফ: 5 JUMP_IF_FALSE 23, 13 JUMP_IF_FALSE 15, 14 JUMP 2, 18 JUMP_IF_FALSE 20, 19 JUMP 23, 22 JUMP 2; আউটপুট 1, 3, 4; আর loop-এর বাইরে ("break", "9:1") দিলে 9:1: error: 'break' outside of a loop. মূল বিষয় দুটি: continue-এর লক্ষ্য সবসময় জানা (পেছনে), তাই সরাসরি লেখা যায়; break-এর লক্ষ্য অজানা (সামনে), তাই loop-এর খাতায় জমা থাকে আর loop বন্ধ হওয়ার সময় ভরা হয়। stack থাকায় ভেতরের loop-এর break কখনো বাইরের loop-এর খাতায় যায় না। Labelled break চাইলে প্রতিটি খাতায় একটি নামও রাখুন, আর break name stack-এ নিচের দিকে সেই নাম খুঁজবে। Reference-এ বদলাতে হবে lexer-এর keyword তালিকা (এখন break একটি সাধারণ নাম, তাই undefined variable 'break'), আর সিদ্ধান্ত ২১-এর missing-return নিয়ম: break-ওয়ালা while true থাকলেও সেটি “return করে” গণ্য না হওয়াই নিরাপদ, যেমন এখন।

  2. ভুল খুঁজুন: একজন সহকর্মী একটি compiler-এ C-র for-কে while-এ নামানোর নিয়ম লিখলেন: for (init; cond; step) body ⟶ init; while (cond) { body; step; }. নিচের program-এ তাঁর নিয়ম কী ঘটাবে? ভুলটি কোথায়, আর সঠিক নিয়ম কী?
    for (int i = 0; i < 5; i++) {
        if (i == 2) continue;
        printf("%d ", i);
    }

    সঠিক আউটপুট 0 1 3 4. সহকর্মীর রূপে i = 2-এ continue while-এর শর্তে লাফ দেয়, ফলে i++ আর কখনো চলে না: অসীম loop. সত্যিকারের run (Clang 22.1.8, পাহারা-গণক দিয়ে ১০ round-এ থামানো): 0 1 stuck: i = 2. ভুলটি হলো ধরে নেওয়া যে continue-এর অর্থ “শর্তে ফেরা”; C-র for-এ এর অর্থ “step-এ যাওয়া”। সঠিক নিয়ম: init; while (cond) { body′; next: step; }, যেখানে body′-তে এই loop-এর প্রতিটি continue বদলে goto next (ভেতরের nested loop-এর continue নয়)। compiler-এ সহজ পথ হলো সরাসরি লাফে নামানো: loop-এর খাতায় continue-এর লক্ষ্য রাখা হয় step-এর label, while-এর মতো শর্তের label নয়। আরেকটি সূক্ষ্মতা: init-এ ঘোষিত i-এর scope শুধু loop, তাই পুরোটা একটি বাড়তি block { … }-এর ভেতরে রাখতে হয়।

  3. হিসাব ও trace: অংশ ৩-এর zone program-এর (km = 2 থেকে শুরু, প্রতি round-এ ৪ করে বাড়ে, km ≤ 10 পর্যন্ত; km ≤ 3 হলে paid-এ ৪০, নইলে ৬০ যোগ) জন্য (ক) label-সহ three-address code লিখুন, ifFalse … goto আর goto ব্যবহার করে। (খ) Haat reference-এর bytecode-এ চারটি লাফ 7 JUMP_IF_FALSE 26, 11 JUMP_IF_FALSE 17, 16 JUMP 21, 25 JUMP 4: প্রতিটি কতবার লাফ দেয়? (গ) আউটপুট কী?
            km = 2
            paid = 0
    L1:     t1 = km <= 10
            ifFalse t1 goto L4
            t2 = km <= 3
            ifFalse t2 goto L2
            paid = paid + 40
            goto L3
    L2:     paid = paid + 60
    L3:     km = km + 4
            goto L1
    L4:     print paid

    (খ) km-এর মান 2, 6, 10, তারপর 14-এ শেষ। 7→26 একবার (km = 14), 11→17 দুবার (km = 6, 10), 16→21 একবার (km = 2-এ then-এর পরে), 25→4 তিনবার। (গ) 160. যাচাই: অংশ ৩-এর VM-এর সত্যিকারের আউটপুট jumps taken: 16->21 25->4 11->17 25->4 11->17 25->4 7->26, আর reference-এর run ও vm দুটিই 160. খেয়াল করুন, three-address code-এর label L1, L2, L3, L4 ঠিক bytecode-এর 4, 17, 21, 26-এর জায়গায়; IR আর bytecode-এর এই মিল পর্ব ৬২-এ (Intermediate representation) কাজে লাগবে।

  4. আউটপুট অনুমান করুন: Python 3.14-এ নিচের program কী ছাপবে? চালানোর আগে ছয়টি লাইন লিখুন।
    def find(stock, want):
        for i, q in enumerate(stock):
            if q == 0:
                continue
            if q >= want:
                print("found at", i)
                break
        else:
            print("none")
        return i
    print(find([0, 3, 8, 1], 5))
    print(find([0, 2], 5))
    print(find([7], 5))

    সত্যিকারের run (CPython 3.14.4): found at 2, 2, none, 1, found at 0, 0. প্রথম ডাকে i = 0-এ continue, i = 1-এ 3 < 5, i = 2-এ 8 ≥ 5, তাই break; break হয়েছে বলে else চলেনি। দ্বিতীয় ডাকে কোনো break নেই, loop স্বাভাবিকভাবে শেষ, তাই else ছাপে none; আর i শেষ মান 1 ধরে রাখে, কারণ Python-এ loop variable loop-এর পরেও থাকে (C-র for (int i …)-এ থাকে না)। continue loop-else-কে প্রভাবিত করে না: শুধু break-ই else বাতিল করে। সাবধান: খালি তালিকা দিলে loop একবারও চলে না, তখন i কখনো তৈরিই হয় না আর return i UnboundLocalError দেয়।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমএকটি bytecode compiler while c { s }-কে যে ক্রমে নামায়, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. এখনকার নির্দেশ-সংখ্যা top হিসেবে মনে রাখা
  2. শর্ত c-এর কোড লেখা
  3. লক্ষ্য ফাঁকা রেখে JUMP_IF_FALSE লেখা
  4. body s-এর কোড লেখা
  5. JUMP top লেখা
  6. ফাঁকা লক্ষ্যটি পরের নির্দেশের index দিয়ে ভরা

C-তে int x = 0, a = 0, b = 1; if (a) if (b) x = 1; else x = 2; চলার পরে x-এর মান কত?

  • 0
  • 1
  • 2
  • Compile error

C-র একটি switch-এ case 0 থেকে 5, আর প্রতিটি case শুধু একটি ধ্রুবক ফেরত দেয় (যেমন case 3: return 90;). Clang 22-এর -O2 সাধারণত একে কীভাবে নামায়?

  • ছয়টি তুলনার শিকল
  • ঠিকানার jump table আর indirect jump
  • মানের lookup table, সীমা পরীক্ষার পরে একটি মেমরি পড়া
  • Binary search-এর মতো তুলনার গাছ

Python-এ for x in xs: loop কীভাবে জানে যে আর কোনো জিনিস নেই?

  • শুরুতে len(xs) পড়ে রাখে
  • iterator-এর next() StopIteration তোলে, আর for তা ধরে থামে
  • next() None ফেরত দেয়
  • প্রতি round-এ hasNext() ডাকে

একজন লিখলেন: for (init; cond; step) body-এর অর্থ init; while (cond) { body; step; }. body-তে কী থাকলে এই নামানো C-র অর্থ বদলে দেয়?

  • break
  • return
  • loop variable-এ assignment
  • continue

Haat reference compiler while c { s }-কে top: c; JUMP_IF_FALSE end; s; JUMP top; end:-এ নামায়। loop-এর প্রতিটি পূর্ণ round-এ (শর্ত সত্য) কয়টি লাফের নির্দেশ চলে?

  • ১টি
  • ২টি
  • ৩টি
  • ০টি

Python-এ for … else-এর else অংশ কখন চলে?

  • শুধু তালিকা খালি হলে
  • loop break দিয়ে থামলে
  • loop break ছাড়া স্বাভাবিকভাবে শেষ হলে
  • loop-এর ভেতরে exception হলে

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. সব গঠনই লাফ: if = শর্ত-মিথ্যায় else-এ লাফ + then-শেষে join-এ লাফ; while = ওপরে শর্ত, নিচে পেছনের লাফ। সামনের লাফের লক্ষ্য backpatching দিয়ে পরে ভরা হয়।
  2. Dangling else: C আর Java-তে else কাছের if-এর; Haat, Rust, Go বন্ধনী বাধ্যতামূলক করে প্রশ্নটিই মুছে দেয়।
  3. switch: C-তে case হলো label, তাই fall-through; compiler বাছে তুলনার গাছ, jump table বা lookup table, মানের ঘনত্ব আর case-এর কাজ দেখে।
  4. Loop: গোনা বনাম শর্তের loop; C-র for আসলে শর্তের loop, আর তাকে while-এ নামাতে continue-কে step-এ পাঠাতে হয়। for-each = iterator protocol.
  5. break, continue, labelled break আর goto cleanup সীমিত লাফ; structured গঠন reducible CFG দেয়, যা compiler-এর বিশ্লেষণ আর Wasm-এর মতো লক্ষ্য দুটিকেই সহজ করে।

পরের পর্বে: পর্ব ২৮ (Exception handling — try, unwinding আর error value). একটি error কীভাবে কয়েকটি function পেরিয়ে ওপরে ওঠে, finally কখন চলে, আর compiler কীভাবে এই “অদৃশ্য লাফ” বাস্তবায়ন করে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান