এই পর্বে যা শিখবেন
- 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. সেগুলো এখানে আর বলা হবে না। এই পর্বে তিনটি নতুন প্রশ্ন:
- অর্থ: প্রতিটি গঠনের নিখুঁত অর্থ কী? else কোন if-এর, switch-এ break না থাকলে কী হয়, loop-এর ভেতরে list বদলালে কী হয়?
- নকশা: ভাষাগুলো কেন আলাদা পথ নেয়? C-র fall-through, Python-এর
for…else, Java আর JavaScript-এর labelled break, Haat-এর বাধ্যতামূলক বন্ধনী। - বাস্তবায়ন: 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, অংশ ৩)
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, JavaScript | grammar ছোট থাকে; ফাঁদটি প্রোগ্রামারের ঘাড়ে |
| শাখার শেষ চিহ্ন বাধ্যতামূলক | 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).
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);
| নতুন নির্দেশ | |
| ভরা হলো | |
| ফাঁকা ঘর |
- while শুরু। এখন পর্যন্ত ৪টি নির্দেশ (০–৩, দুটি var), তাই
top = 4মনে রাখা হলো। শর্তkm <= 10হলো 4–6, তারপর 7-এJUMP_IF_FALSE, লক্ষ্য অজানা: ঘর ৭ ফাঁকা। - if-এর শর্ত। body-র প্রথম statement একটি if. শর্ত 8–10, তারপর 11-এ আরেকটি ফাঁকা
JUMP_IF_FALSE. এখন দুটি ঘর অপেক্ষায়। - then-শাখা।
paid = paid + 40হলো 12–15. then-এর শেষে else ডিঙানোরJUMP(16), লক্ষ্য অজানা। এখন else ঠিক পরের নির্দেশ ১৭ থেকে শুরু হবে, তাই ঘর ১১ ভরা হলো ১৭ দিয়ে। - else-শাখা। 17–20. else শেষ, if-ও শেষ: পরের নির্দেশ ২১ হলো join, তাই ঘর ১৬ ভরা হলো ২১ দিয়ে।
- body-র বাকি অংশ আর পেছনের লাফ।
km = km + 4হলো 21–24, তারপর 25-এJUMP 4. লক্ষ্য আগে থেকেই জানা (top), তাই কিছু ফাঁকা রাখতে হলো না। - loop শেষ। পরের নির্দেশ ২৬ হবে loop-এর পরের কোড, তাই ঘর ৭ ভরা হলো ২৬ দিয়ে। আর কোনো ঘর ফাঁকা নেই।
- বাকি 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):
- শেষ নিয়ম E-WhileF হলে: c-এর কোড false রাখে,
JUMP_IF_FALSEতা তুলে end-এ লাফ দেয়; কোনো variable বদলায়নি, তাই অবস্থা σ, যা নিয়মের ফলের সমান। - শেষ নিয়ম E-WhileT হলে: c-এর কোড true রাখে, লাফ হয় না, s-এর কোড শুরু হয় σ নিয়ে আর ধরে নেওয়া শর্তে শেষ হয় σ′ নিয়ে।
- তারপর
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
| edi (s) | |
| rcx | |
| rax |
- সীমা পরীক্ষা।
cmp edi, 5মান ৩-কে ৫-এর সঙ্গে তুলনা করে। পরেরja(jump if above) তুলনাটিকে unsigned হিসেবে পড়ে; এটিই এই কৌশলের চাবি। - default নয়। 3 > 5 মিথ্যা, তাই
jaলাফ দেয় না। এখন নিশ্চিত যে মানটি 0..5-এর মধ্যে, টেবিলের বাইরে পড়ার ভয় নেই। - Index আর টেবিল।
eax-এ index 3,rcx-এ টেবিল.LJTI0_0-এর ঠিকানা (ধরুন T).rip-ভিত্তিক ঠিকানা মানে program যেখানেই load হোক, কোড কাজ করবে। - টেবিল পড়া। প্রতিটি ঘর ৪ byte, তাই ঠিকানা T + 4 × 3. ঘরে আছে
.LBB0_5 - .LJTI0_0: পূর্ণ ঠিকানা নয়, টেবিল থেকে দূরত্ব।movsxdসেটিকে চিহ্নসহ ৬৪ বিটে বড় করে। - পূর্ণ ঠিকানা। দূরত্বের সঙ্গে T যোগ করলে case 3-এর কোডের আসল ঠিকানা
.LBB0_5. - লাফ।
jmp rax: register থেকে ঠিকানা নিয়ে লাফ।.LBB0_5-এholdডাকা হয়jmpদিয়ে (Clang-এর মন্তব্যেTAILCALL), কারণ এটিই function-এর শেষ কাজ; এর বিস্তার পর্ব ৩২-এ (Recursion আর tail call). - s = -1 হলে। -1-এর বিট-রূপ 0xFFFFFFFF; unsigned হিসেবে এটি 4294967295, যা ৫-এর চেয়ে বড়। তাই একই
jadefault-এ পাঠায়। একটি তুলনাতেই দুই দিকের সীমা পরীক্ষা হলো; 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-তে গণক বদলানো নিষেধ।
শর্তে ঘোরা
Logic-controlled loop: প্রতিবার একটি শর্ত পরীক্ষা। শর্ত ওপরে (pre-test, while) হলে body শূন্যবারও চলতে পারে; নিচে (post-test, 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-for | begin(xs), end(xs) | *it, তারপর ++it | it == 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 |
- শুরুতে একবার।
iter(cart)ঝুড়ির__iter__ডাকে, ফেরত আসে একটি নতুন iterator, যার গণকi = 0. ঝুড়ি নিজে বদলায় না; অবস্থা থাকে iterator-এ। - প্রথম next.
next(it)দেয়'chal', গণক 1. মান বসল loop variableitem-এ। - Body. body চলে
item = 'chal'নিয়ে। - আবার next.
'dal', গণক 2. - Body.
body: dal. - শেষের সংকেত। গণক 2 = তালিকার দৈর্ঘ্য, তাই
__next__StopIteration তোলে। এটি ভুল নয়, স্বাভাবিক শেষের সংকেত। - 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);
| নতুন নির্দেশ | |
| loop stack | |
| ভরা হলো |
- Loop খোলা।
top = 2; শর্ত 2–4, 5-এ ফাঁকাJUMP_IF_FALSE. stack-এ এই loop-এর একটি খাতা: শুরু 2, break-এর তালিকা খালি। - সাধারণ কাজ।
i = i + 1হলো 6–9; loop stack-এর কিছু বদলায় না। - continue. if-এর শর্ত 10–12, ফাঁকা লাফ 13. ভেতরের
continuestack-এর ওপরের loop-এর শুরু পড়ে নেয়:JUMP 2(14), কোনো ফাঁকা ঘর ছাড়াই। if শেষ, তাই 13 ভরা হলো 15 দিয়ে। - break. শর্ত 15–17, ফাঁকা লাফ 18.
breakলেখেJUMP ?(19), কারণ loop-এর শেষ এখনো অজানা; index 19 ঢুকল loop-এর break-তালিকায়। 18 ভরা হলো 20 দিয়ে। - Loop-এর শেষ। print 20–21, পেছনের লাফ
JUMP 2(22). এখন loop-এর পরের নির্দেশ 23, তাই শর্ত-মিথ্যার লাফ 5 ভরা হলো 23 দিয়ে। - Loop বন্ধ। stack থেকে খাতাটি তুলে তার প্রতিটি break (এখানে 19) ভরা হলো 23 দিয়ে। nested loop হলে প্রতিটি break নিজের loop-এর খাতায় থাকে, তাই কখনো ভুল loop-এ যায় না।
- চালানো। 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-এর গন্তব্য ভুল, ফলে অসীম loop | continue-ওয়ালা input দিয়ে দুই রূপ পাশাপাশি চালানো (differential test) |
| Loop চলার সময় একই list থেকে মোছা বা যোগ করা | কপির ওপর loop, বা নতুন list বানানো; সীমার মান দিয়ে test |
| “-O2-তে switch সবসময় jump table হয়” ধরনের নিশ্চিত দাবি, বা অস্তিত্বহীন flag | সত্যিকারের -S আউটপুট পড়া; flag-এর নাম compiler-এর documentation-এ খোঁজা |
Off-by-one: <= আর < গুলিয়ে ফেলা, শেষ জিনিস বাদ বা একবার বেশি | শূন্য, এক আর দুই জিনিসের input-এ হাতে হিসাব মিলিয়ে দেখা |
AI-কে ভালোভাবে কাজে লাগাতে ভাষা আর version বলে দিন, আর প্রতিটি দাবির যাচাইয়ের উপায় চান:
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 দিয়ে যাচাই করা।
-
নকশা ও বাস্তবায়ন — 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 namestack-এ নিচের দিকে সেই নাম খুঁজবে। Reference-এ বদলাতে হবে lexer-এর keyword তালিকা (এখনbreakএকটি সাধারণ নাম, তাইundefined variable 'break'), আর সিদ্ধান্ত ২১-এর missing-return নিয়ম: break-ওয়ালাwhile trueথাকলেও সেটি “return করে” গণ্য না হওয়াই নিরাপদ, যেমন এখন। -
ভুল খুঁজুন: একজন সহকর্মী একটি 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-এcontinuewhile-এর শর্তে লাফ দেয়, ফলে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{ … }-এর ভেতরে রাখতে হয়। -
হিসাব ও 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) কাজে লাগবে। -
আউটপুট অনুমান করুন: 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 iUnboundLocalErrorদেয়।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি bytecode compiler while c { s }-কে যে ক্রমে নামায়, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- এখনকার নির্দেশ-সংখ্যা top হিসেবে মনে রাখা
- শর্ত c-এর কোড লেখা
- লক্ষ্য ফাঁকা রেখে
JUMP_IF_FALSEলেখা - body s-এর কোড লেখা
JUMP topলেখা- ফাঁকা লক্ষ্যটি পরের নির্দেশের 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 হলে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- সব গঠনই লাফ: if = শর্ত-মিথ্যায় else-এ লাফ + then-শেষে join-এ লাফ; while = ওপরে শর্ত, নিচে পেছনের লাফ। সামনের লাফের লক্ষ্য backpatching দিয়ে পরে ভরা হয়।
- Dangling else: C আর Java-তে else কাছের if-এর; Haat, Rust, Go বন্ধনী বাধ্যতামূলক করে প্রশ্নটিই মুছে দেয়।
- switch: C-তে case হলো label, তাই fall-through; compiler বাছে তুলনার গাছ, jump table বা lookup table, মানের ঘনত্ব আর case-এর কাজ দেখে।
- Loop: গোনা বনাম শর্তের loop; C-র for আসলে শর্তের loop, আর তাকে while-এ নামাতে continue-কে step-এ পাঠাতে হয়। for-each = iterator protocol.
- break, continue, labelled break আর goto cleanup সীমিত লাফ; structured গঠন reducible CFG দেয়, যা compiler-এর বিশ্লেষণ আর Wasm-এর মতো লক্ষ্য দুটিকেই সহজ করে।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ২৮ · Exception handling — try, unwinding আর error valueপরবর্তী পর্বস্বাভাবিক পথের বাইরের লাফ: propagation আর unwinding.
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ০৭ · Imperative আর procedural programmingএই কোর্সেgoto থেকে structured programming, Böhm–Jacopini আর Dijkstra.
- শাখা আর লুপের assemblyপাশের ট্র্যাকRISC-V-তে if, loop rotation আর switch-এর jump table.
- সিদ্ধান্ত — if, else, switchপাশের ট্র্যাকC-র switch আর dangling else, হাতে-কলমে।
- iterator, generator আর yieldপাশের ট্র্যাকPython-এর iterator protocol পুরোটা।