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

Exception handling — try, unwinding আর error value

Exception Handling: try, Stack Unwinding and Error Values

Taught in Bangla, this lesson compares ways to report failure: error codes, Result values, exceptions, panic and Haat v1's halt on a runtime error. It writes try, catch and finally as inference rules, traces unwinding through three frames in Python, and shows a finally return overwriting an earlier one in JavaScript. It covers checked and unchecked exceptions, RAII, setjmp/longjmp versus zero-cost tables with Clang landing pads, CPython's ExceptionTable in a toy VM, and a Result pipeline.

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

  • ব্যর্থতা জানানোর নকশাগুলো (error code, errno, Result, exception, panic) তুলনা করা, আর Haat কোনটি নিয়েছে তা বোঝা
  • try/catch/finally-এর অর্থ inference rule-এ লেখা, আর propagation ও stack unwinding ধাপে ধাপে চালানো
  • finally আর return-এর টানাটানি, checked বনাম unchecked exception, panic, RAII আর exception safety-র নিশ্চয়তা
  • Compiler কীভাবে exception বাস্তবায়ন করে: setjmp/longjmp, zero-cost table, landing pad (সত্যিকারের Clang output) আর CPython-এর ExceptionTable
  • Haat-এর বর্ধিত রূপে throw আর try … catch নকশা করা: syntax, typing rule আর VM-এর exception table

১ · কিছু ব্যর্থ হলে খবরটি কোন পথে যায়

বাজারঘরের গুদামে একজন কর্মী অর্ডার প্যাক করছেন। দেখলেন পণ্যটি নেই। এখন তিনি কী করবেন? এক পথ: স্লিপে একটি লাল দাগ দিয়ে কাজ চালিয়ে যাওয়া, পরে কেউ স্লিপ দেখে বুঝবে। আরেক পথ: সঙ্গে সঙ্গে হাতের কাজ ফেলে সুপারভাইজারকে ডাকা; সুপারভাইজার না পারলে ম্যানেজার, তিনিও না পারলে মালিক। তৃতীয় পথ: গুদামের সাইরেন বাজিয়ে সব কাজ বন্ধ। প্রোগ্রামিং ভাষার error handling-এর নকশা ঠিক এই তিনটির মধ্যে বাছাই।

পর্ব ০৬-এ (ভাষা নকশার লক্ষ্য আর আপস) exception আর error value-এর মৌলিক তুলনা দেখেছেন, আর পর্ব ২৪-এ (Algebraic data type আর pattern matching) দেখেছেন Result type কীভাবে ব্যর্থতাকে type-এ লেখে। এই পর্বের প্রশ্ন গভীরতর: exception-এর ঠিক অর্থ কী, stack ভেঙে ওপরে ওঠা আসলে কীভাবে ঘটে, আর compiler এটি যন্ত্রের নির্দেশে কীভাবে নামায়। আগে সব নকশা এক টেবিলে:

নকশাউদাহরণখবর কোথায় থাকেউপেক্ষা করা যায়?
Error code / sentinelC-র fopen ফেরত দেয় NULL, অনেক function −1সাধারণ ফেরত মানেখুব সহজে
errnoC আর POSIX libraryএকটি আলাদা thread-local variable-এসহজে; আগে ফেরত মান দেখে বুঝতে হয়
Error value (sum type)Rust Result, Haskell Either, C++23 std::expectedফেরত মানের type-একঠিন; মান বের করতে ক্ষেত্রটি সামলাতে হয়
ExceptionC++, Java, Python, JavaScript, C#আলাদা নিয়ন্ত্রণ-পথে, ফেরত মানে নয়না ধরলে program থামে
Panic / abortRust panic!, Go panic, C abort()“এটি ঘটা উচিত ছিল না” — প্রোগ্রামের ভুলসাধারণত ধরার কথা নয়

Haat v1 — runtime error মানে থামা

Haat v1-এ কোনো try বা throw নেই। Reference-এর নকশা-সিদ্ধান্ত ২৬: runtime error program থামায়, আর error-এর আগে ছাপা output থেকে যায়। তিন রকম runtime error: division by zero, 'k' is not initialized yet (সিদ্ধান্ত ১৮) আর ১,০০০-এর বেশি নেস্টেড call-এ stack overflow. বিল কয়েকজনে ভাগের একটি ছোট program:

// বাজারঘর: বিল কয়েকজনে ভাগ
fn share(total: Int, people: Int) -> Int {
    return total / people;
}
fn bill(total: Int, people: Int) -> Int {
    let s = share(total, people);
    print(s);
    return s;
}
print(bill(996, 3));
print(bill(996, 0));
print(1);

সত্যিকারের run, reference বাস্তবায়নের দুই back end (CPython 3.14.4):

~/haat $ python -B haat.py run split.haat
332
332
3:18: runtime error: division by zero
~/haat $ python -B haat.py vm split.haat
332
332
3:18: runtime error: division by zero

প্রথম ডাক দুবার 332 ছাপে (bill-এর ভেতরে একবার, বাইরে একবার)। দ্বিতীয় ডাকে লাইন ৩-এর কলাম ১৮-এর /-এ ভাগ শূন্য দিয়ে (সিদ্ধান্ত ২৪: শূন্য দিয়ে ভাগের error / বা % চিহ্নে)। তখন share, bill আর top level, তিনটি স্তরই একসাথে শেষ; শেষ লাইনের print(1) চলেই না, আর exit status 1. মজার কথা, reference-এর Python কোড নিজে এই থামানো বাস্তবায়ন করেছে Python-এর exception দিয়েই: runtime.py একটি HaatError raise করে, যা Python-এর stack ধরে haat.py-এর except HaatError পর্যন্ত উঠে যায়। অর্থাৎ host ভাষার exception দিয়ে guest ভাষার “থামা” বানানো হয়েছে; অংশ ৮-এ একই কৌশলে Haat-এ ধরা যায় এমন exception যোগ করবেন।

২ · try, catch আর finally-এর অর্থ — নিয়মে লেখা

একটি try-এর তিনটি অংশ। try block: যে কাজে ব্যর্থতা আসতে পারে। catch (Python-এ except): নির্দিষ্ট ধরনের exception এলে কী করতে হবে, অর্থাৎ exception handler. finally: যা ঘটুক, বেরোনোর আগে অবশ্যই যা চলবে। কোন handler চলবে, তা ঠিক হয় চলার সময়ের ডাকার শিকল দেখে, কোডের লেখার গঠন দেখে নয়: যে function আমাকে ডেকেছে, তার handler, না থাকলে তাকে যে ডেকেছে তার। Scope-এর ভাষায় এটি dynamic, যদিও নাম খোঁজার নিয়ম (পর্ব ১৫) static.

Exception ধরার পর কী হয়, তার দুটি মডেল আছে। Termination model: handler চলে, তারপর try-এর পরের লাইন থেকে কাজ এগোয়; যেখানে exception ছোড়া হয়েছিল, সেখানে আর ফেরা হয় না। C++, Java, Python, JavaScript, C#, Ada, সবাই এটি নিয়েছে। Resumption model: handler সমস্যা মিটিয়ে ছোড়ার জায়গাতেই কাজ আবার চালু করতে পারে। PL/I-এর ON-condition আর Common Lisp-এর condition system এর পরিচিত উদাহরণ (ভাবনার প্রশ্ন ১-এ বিস্তার)।

নিয়মগুলো সংক্ষেপে লিখতে একটি বিবৃতির (statement) তিন রকম ফলাফল ধরি: ok (স্বাভাবিকভাবে শেষ), ret(v) (মান v নিয়ে return), আর exc(v) (মান v নিয়ে exception). s ⇓ r পড়ুন “s চালালে ফলাফল r”. প্রতিটি নিয়মে দাগের ওপরে শর্ত (premise), নিচে সিদ্ধান্ত। সরলতার জন্য memory-র অবস্থা বাদ রাখা হলো; পূর্ণ big-step semantics আসবে পর্ব ৪০-এ (Operational semantics).

e ⇓ v
throw e ⇓ exc(v)
(S-Throw)
s1 ⇓ r    r ≠ ok
s1; s2 ⇓ r
(S-Seq-Abrupt)
s1 ⇓ r    r ≠ exc(_)
try s1 catch (m) s2 ⇓ r
(S-Try-Ok)
s1 ⇓ exc(v)    s2[m := v] ⇓ r
try s1 catch (m) s2 ⇓ r
(S-Try-Catch)
s1 ⇓ r1    s2 ⇓ r2
try s1 finally s2 ⇓ (r2 = ok ? r1 : r2)
(S-Finally)
body[params := args] ⇓ exc(v)
f(args) ⇓ exc(v)
(S-Call-Exc)

পড়ুন: S-Seq-Abrupt বলে, প্রথম বিবৃতি যদি স্বাভাবিকভাবে শেষ না হয় (return বা exception), তবে দ্বিতীয়টি চলেই না, আর পুরোটার ফল সেটিই। এটিই “বাকি কাজ বাদ” কথার নিয়ম। S-Try-Catch-এ s2[m := v] মানে handler-এর দেহ চলে যেখানে নাম m-এর মান ছোড়া মান v. S-Finally সবচেয়ে কৌতূহলজনক: finally-র দেহ s2 সব ক্ষেত্রে চলে; s2 স্বাভাবিকভাবে শেষ হলে আগের ফল r1 টিকে থাকে, কিন্তু s2 নিজে return বা throw করলে r2 জিতে যায়, আর r1 হারিয়ে যায়। অংশ ৪-এ এর সত্যিকারের ফল দেখবেন। S-Call-Exc বলে, function-এর দেহ exception দিয়ে শেষ হলে ডাকটিও সেই exception দিয়েই শেষ: propagation-এর নিয়ম। Expression-এও একই ধাঁচ: e1 + e2-এ e1 exception দিলে e2 হিসাবই হয় না, কারণ Haat-এর মতো ভাষায় মূল্যায়ন বাঁ থেকে ডানে (সিদ্ধান্ত ১২)।

প্রস্তাব ২৮.১ — “return করে” এমন দেহ কখনো চুপচাপ শেষ হয় না

Haat-এর বর্ধিত রূপে throw যোগ করে নকশা-সিদ্ধান্ত ২১-এর syntactic নিয়ম বাড়াই: একটি বিবৃতি-তালিকা “return করে”, যদি তাতে একটি return, একটি throw, return করে এমন একটি block, দুই শাখাই return করে এমন if/else, অথবা দুই অংশই return করে এমন try … catch থাকে। দাবি: এমন তালিকা s থেমে গেলে তার ফল কখনো ok নয়।

প্রমাণের রূপরেখা (তালিকার গঠন ধরে induction):

  1. তালিকা s = s1; …; sn, যেখানে কোনো sk নিয়ম অনুযায়ী “return করে”। যদি k-এর আগের কোনো si ok ছাড়া অন্য ফল দেয়, S-Seq-Abrupt অনুযায়ী পুরো তালিকার ফল সেটিই, যা ok নয়।
  2. নইলে sk চলে। return হলে ফল ret(v); throw হলে S-Throw অনুযায়ী exc(v). কোনোটিই ok নয়।
  3. if/else হলে যে শাখাই চলুক, induction-এর অনুমান অনুযায়ী তার ফল ok নয়। try … catch হলে S-Try-Ok-এ ফল s1-এর (ok নয়), S-Try-Catch-এ ফল handler-এর (অনুমান অনুযায়ী ok নয়)।
  4. sk-এর ফল ok নয় বলে S-Seq-Abrupt আবার খাটে, তাই পুরো তালিকার ফলও ok নয়। ∎

“থেমে গেলে” শর্তটি জরুরি: while true {}-এর মতো চিরকালের loop কোনো ফলই দেয় না, তাই নিয়মটি loop-কে গোনে না (সিদ্ধান্ত ২১-এও while কখনো গোনা হয় না)। Type checker এই প্রস্তাবের ওপর ভরসা করে বলতে পারে, -> Int function কখনো মান ছাড়া শেষ হবে না।

৩ · Propagation আর stack unwinding

Exception ছোড়ার মুহূর্তে runtime খোঁজে: বর্তমান function-এ কি এই ধরনের handler আছে? না থাকলে function-টির কাজ ওখানেই শেষ, তার stack frame সরে যায়, আর একই প্রশ্ন যায় ডাকা-পক্ষের কাছে। এই নিচের দিকে নামা হলো exception propagation, আর পথে frame সরানোর কাজটির নাম stack unwinding. Call stack-এর ধারণা পর্ব ১৬-এ দেখেছেন। Python 3.14-এ তিন স্তরের একটি checkout, যেখানে মাঝের স্তরে শুধু finally আছে:

log = []
def parse_amount(raw):
    log.append("    enter parse_amount")
    if raw < 0:
        raise ValueError(f"negative amount {raw}")
    return raw
def charge(raw):
    log.append("  enter charge")
    try:
        a = parse_amount(raw)
        log.append("    charged")           # raise হলে এই লাইন চলে না
        return a
    finally:
        log.append("  charge: finally")     # সব পথেই চলে
def checkout(raw):
    log.append("enter checkout")
    try:
        return charge(raw)
    except ValueError as e:
        log.append(f"checkout caught: {e}")
        return 0

for raw in (500, -7):
    print("result:", checkout(raw))
    print(*log, sep="\n"); log.clear()

def audit():                                # finally নিজেই raise করলে
    try:
        raise ValueError("card declined")
    finally:
        raise KeyError("audit log")
try:
    audit()
except Exception as e:
    print(type(e).__name__, e, "| context:", repr(e.__context__))

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

result: 500
enter checkout
  enter charge
    enter parse_amount
    charged
  charge: finally
result: 0
enter checkout
  enter charge
    enter parse_amount
  charge: finally
checkout caught: negative amount -7
KeyError 'audit log' | context: ValueError('card declined')

সফল পথে (500) finally চলেছে return a-এর পরে, function ফেরার ঠিক আগে। ব্যর্থ পথে (−7) charged লাইনটি নেই: S-Seq-Abrupt অনুযায়ী বাকি কাজ বাদ। charge-এর কোনো except নেই, তবু তার finally চলেছে, আর তা চলেছে checkout-এর handler-এর আগে: Python exception ওপরে তুলতে তুলতেই frame সরায় আর পথের finally চালায়। শেষ লাইন একটি বিপদ দেখায়: finally-র ভেতরে নতুন exception (KeyError) আগেরটিকে (ValueError) প্রতিস্থাপন করেছে, S-Finally-র r2 জেতার ঘটনা। Python অন্তত পুরোনোটিকে __context__-এ রেখে দেয় (exception chaining), তাই traceback-এ দুটিই দেখা যায়।

এবার ব্যর্থ পথটি frame ধরে ধরে দেখুন। ডান পাশের call stack-এ ওপরের নামটি সবচেয়ে নতুন frame:

1def parse_amount(raw):2    if raw < 0: raise ValueError(…)3def charge(raw):4    try: return parse_amount(raw)5    finally: log("charge: finally")6def checkout(raw):7    try: return charge(raw)8    except ValueError: return 0
Call stack (ওপরে নতুন)
frame
exception
  1. checkout(-7). প্রথম frame, আর তার try-এ ঢোকা হলো। এই try-এর handler ValueError ধরে।
  2. charge(-7). দ্বিতীয় frame. এর try-এ কোনো except নেই, শুধু finally.
  3. parse_amount(-7). তৃতীয় frame. -7 < 0, তাই raise ValueError. এখন খোঁজা শুরু: এই function-এ কোনো try নেই।
  4. Unwind ১. handler নেই, তাই parse_amount-এর frame সরানো হলো; return raw কখনো চলবে না। Exception এখন charge-এর ডাকার জায়গায়।
  5. Unwind ২, পথে finally. charge-এর try ValueError ধরে না, কিন্তু finally আছে: সেটি চলে, log-এ charge: finally. finally স্বাভাবিকভাবে শেষ হয়েছে, তাই exception আবার ওঠে, আর charge-এর frame সরে।
  6. Handler. checkout-এর except ValueError মিলেছে। Handler চলে, ফল 0. Termination model: parse_amount-এ আর ফেরা হয় না।

দুটি সূক্ষ্ম বিষয় পরীক্ষায় প্রায়ই আসে। প্রথম, handler বাছাই হয় ক্রমে: একটি try-এ কয়েকটি catch থাকলে ওপর থেকে প্রথম যেটির type মেলে (subclass হলেও মেলে), সেটিই চলে। তাই Java-তে catch (Exception e)-কে catch (IOException e)-এর আগে লিখলে পরেরটি অপ্রাপ্য, আর javac তা compile error হিসেবে ধরে। দ্বিতীয়, handler না পেলে কী হয়, তা ভাষাভেদে আলাদা: Python আর Java-তে stack trace ছাপিয়ে program (বা thread) শেষ; C++-এ std::terminate ডাকা হয়, আর C++ standard অনুযায়ী তার আগে stack unwind হবে কি না, তা implementation-defined. অনুশীলন ৪-এ এর সত্যিকারের ফল দেখবেন। Python-এর try/except-এর পুরো ব্যবহার Python কোর্সের পর্ব ২৫-এ, JavaScript-এর JavaScript কোর্সের পর্ব ২৯-এ.

৪ · finally আর return — কে কাকে মুছে দেয়

S-Finally নিয়মটি কাগজে নিরীহ, বাস্তবে চমক দেয়। JavaScript-এর specification (ECMAScript) এটি বর্ণনা করে completion record দিয়ে: প্রতিটি বিবৃতির ফল একটি রেকর্ড, যার ধরন normal, return, throw, break বা continue, সঙ্গে একটি মান। try block-এর completion তোলা থাকে, finally চলে; finally-র completion normal হলে তোলা completion ফিরে আসে, নইলে finally-রটিই চূড়ান্ত। নিচের block-এ পাঁচটি ক্ষেত্র:

function pay() {
  try { return "paid"; }
  finally { console.log("  finally runs before pay() returns"); }
}
function refund() {
  try { return "paid"; }
  finally { return "refunded"; }          // finally-র return জিতে যায়
}
function swallow() {
  try { throw new Error("card declined"); }
  finally { return "ok?"; }               // exception হারিয়ে গেল!
}
let n = 0;
function counter() {
  try { return n; }                       // ফেরত মান এখনই হিসাব হলো
  finally { n = n + 1; }
}
function loop() {
  const log = [];
  for (const x of [1, 2, 3]) {
    try { if (x === 2) continue; log.push("item " + x); }
    finally { log.push("fin " + x); }
  }
  return log.join(", ");
}
console.log(pay());
console.log(refund());
console.log(swallow());
console.log(counter(), n);
console.log(loop());

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

  finally runs before pay() returns
paid
refunded
ok?
0 1
item 1, fin 1, fin 2, item 3, fin 3

pay: finally চলেছে, কিন্তু তার completion normal, তাই "paid" টিকেছে। refund: finally-র return নতুন completion, "paid" মুছে গেছে। swallow সবচেয়ে বিপজ্জনক: একটি সত্যিকারের ব্যর্থতা (কার্ড প্রত্যাখ্যাত) নিঃশব্দে “সফল” ফেরত মানে বদলে গেছে, কোনো সতর্কতা ছাড়াই। counter দেখায়, return n-এর মান (0) finally চলার আগেই হিসাব হয়ে তোলা থাকে; পরে n বাড়লেও ফেরত মান বদলায় না। loop-এ continue-ও একটি completion: x = 2-এ item যোগ হয়নি, কিন্তু finally চলেছে।

1function refund() {2  try {3    return "paid";4  } finally {5    return "refunded";6  }7}8console.log(refund());
Completion record
try-এর ফল
finally-র ফল
  1. ডাক। refund() শুরু, try-এ ঢোকা হলো।
  2. প্রথম return. return "paid" সঙ্গে সঙ্গে function শেষ করে না; ফল একটি completion: ধরন return, মান "paid".
  3. finally শুরু। try-এর completion একপাশে তোলা থাকে। finally স্বাভাবিকভাবে শেষ হলে এটিই ফিরবে, যেমন pay()-এ ঘটেছিল।
  4. দ্বিতীয় return. finally-র ভেতরে নতুন completion: return "refunded". এটি normal নয়, তাই তোলা completion বাতিল; S-Finally-তে r2 ≠ ok.
  5. ফল। refunded ছাপা হলো। "paid"-এর কোনো চিহ্ন নেই। Try-এর ভেতরে throw থাকলে সেটিও ঠিক এভাবে হারাত (swallow).

একই নিয়ম Python আর Java-তেও খাটে। পার্থক্য সতর্কতায়। CPython 3.14.4-এ একই refund Python-এ লিখে চালানো হলো (সত্যিকারের run):

~/haat $ python fin.py
fin.py:5: SyntaxWarning: 'return' in a 'finally' block
  return "refunded"
refunded

Python 3.14 থেকে PEP 765 অনুযায়ী finally থেকে বেরিয়ে যাওয়া return, break আর continue-এর জন্য compile-এর সময়ে SyntaxWarning আসে; ফল এখনো বদলায়নি (refunded), শুধু সতর্কতা। Java-য় javac-এর -Xlint:finally সতর্কতা আছে (“finally clause cannot complete normally”; এখানে চালানো হয়নি)। নিয়মটি সব ভাষায় একই কেন? কারণ finally-র প্রতিশ্রুতি “সবসময় চলবে”, আর চলার মধ্যে নিজের return বা throw থাকলে ভাষাকে একটি বাছতেই হয়; প্রায় সবাই শেষেরটিকে বেছেছে। C# অন্য পথ নিয়েছে: সেখানে finally থেকে return লেখাই compile error (এখানে চালানো হয়নি)। ভালো অভ্যাস একটিই: finally-তে শুধু পরিষ্কারের কাজ, কোনো return, break বা throw নয়।

৫ · Checked, unchecked আর panic — কোন ব্যর্থতা কার দায়

সব ব্যর্থতা এক রকম নয়। ফাইল না পাওয়া, নেটওয়ার্ক বন্ধ, ভুল ইনপুট: এগুলো প্রত্যাশিত, ভালো program এগুলো সামলায়। Array-র সীমার বাইরে index, null-এর ওপর method: এগুলো প্রোগ্রামারের ভুল, সামলানোর চেয়ে ঠিক করা দরকার। ভাষাগুলো এই তফাত কয়েক ভাবে প্রকাশ করে।

Java exception-কে type-এর গাছে সাজায়। Throwable-এর নিচে Error (JVM-এর বিপর্যয়, যেমন OutOfMemoryError) আর Exception; Exception-এর নিচে RuntimeException. RuntimeException আর Error-এর বংশধর unchecked exception; বাকি সব checked exception, যেমন IOException. Checked হলে compiler জোর করে: method হয় সেটি ধরবে, নয়তো ঘোষণায় throws IOException লিখবে। অর্থাৎ ব্যর্থতার সম্ভাবনা method-এর type-এর অংশ, Result-এর মতোই, শুধু ভিন্ন পথে। এর ফলাফল আর বিতর্ক ভাবনার প্রশ্ন ২-এ; ব্যবহারিক দিক Java কোর্সের পর্ব ২৯-এ.

Rust দুটি পথ আলাদা রাখে। প্রত্যাশিত ব্যর্থতা Result<T, E> আর ? (পর্ব ২৪); প্রোগ্রামারের ভুল panic!, যেমন সীমার বাইরে index. Panic ডিফল্টে stack unwind করে (পথে প্রতিটি মান drop হয়, C++-এর destructor-এর মতো), আর Cargo.toml-এ panic = "abort" দিলে সঙ্গে সঙ্গে থামে। Go-তে প্রথাগত পথ (value, err) ফেরত মান, আর বিরল বিপর্যয়ে panic, যাকে একটি deferred function-এর ভেতরে recover থামাতে পারে। (Rust আর Go-র এই উদাহরণ এখানে চালানো হয়নি।)

Haat v1-এর সব runtime error এই হিসাবে panic-ধাঁচের: ধরার উপায় নেই। শেখার ভাষার জন্য এটি সরল আর সৎ সিদ্ধান্ত: division by zero হলে প্রোগ্রামার নিজেই আগে people == 0 পরীক্ষা করবেন। ধরার সুবিধা চাইলে নকশা লাগবে, যা অংশ ৮-এ।

৬ · RAII আর exception safety — unwinding-এর পথে পরিষ্কার

Exception-এর সবচেয়ে বড় ঝুঁকি হিসাব নয়, পরিষ্কার: ফাইল খোলা থেকে যাওয়া, lock না ছাড়া, অর্ধেক লেখা অর্ডার। C-তে কেউ fopen-এর পরে fclose লেখেন, কিন্তু মাঝের লাইন exception দিলে fclose-এ পৌঁছানোই হয় না: resource leak. C++-এর উত্তর RAII: সম্পদ রাখুন একটি object-এ, যার destructor সম্পদ ফেরত দেয়। Unwinding-এর সময় C++ প্রতিটি সরানো frame-এর সব সম্পূর্ণ তৈরি local object-এর destructor চালায়, তৈরির উল্টো ক্রমে। RAII-এর মৌলিক পরিচয় C++ কোর্সের পর্ব ১৭-এ. সত্যিকারের run, Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8, zig c++ -O2 -std=c++20 -Wall -Wextra:

struct Guard {                       // RAII: constructor নেয়, destructor ফেরত দেয়
    const char *name;
    Guard(const char *n) : name(n) { std::printf("open  %s\n", name); }
    ~Guard() { std::printf("close %s\n", name); }
};
int parse_amount(int raw) {
    Guard g("parse");
    if (raw < 0) throw std::invalid_argument("negative amount");
    return raw;
}
int charge(int raw) {
    Guard g("charge");
    int a = parse_amount(raw);
    std::printf("charged %d\n", a);   // throw হলে এই লাইন চলে না
    return a;
}
int main() {
    try {
        Guard g("checkout");
        charge(500);
        charge(-7);
    } catch (const std::exception &e) {
        std::printf("caught: %s\n", e.what());
    }
}
~/haat $ ./raii
open  checkout
open  charge
open  parse
close parse
charged 500
close charge
open  charge
open  parse
close parse
close charge
close checkout
caught: negative amount

দ্বিতীয় ডাকে charged নেই, কিন্তু তিনটি close-ই আছে, নতুন থেকে পুরোনো ক্রমে। লক্ষ্য করুন close checkout এসেছে caught-এর আগে: Guard g("checkout") try block-এর ভেতরে তৈরি, তাই handler-এ ঢোকার আগেই তার scope শেষ। Python-এ একই কাজ with statement (Python কোর্সের পর্ব ৩৯), Java-য় try-with-resources; দুটিই ভেতরে finally.

Exception safety-র তিন স্তর

পরিষ্কারের পরেও প্রশ্ন থাকে: মাঝপথে exception এলে object-এর অবস্থা কেমন থাকবে? C++ সমাজে ১৯৯০-এর দশকের শেষে (David Abrahams-এর লেখা থেকে পরিচিত) exception safety-র তিনটি স্তর প্রচলিত হয়, নামের সামান্য ভেদসহ:

  • Basic guarantee: কোনো সম্পদ হারায় না, আর object বৈধ কোনো অবস্থায় থাকে, যদিও কোনটি তা আগে থেকে বলা যায় না।
  • Strong guarantee: সব-বা-কিছুই-না। Exception এলে অবস্থা ঠিক আগের মতো, যেন কাজটি শুরুই হয়নি। প্রচলিত কৌশল: একটি কপিতে কাজ করে শেষে exception ছোড়ে না এমন একটি swap.
  • Nothrow guarantee: কাজটি কখনো exception ছোড়ে না। C++11 থেকে destructor ডিফল্টে noexcept; unwinding চলার সময় কোনো destructor থেকে exception বেরোলে std::terminate চলে, কারণ একসাথে দুটি exception সামলানোর কোনো নিয়ম নেই।

বাজারঘরের অর্ডার-তালিকায় একটি অর্ডার যোগ করতে দুটি কাজ: তালিকায় যোগ আর মোট টাকা বাড়ানো। দ্বিতীয়টি exception দিলে প্রথমটি থেকে যায়: অবস্থা বৈধ নয় (মোট ভুল)। কাজের ক্রম বদলে (আগে ছোড়া-সম্ভব কাজ, পরে ছোড়া-অসম্ভব কাজ) strong guarantee পাওয়া যায়। C++-এর std::vector::push_back সাধারণত strong guarantee দেয়, তবে উপাদানের move constructor exception ছুড়তে পারলে নিয়মটি জটিল; বিস্তার C++ কোর্সের পর্ব ৩৭-এ.

৭ · Compiler কীভাবে বাস্তবায়ন করে — setjmp থেকে zero-cost table

যন্ত্রে “throw” বলে কোনো নির্দেশ নেই। Compiler-কে সাধারণ নির্দেশ দিয়ে দুটি কাজ করতে হয়: ঠিক handler খুঁজে বের করা, আর পথের frame-গুলো ঠিকভাবে সরানো, যার মধ্যে আছে stack pointer ও সংরক্ষিত register ফিরিয়ে আনা আর destructor চালানো। দুটি প্রধান কৌশল।

কৌশল ১ — setjmp/longjmp: প্রতিটি try-এ খরচ

C-র standard library-তে setjmp বর্তমান register আর stack pointer-এর একটি “ছবি” একটি jmp_buf-এ রাখে, আর longjmp সেই ছবি ফিরিয়ে এনে সরাসরি সেখানে লাফ দেয়, মাঝের সব frame এক লাফে বাদ। সত্যিকারের run (একই Clang, zig cc -std=c17 -O2 -Wall -Wextra):

static jmp_buf handler;              /* "catch"-এর ঠিকানা আর register-এর ছবি */
static int parse_amount(int raw) {
    if (raw < 0) longjmp(handler, 1);  /* "throw": সরাসরি setjmp-এ ফেরা */
    return raw;
}
static int charge(int raw) {
    printf("open  charge\n");
    int a = parse_amount(raw);
    printf("close charge\n");          /* longjmp হলে এটি কখনো চলে না */
    return a;
}
int main(void) {
    int code = setjmp(handler);        /* প্রথমবার 0 ফেরত দেয় */
    if (code == 0) {
        printf("charged %d\n", charge(500));
        printf("charged %d\n", charge(-7));
    } else {
        printf("caught code %d\n", code);
    }
    return 0;
}

~/haat $ ./sj
open  charge
close charge
charged 500
open  charge
caught code 1

দ্বিতীয় ডাকে close charge নেই: longjmp পথের কোনো পরিষ্কারের কাজ চালায় না, তাই C++-এর destructor বা Python-এর finally-এর মতো কিছু এখানে নিজে থেকে ঘটে না। (C-তে setjmp-এর পরে বদলানো local variable-এর মান longjmp-এর পরে অনির্দিষ্ট হতে পারে, যদি সেটি volatile না হয়; তাই এই কৌশল সাবধানে ব্যবহার করতে হয়।) এর ওপর exception বানাতে হলে প্রতিটি try-এ ঢোকার সময় একটি jmp_buf একটি handler-stack-এ push করতে হয় আর বেরোনোর সময় pop. ফলে exception কখনো না ঘটলেও প্রতিটি try-এ খরচ। কিছু পুরোনো বা বিশেষ target-এ C++ compiler এই “SJLJ” পদ্ধতি ব্যবহার করত; ৩২-বিট Windows-এর পুরোনো SEH-ও এমন frame-ধরে-নিবন্ধন ধাঁচের ছিল বলে জানা যায়।

কৌশল ২ — table-based “zero-cost” unwinding

আধুনিক x86-64 Linux, macOS, ARM64 আর ৬৪-বিট Windows-এ ধারণা উল্টো: সফল পথে কিছুই করবেন না; কোন নির্দেশের ঠিকানায় exception এলে কোথায় যেতে হবে, তা আগেই একটি টেবিলে লিখে রাখুন। খরচ পড়ে শুধু throw-এর মুহূর্তে (আর টেবিলের জন্য program-এর আকারে)। একে বলে zero-cost exceptions; “zero” মানে সফল পথে প্রায় শূন্য বাড়তি নির্দেশ, সব মিলিয়ে শূন্য খরচ নয় (ভাবনার প্রশ্ন ৩)। অংশ ৬-এর charge-কে একটি আলাদা ফাইলে রেখে (যাতে অন্য function inline না হয়) সত্যিকারের Clang 22.1.8 output, zig c++ -target x86_64-linux-gnu -O2 -g0 -S (CFI নির্দেশ বাদ):

_Z6chargei:                     # charge(int)
    pushq   %rbp
    movq    %rsp, %rbp
    pushq   %rbx
    pushq   %rax
    movl    %edi, %ebx
    leaq    -9(%rbp), %rdi
    callq   _ZN5GuardC1Ev@PLT   # Guard g;
.Ltmp0:                         # EH_LABEL
    movl    %ebx, %edi
    callq   _Z12parse_amounti@PLT
.Ltmp1:                         # EH_LABEL
.Ltmp2:                         # EH_LABEL
    movl    %eax, %ebx
    movl    %eax, %edi
    callq   _Z10log_chargei@PLT
.Ltmp3:                         # EH_LABEL
    leaq    -9(%rbp), %rdi
    callq   _ZN5GuardD1Ev@PLT   # সফল পথ: ~Guard()
    movl    %ebx, %eax
    addq    $8, %rsp
    popq    %rbx
    popq    %rbp
    retq
.LBB0_3:                        # landing pad
.Ltmp4:                         # EH_LABEL
    movq    %rax, %rbx
    leaq    -9(%rbp), %rdi
    callq   _ZN5GuardD1Ev@PLT   # unwinding পথ: ~Guard()
    movq    %rbx, %rdi
    callq   _Unwind_Resume@PLT  # exception আরও নিচে পাঠাও
GCC_except_table0:
    ...
    .uleb128 .Lfunc_begin0-.Lfunc_begin0  # >> Call Site 1 <<
    .uleb128 .Ltmp0-.Lfunc_begin0         #   Call between .Lfunc_begin0 and .Ltmp0
    .byte   0                             #     has no landing pad
    .uleb128 .Ltmp0-.Lfunc_begin0         # >> Call Site 2 <<
    .uleb128 .Ltmp3-.Ltmp0                #   Call between .Ltmp0 and .Ltmp3
    .uleb128 .Ltmp4-.Lfunc_begin0         #     jumps to .Ltmp4
    .uleb128 .Ltmp3-.Lfunc_begin0         # >> Call Site 3 <<
    .uleb128 .Lfunc_end0-.Ltmp3           #   Call between .Ltmp3 and .Lfunc_end0
    .byte   0                             #     has no landing pad

(মন্তব্যের # Guard g;, # landing pad ইত্যাদি বাংলা/ইংরেজি টীকা আমাদের যোগ করা; বাকিটা compiler-এর। .gcc_except_table-এর কয়েকটি encoding-লাইন ... দিয়ে বাদ, আর .Lfunc_begin0-এর মতো কয়েকটি label ও directive-এর লাইনও বাদ।) সফল পথ (retq পর্যন্ত) পড়ুন: সাধারণ call, আর কোনো বাড়তি পরীক্ষা নেই। .LBB0_3 হলো landing pad: exception এলে unwinder এখানে আসে, ~Guard() চালায়, তারপর _Unwind_Resume দিয়ে exception-কে আরও নিচের frame-এ পাঠায়, কারণ charge-এ কোনো catch নেই। টেবিলটি বলে: parse_amount আর log_charge-এর call (.Ltmp0 থেকে .Ltmp3) থেকে exception এলে .Ltmp4-এ যান; Guard-এর constructor-এর call (Call Site 1)-এ কোনো landing pad নেই, কারণ তখনো g তৈরিই হয়নি, ধ্বংস করার কিছু নেই।

একই function-এর LLVM IR (-S -emit-llvm, একই flag) ধারণাটি আরও পরিষ্কার দেখায়: যে call exception দিতে পারে, তা call নয়, invoke, যার দুটি গন্তব্য:

  %3 = invoke noundef i32 @_Z12parse_amounti(i32 noundef %0)
          to label %4 unwind label %6
...
6:                                                ; preds = %4, %1
  %7 = landingpad { ptr, i32 }
          cleanup
  call void @_ZN5GuardD1Ev(ptr noundef nonnull align 1 dereferenceable(1) %2) #4
  call void @llvm.lifetime.end.p0(ptr nonnull %2) #4
  resume { ptr, i32 } %7

to label %4 স্বাভাবিক ফেরার পথ, unwind label %6 exception-এর পথ। landingpad … cleanup বলে “এখানে শুধু পরিষ্কার, ধরা নয়”, আর resume exception-কে আবার চালু করে। Control flow graph-এ (পর্ব ৬২) প্রতিটি invoke থেকে তাই দুটি তীর; optimizer-কে এই বাড়তি তীরগুলোও মানতে হয়। LLVM IR-এর বিস্তার পর্ব ৬৮-এ।

দুই ধাপের unwinding

Linux-এর C++ (Itanium C++ ABI নামে পরিচিত নিয়ম) throw-এর পরে unwinding চালায় দুই ধাপে। ধাপ ১, খোঁজা (search): unwinder stack ধরে নিচে নামে, কিছু না বদলে; প্রতিটি frame-এর জন্য ভাষার personality routine (C++-এ __gxx_personality_v0) টেবিল পড়ে বলে “এখানে মেলা catch আছে কি?”. ধাপ ২, পরিষ্কার (cleanup): handler পাওয়া গেলে unwinder আবার ওপর থেকে নামে, এবার প্রতিটি landing pad চালিয়ে frame সরায়, শেষে handler-এ ঢোকে। Handler না পেলে ধাপ ১-এই std::terminate; তখন ধাপ ২ না চালানোর সুযোগ থাকে, তাই অংশ ৩-এর “implementation-defined”. সুবিধা: crash-এর সময় stack অক্ষত থাকে, তাই debugger ঠিক কোথায় throw হয়েছিল তা দেখাতে পারে।

ছবি ২৮.১ — charge(-7)-এ দুই ধাপের unwinding

বাঁয়ে call stack (ওপরে নতুন), মাঝে দুই ধাপ, নিচে charge-এর টেবিল

Two-phase unwinding: phase 1 searches frames for a handler, phase 2 runs the landing pad in charge and enters the catch in checkout parse_amount throw (raw < 0) charge Guard g; pad: ~Guard() checkout catch (exception&) main ধাপ ১ খোঁজা catch নেই catch ✓ ধাপ ২ পরিষ্কার pad চলে catch-এ ঢোকা call stack — ওপরে নতুন frame charge-এর call-site টেবিল Guard() → pad নেই parse_amount, → .Ltmp4 log_charge (cleanup)
ছবি ২৮.১ — নীল ড্যাশ তীর (ধাপ ১) কিছু বদলায় না: parse_amount-এ catch নেই, charge-এ শুধু cleanup, checkout-এ মেলা catch. তারপর লাল তীর (ধাপ ২) একই পথে নামে, charge-এর landing pad-এ থেমে ~Guard() চালায়, শেষে checkout-এর catch-এ ঢোকে। main-এ কেউ পৌঁছায় না।

CPython-এর ExceptionTable আর একটি খেলনা VM

Bytecode VM-ও একই বাছাইয়ের মুখোমুখি। CPython 3.10 পর্যন্ত প্রতিটি try-এ একটি block-setup নির্দেশ চলত (setjmp ধাঁচ); CPython 3.11 থেকে “zero-cost” exception: try-তে ঢুকতে কোনো নির্দেশ নেই, আর প্রতিটি code object-এ একটি exception table. CPython 3.14.4-এর dis, সত্যিকারের run:

def charge(raw):
    try:
        a = parse(raw)
    except ValueError:
        a = 0
    return a

   4           NOP
   5   L1:     LOAD_GLOBAL              1 (parse + NULL)
               LOAD_FAST_BORROW         0 (raw)
               CALL                     1
               STORE_FAST               1 (a)
   8   L2:     LOAD_FAST_BORROW         1 (a)
               RETURN_VALUE
  --   L3:     PUSH_EXC_INFO
   6           LOAD_GLOBAL              2 (ValueError)
               CHECK_EXC_MATCH
               POP_JUMP_IF_FALSE        7 (to L5)
               …
ExceptionTable:
  L1 to L2 -> L3 [0]
  L3 to L4 -> L6 [1] lasti
  L5 to L6 -> L6 [1] lasti

(প্রথম লাইনের RESUME আর handler-এর কয়েকটি নির্দেশ বাদ।) try:-এর লাইন ৪-এ শুধু একটি NOP; সফল পথ L1 থেকে সোজা RETURN_VALUE. টেবিলের প্রথম সারি: L1 থেকে L2-এর মধ্যে exception এলে L3-এ যান, আর operand stack-এর গভীরতা [0]-এ নামান। L3-এর handler CHECK_EXC_MATCH দিয়ে type মেলায়; না মিললে L5-এর RERAISE. এটিই Clang-এর call-site টেবিলের bytecode রূপ। নিচের block Haat-এর বর্ধিত রূপের জন্য একই নকশার একটি খেলনা VM: THROW নির্দেশ, আর প্রতিটি function-এর টেবিলে (শুরু, শেষ, handler, stack-গভীরতা)।

# Haat-এর বর্ধিত রূপের খেলনা VM: THROW আর exception table (zero-cost ধাঁচ)
def program(share_body):
    return {
      "main":  {"ins": [("CALL", "bill"), ("PRINT",), ("CONST", "done"), ("PRINT",),
                        ("HALT",), ("PRINT",), ("JUMP", 2)],
                "table": [(0, 2, 5, 0)]},     # [0, 2)-এ throw হলে 5-এ যান, stack গভীরতা 0
      "bill":  {"ins": [("CALL", "share"), ("RET",)], "table": []},
      "share": {"ins": share_body, "table": []}}

def run(code):
    frames, stack, out, count = [["main", 0]], [], [], 0
    while True:
        fr = frames[-1]; op = code[fr[0]]["ins"][fr[1]]; fr[1] += 1; count += 1
        if op[0] == "CONST": stack.append(op[1])
        elif op[0] == "PRINT": out.append(stack.pop())
        elif op[0] == "JUMP": fr[1] = op[1]
        elif op[0] == "CALL": frames.append([op[1], 0])
        elif op[0] == "RET": frames.pop()          # ফেরত মান stack-এ থেকে যায়
        elif op[0] == "HALT": return out, count
        elif op[0] == "THROW":
            exc = stack.pop()
            while frames:                          # unwinding: ওপরের frame থেকে নিচে
                fn, ip = frames[-1]; at = ip - 1   # এই frame এখন কোন নির্দেশে
                hit = [(h, d) for s, e, h, d in code[fn]["table"] if s <= at < e]
                if hit:
                    del stack[hit[0][1]:]; stack.append(exc)
                    frames[-1][1] = hit[0][0]; out.append(f"<handler {fn}@{hit[0][0]}>")
                    break
                out.append(f"<unwind {fn}>"); frames.pop()
            else:
                return out + [f"uncaught: {exc}"], count

print(run(program([("CONST", 332), ("RET",)])))
print(run(program([("CONST", "division by zero"), ("THROW",)])))

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

([332, 'done'], 9)
(['<unwind share>', '<unwind bill>', '<handler main@5>', 'division by zero', 'done'], 9)

main-এর কোড মানে try { print(bill()); } catch (m) { print(m); } print("done");. সফল run-এ ৯টি নির্দেশ চলেছে, আর তার কোনোটিই try-এর জন্য নয়: টেবিল শুধু পড়া হয় throw হলে। দ্বিতীয় run-এ share THROW করে; unwinder প্রথমে share-এর টেবিল দেখে (খালি), frame সরায়; তারপর bill; তারপর main, যার CALL নির্দেশ (index 0) টেবিলের [0, 2) পরিসরে, তাই handler 5-এ লাফ, stack গভীরতা 0-তে নামিয়ে message push. Reference-এর আসল VM-এ (৩১টি opcode) THROW নেই; এটি পর্ব ৫৯-এর (Stack-based virtual machine) VM-এ যোগ করার একটি প্রস্তাব।

৮ · Error value বনাম exception, আর Haat-এর বর্ধিত রূপ

Exception-এর বিকল্প হিসেবে Result-এর গঠন আর গণনা পর্ব ২৪-এ দেখেছেন; এখানে প্রশ্ন নিয়ন্ত্রণ-প্রবাহের। Result দিয়ে লেখা একটি ধাপে-ধাপে কাজের শিকলে (pipeline) একটি ধাপ ব্যর্থ হলে বাকি ধাপ চলে না, ঠিক exception-এর মতো, কিন্তু কোনো লাফ ছাড়াই: প্রতিটি ধাপ শুধু দেখে আগের ফল Ok না Err. Rust-এর ? এই পরীক্ষার desugaring. বাজারঘরের অর্ডার, দুই পদ্ধতিতে:

from dataclasses import dataclass
@dataclass
class Ok:  value: object
@dataclass
class Err: reason: str

PRICES, STOCK, steps = {101: 520, 102: 60}, {101: 5, 102: 0}, []
def parse_qty(s):
    steps.append("parse"); return Ok(int(s)) if s.isdigit() else Err(f"bad qty {s!r}")
def lookup(code, qty):
    steps.append("lookup")
    return Ok((PRICES[code], qty)) if code in PRICES else Err(f"unknown product {code}")
def in_stock(code, unit, qty):
    steps.append("stock"); return Ok(unit * qty) if STOCK[code] >= qty else Err("out of stock")

def bind(r, f):                     # Rust-এর ? / and_then: Err হলে সঙ্গে সঙ্গে ফেরত
    return f(r.value) if isinstance(r, Ok) else r
def order_result(code, s):
    r = parse_qty(s)
    r = bind(r, lambda q: lookup(code, q))
    return bind(r, lambda uq: in_stock(code, *uq))

class OrderError(Exception): pass
def order_exc(code, s):             # একই কাজ, exception দিয়ে
    if not s.isdigit(): raise OrderError(f"bad qty {s!r}")
    if code not in PRICES: raise OrderError(f"unknown product {code}")
    if STOCK[code] < int(s): raise OrderError("out of stock")
    return PRICES[code] * int(s)

for code, s in [(101, "2"), (205, "2"), (101, "x"), (102, "1")]:
    steps.clear(); r = order_result(code, s)
    try: e = order_exc(code, s)
    except OrderError as ex: e = f"raised: {ex}"
    print(f"{code} {s!r:4} {str(r):34} steps={len(steps)} | {e}")

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

101 '2'  Ok(value=1040)                     steps=3 | 1040
205 '2'  Err(reason='unknown product 205')  steps=2 | raised: unknown product 205
101 'x'  Err(reason="bad qty 'x'")          steps=1 | raised: bad qty 'x'
102 '1'  Err(reason='out of stock')         steps=3 | raised: out of stock

দুই পদ্ধতির উত্তর প্রতিটি সারিতে মেলে, আর steps দেখায় Result-এর শিকলও প্রথম ব্যর্থতার পরে থামে: অজানা পণ্যে ২টি ধাপ, ভুল সংখ্যায় ১টি। পার্থক্য কোথায় দেখা যায়: order_result-এর ফেরত মানের type-এ ব্যর্থতা আছে, ডাকা-পক্ষ তা উপেক্ষা করতে পারে না; order_exc-এর সই দেখে বোঝার উপায় নেই কী কী ছুড়তে পারে। উল্টো দিকে exception সংস্করণ ছোট, কারণ মাঝের ধাপগুলোকে কিছুই লিখতে হয়নি।

1r = parse_qty("2")2r = bind(r, lambda q: lookup(205, q))3r = bind(r, lambda uq: in_stock(205, *uq))4return r
Pipeline-এর অবস্থা
r
steps
  1. parse_qty. "2" সংখ্যা, তাই Ok(2). steps-এ একটি ধাপ।
  2. প্রথম bind. ফল Ok, তাই ভেতরের মান 2 নিয়ে lookup(205, 2) ডাকা হলো। 205 দামের তালিকায় নেই: Err.
  3. দ্বিতীয় bind. ফল Err, তাই bind function-টি ডাকেই না, Err-টিই ফেরত দেয়। in_stock চলেনি, steps এখনো ২। এটিই error value-এর “short-circuit”, কোনো stack না ভেঙেই।
  4. ফল। Err(reason='unknown product 205'). Exception সংস্করণ একই জায়গায় থেমেছিল, তবে লাফ দিয়ে: দ্বিতীয় if-এ raise, তৃতীয় if চলেনি।

Haat-এর বর্ধিত রূপ — throw আর try … catch

Haat-এ ধরা যায় এমন exception যোগ করলে কী কী বদলাতে হবে? একটি নকশার খসড়া (reference বাস্তবায়ন করে না):

// Haat-এর বর্ধিত রূপ (reference-এ নেই)
fn share(total: Int, people: Int) -> Int {
    if people == 0 { throw "no people to share"; }
    return total / people;
}
try {
    print(share(996, 3));
    print(share(996, 0));
    print(0);
} catch (msg) {
    print("error: " + msg);
}
print("done");
  • Lexer: নতুন keyword throw try catch. পুরোনো কোডে এই নামের variable থাকলে তা ভাঙবে; নতুন keyword যোগের এটিই চিরকালের দাম।
  • Parser আর AST: নতুন node Throw(value) আর Try(body: Block, name, handler: Block); throw একটি বিবৃতি, যেমন print (সিদ্ধান্ত ৮).
  • Typing: সরলতম নকশায় ছোড়া মান সবসময় Str. দুটি নিয়ম: Γ ⊢ e : Str হলে throw e; বৈধ; আর Γ ⊢ B1 ok এবং Γ, msg : Str ⊢ B2 ok হলে try B1 catch (msg) B2 বৈধ, যেখানে msg শুধু handler-এর নতুন scope-এ দেখা যায়। প্রস্তাব ২৮.১-এর missing-return নিয়মও লাগবে।
  • Runtime error: division by zero কি ধরা যাবে? সুবিধাজনক: হ্যাঁ, message "division by zero" দিয়ে। কিন্তু stack overflow ধরতে দিলে handler চালানোর জন্যই stack লাগবে; অনেক ভাষা এই ধরনের বিপর্যয়কে আলাদা রাখে (Java-র StackOverflowError একটি Error).
  • বাস্তবায়ন: tree-walking interpreter-এ (পর্ব ৫৬) host-এর exception দিয়ে সহজ, যেমন reference-এর interp.py নিজেই return বাস্তবায়ন করে Python-এর একটি exception (ReturnSignal) দিয়ে, আর call-এর গভীরতা কমায় একটি finally-তে। Bytecode VM-এ অংশ ৭-এর মতো THROW আর প্রতিটি Code-এ exception table.

Reference-এর interp.py-এর call-এর অংশটি (সত্যিকারের কোড, হুবহু):

    def call(self, f, args, node):
        if self.depth >= MAX_CALL_DEPTH:
            raise runtime_error(node.line, node.col, "stack overflow")
        env = Env(f.env)                  # parameters and body share this scope
        env.vars.update(zip(f.params, args))
        self.depth += 1
        try:
            self.exec_block(f.body, env)
            return None                   # fell off the end: Unit
        except ReturnSignal as r:
            return r.value
        finally:
            self.depth -= 1

এখানে return নিজেই একটি “exception”, যা Python-এর stack ভেঙে নিকটতম call পর্যন্ত ওঠে; আর runtime error হলেও finally গভীরতার হিসাব ঠিক রাখে। অনুশীলন ৩-এ এই কৌশলে throw আর try যোগ করবেন।

PL/I (১৯৬০-এর দশক) ON-condition দিয়ে exception-এর মতো সুবিধা মূলধারায় আনে। John Goodenough-এর ১৯৭৫ সালের প্রবন্ধ (Communications of the ACM) সমস্যাটিকে সুশৃঙ্খল ভাষায় আলোচনা করে। Barbara Liskov আর Alan Snyder-এর CLU (প্রবন্ধ ১৯৭৯) termination model আর function-এর ঘোষণায় সম্ভাব্য exception লেখার ধারণা দেয়; Ada (১৯৮৩) exception-কে ভাষার মূল অংশ করে। Andrew Koenig আর Bjarne Stroustrup-এর C++ exception-এর নকশা (প্রবন্ধ ১৯৮৯–৯০ নাগাদ) পরে C++98-এ মানে আসে; Java (১৯৯৫) checked exception যোগ করে। CPython 3.11 (২০২২) zero-cost exception আনে, আর Python 3.14 (২০২৫) finally থেকে return-এ সতর্কতা।

আরও গভীরে: table-based unwinding-এর আসল যন্ত্র DWARF-এর CFI (call frame information): প্রতিটি নির্দেশের ঠিকানায় কোন register কোথায় সংরক্ষিত, তার একটি ছোট “program”, যা .eh_frame section-এ থাকে; ছেঁটে ফেলা .cfi_ নির্দেশগুলো এটিই বানায়। ৬৪-বিট Windows একই ধারণার নিজস্ব রূপ (unwind info আর SEH) ব্যবহার করে। Herb Sutter-এর ২০১৮ সালের প্রস্তাব P0709 (“zero-overhead deterministic exceptions”) C++-এ exception-কে ফেরত-মানের মতো সস্তা করার একটি পথ দেখিয়েছিল, যা এখনো মানে আসেনি; আর WebAssembly-তে exception handling-এর নির্দেশ সাম্প্রতিক সংস্করণে মানে যোগ হয়েছে বলে জানা যায় (ব্রাউজার আর runtime-ভেদে সমর্থন যাচাই করুন)।

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

  • Termination আর resumption model-এর পার্থক্য? Termination-এ handler-এর পরে ছোড়ার জায়গায় আর ফেরা হয় না; resumption-এ ফেরা যায়। মূলধারার প্রায় সব ভাষা termination.
  • Stack unwinding কী? Handler না পাওয়া পর্যন্ত frame একে একে সরানো, পথে finally বা destructor চালানো।
  • try-তে return 1, finally-তে return 2 হলে ফল? Java, JavaScript আর Python-এ 2; finally-র abrupt completion আগেরটি মুছে দেয় (C#-এ এমন লেখা compile error).
  • Checked আর unchecked exception? Checked (Java-র IOException) ধরতে বা ঘোষণা করতে compiler বাধ্য করে; unchecked (RuntimeException, Error) করে না।
  • Zero-cost exception কেন “zero-cost”? Handler-এর তথ্য টেবিলে থাকে, তাই exception না ঘটলে সফল পথে বাড়তি নির্দেশ চলে না; খরচ throw-এর সময়ে আর program-এর আকারে।

৯ · AI-এর যুগে exception handling

try/catch লিখতে AI assistant খুব দ্রুত, কিন্তু এই বিষয়ে কিছু ভুল বারবার দেখা যায়, আর সেগুলো বেশিরভাগ সময় “চলে”, শুধু ব্যর্থতার দিন ধরা পড়ে:

AI-এর ভুলকীভাবে ধরবেন
সব exception ধরে চুপ করানো (except Exception: pass, খালি catch)প্রতিটি catch কোন নির্দিষ্ট ব্যর্থতা সামলায় তা জিজ্ঞেস করা; ইচ্ছা করে ব্যর্থতা ঘটিয়ে test
finally-তে return বা পরিষ্কারের কাজে নতুন exception, যা আসল ব্যর্থতা মুছে দেয়Python 3.14-এর SyntaxWarning পড়া; finally-তে শুধু পরিষ্কার
এক ভাষার নিয়ম অন্য ভাষায় (“C++-এ uncaught exception-এও সব destructor চলে”, “Python-এ checked exception আছে”)ভাষার standard বা documentation; সেই compiler-এ চালিয়ে দেখা
সাধারণ catch বিশেষটির আগে, ফলে বিশেষটি অপ্রাপ্যCompiler-এর error/warning; প্রতিটি catch-এর জন্য আলাদা test
“exception সবসময় ধীর” বা “zero-cost মানে কোনো খরচ নেই”-এর মতো ঢালাও দাবিনিজের যন্ত্রে দুই সংস্করণ মেপে দেখা; সত্যিকারের -S output পড়া
বানানো compiler flag বা ABI-র বিবরণ, যা বাস্তব output-এর সঙ্গে মেলে নাclang -S, -emit-llvm, dis চালিয়ে মিলিয়ে নেওয়া

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

আমি Python 3.14 আর C++20 (Clang)-এ একটি দোকানের checkout লিখছি: parse → stock check → charge, যেকোনো ধাপ ব্যর্থ হতে পারে। ১. দুই ভাষায় এমন কোড লেখো, যেখানে প্রতিটি catch/except একটি নির্দিষ্ট ব্যর্থতা ধরে; কোনো খালি বা ঢালাও catch রাখবে না। ২. ফাইল আর lock-এর মতো সম্পদ C++-এ RAII আর Python-এ with দিয়ে সামলাও; finally-র ভেতরে return বা throw রাখবে না। ৩. প্রতিটি function কোন exception-safety নিশ্চয়তা (basic, strong, nothrow) দেয়, এক লাইনে বলো আর কারণ দাও। ৪. প্রতিটি ব্যর্থতার পথের জন্য একটি test দাও, যা ইচ্ছা করে সেই ব্যর্থতা ঘটায়। ৫. কোনো ভাষার নিয়ম নিয়ে নিশ্চিত না হলে "নিশ্চিত নই" বলো, আর কোন documentation-এ আছে তা বলো।

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

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

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

প্র ০১Resumption model শুনতে বেশি শক্তিশালী। তবু মূলধারার প্রায় সব ভাষা termination model নিল কেন?

Resumption-এ handler সমস্যা মিটিয়ে বলতে পারে “যেখানে ছিলে সেখান থেকে চালিয়ে যাও”। PL/I-এর ON-condition-এ এটি সম্ভব ছিল, আর Xerox PARC-এর Mesa ভাষাতেও (১৯৭০-এর দশক) resumption ছিল। কাগজে এটি বেশি সাধারণ: termination আসলে resumption-এর একটি বিশেষ ক্ষেত্র, যেখানে handler কখনো ফেরে না। তবু Goodenough-এর ১৯৭৫ সালের আলোচনার পর থেকে CLU, Ada, C++, Java, Python, সবাই termination বেছেছে।

প্রধান কারণ যুক্তি দেওয়ার সরলতা। Termination-এ throw-এর পরের লাইন কখনো চলে না, তাই প্রোগ্রামার জানেন exception-এর পরে কোন অবস্থা ধরে নেওয়া যাবে না। Resumption-এ throw-এর পরের লাইন চলতেও পারে, না-ও পারে; তাই প্রতিটি throw-এর জায়গাকে দুই সম্ভাবনার জন্যই প্রস্তুত থাকতে হয়, আর handler-কে জানতে হয় নিচের function-এর ভেতরের খুঁটিনাটি, যা encapsulation ভাঙে। Stroustrup তাঁর C++-এর নকশার ইতিহাস-বইয়ে উল্লেখ করেছেন যে C++-এর নকশার আলোচনায় Mesa-র বড় সিস্টেমের অভিজ্ঞতা গুরুত্ব পেয়েছিল: সেখানে resumption প্রায় শুধু খুঁজে বের করার কাজে লাগত, আর কয়েকটি ক্ষেত্রে তুলে দিলে কোড সরলই হয়েছিল (বর্ণনাটি তাঁর লেখা থেকে, বিস্তার ভিন্ন উৎসে একটু আলাদা)।

দ্বিতীয় কারণ বাস্তবায়ন। Termination-এ unwinding শেষ হলে frame-গুলো সত্যিই চলে যায়, stack সরল থাকে। Resumption-এ handler চলার সময় throw-এর frame বেঁচে থাকতে হয়, তাই handler আসলে stack-এর ওপরে আরেকটি call, আর unwinding পিছিয়ে যায়।

তবে resumption মরে যায়নি। Common Lisp-এর condition system “restart” দিয়ে এটি সুন্দরভাবে রাখে: নিচের function জানায় কোন কোন উপায়ে চালিয়ে যাওয়া সম্ভব (যেমন “এই লাইন বাদ দাও”, “ডিফল্ট মান নাও”), আর ওপরের handler নীতি ঠিক করে কোনটি নেবে। আধুনিক গবেষণার algebraic effect আর effect handler (OCaml 5-এ ২০২২ সালে যুক্ত) এই ধারণার সাধারণ রূপ, যেখানে handler একটি continuation পায় আর চাইলে তা চালিয়ে কাজ আবার শুরু করতে পারে; generator আর async-এর সঙ্গে এর আত্মীয়তা পর্ব ৩১-এ (Generator, coroutine আর async/await) দেখবেন।

মূল উপলব্ধি: Termination model কম শক্তিশালী কিন্তু বোঝা, যুক্তি দেওয়া আর বাস্তবায়ন করা সহজ; resumption-এর শক্তি টিকে আছে Lisp-এর restart আর আধুনিক effect handler-এ।

প্র ০২Java-র checked exception একটি বড় পরীক্ষা ছিল। পরের ভাষাগুলো কেন তা নেয়নি, আর “typed throws” আবার ফিরছে কেন?

Java (১৯৯৫) CLU আর Modula-3-এর ধারণা নিয়ে method-এর সইয়ে সম্ভাব্য exception লেখা বাধ্যতামূলক করে। উদ্দেশ্য স্পষ্ট: ফাইল না পাওয়ার মতো প্রত্যাশিত ব্যর্থতা কেউ ভুলে যাবেন না, compiler মনে করিয়ে দেবে। ছোট program-এ এটি চমৎকার কাজ করে।

সমস্যা দেখা দেয় বড় সিস্টেমে, দুই দিক থেকে। প্রথম, version বদলের সমস্যা: একটি library-র method নতুন সংস্করণে একটি নতুন checked exception ছুড়লে, তার সব ব্যবহারকারীর কোড compile হওয়া বন্ধ, যদিও তাদের অনেকে ব্যর্থতাটি সামলাতেই চান না, শুধু ওপরে পাঠাতে চান। দ্বিতীয়, স্তর বাড়ার সমস্যা: দশ স্তর নিচের একটি ডেটাবেস exception প্রতিটি স্তরের সইয়ে লিখতে হয়, অথবা প্রতিটি স্তরে মুড়িয়ে নতুন exception বানাতে হয়। C#-এর প্রধান নকশাকার Anders Hejlsberg ২০০৩ সালের একটি সাক্ষাৎকারে এই দুই কারণ দেখিয়ে বলেছিলেন কেন C# checked exception নেয়নি। বাস্তবে অনেক Java কোডে দেখা যায় catch (Exception e) {} দিয়ে চুপ করানো, যা কোনো নিয়ম না থাকার চেয়েও খারাপ। Java 8-এর lambda আর stream আসার পর সমস্যা বাড়ে: Function interface-এর method কোনো checked exception ঘোষণা করে না, তাই lambda-র ভেতর থেকে IOException ছোড়া যায় না। Kotlin আর Scala JVM-এ চলেও checked exception রাখেনি।

তবু ধারণাটির মূল, “ব্যর্থতা type-এর অংশ”, হারিয়ে যায়নি; ফিরেছে অন্য রূপে। Rust-এর Result<T, E> এই কাজটিই করে, কিন্তু সাধারণ generic type হিসেবে, তাই lambda আর iterator-এর সঙ্গে স্বাভাবিকভাবে মেলে, আর ? ওপরে পাঠানো সহজ করে। Swift-এ throws চিহ্ন বাধ্যতামূলক কিন্তু শুরুতে কোন type ছোড়া হবে তা লেখা যেত না; Swift 6 (২০২৪) থেকে ঐচ্ছিক “typed throws” এসেছে বলে জানা যায়। শিক্ষা: নিশ্চয়তা আর নমনীয়তার ভারসাম্য দরকার। ব্যর্থতার অস্তিত্ব সইয়ে রাখা প্রায় সবসময় লাভজনক; ব্যর্থতার সঠিক type-তালিকা সব স্তরে বাধ্য করা প্রায়ই বোঝা।

মূল উপলব্ধি: Checked exception-এর লক্ষ্য ঠিক ছিল, কিন্তু version বদল আর higher-order function-এর সঙ্গে খাপ খায়নি; generic Result আর ঐচ্ছিক typed throws একই লক্ষ্যে কম ঘর্ষণের পথ।

প্র ০৩“Zero-cost” exception কি সত্যিই বিনা খরচে? কিছু C++ কোডবেস exception পুরো বন্ধ রাখে কেন?

“Zero-cost” কথাটির সংকীর্ণ অর্থ: exception না ঘটলে সফল পথে কোনো বাড়তি নির্দেশ চলে না। অংশ ৭-এর Clang output এটি দেখিয়েছে: charge-এর সফল পথে শুধু সাধারণ call আর একটি destructor-call, কোনো পরীক্ষা নেই। কিন্তু খরচ অন্তত চার জায়গায় লুকিয়ে থাকে।

প্রথম, আকার। প্রতিটি function-এর জন্য unwind টেবিল আর landing pad-এর কোড program-এ থাকে, এমনকি কোনো দিন না চললেও। ছোট embedded যন্ত্রে এটি গুরুত্বপূর্ণ। দ্বিতীয়, optimization-এর বাধা। IR-এ প্রতিটি invoke-এর একটি বাড়তি তীর আছে; optimizer-কে মানতে হয় যে প্রায় প্রতিটি call-এর পরে হঠাৎ landing pad-এ যাওয়া সম্ভব, তাই কিছু কোড সরানো বা মেলানো কঠিন হয়। C++-এ noexcept লিখলে compiler এই তীর বাদ দিতে পারে; তাই move constructor-এ noexcept লেখা প্রায়ই পরামর্শ দেওয়া হয়। তৃতীয়, throw-এর মুহূর্তের খরচ বেশ বড়: exception object তৈরি (প্রায়ই heap-এ), দুই ধাপে টেবিল খোঁজা, প্রতিটি frame-এর register ফিরিয়ে আনা। তাই exception-কে স্বাভাবিক নিয়ন্ত্রণ-প্রবাহ হিসেবে ব্যবহার (যেমন loop থেকে বেরোতে) খারাপ অভ্যাস। চতুর্থ, পূর্বানুমানযোগ্যতা: throw-এর সময় কত লাগবে তা stack-এর গভীরতা আর টেবিলের আকারের ওপর নির্ভর করে, যা real-time সিস্টেমে সমস্যা।

এই কারণে কিছু বড় C++ কোডবেস, অনেক game engine আর embedded প্রকল্প -fno-exceptions দিয়ে compile করে, আর error জানায় ফেরত মানে। তখন একটি ভাঙন তৈরি হয়: standard library-র অনেক অংশ exception ধরে নেয়, তাই দুই “উপভাষা”-র C++ পাশাপাশি চলে। C++23-এর std::expected ফেরত-মানের পথকে standard-এ এনেছে, আর অংশ ৮-এর “আরও গভীরে”-তে বলা P0709 প্রস্তাব exception-কেই সস্তা ফেরত-মানের মতো বানানোর চেষ্টা করেছিল। কোনটি দ্রুত, তা সাধারণভাবে বলা যায় না: ব্যর্থতা বিরল হলে zero-cost exception প্রায়ই ফেরত-মান পরীক্ষার চেয়ে দ্রুত, ঘন ঘন হলে উল্টো। সংখ্যা চাইলে নিজের workload মেপে দেখতে হয়।

মূল উপলব্ধি: Zero-cost মানে সফল পথে শূন্য নির্দেশ, সব মিলিয়ে শূন্য খরচ নয়; আকার, optimization আর throw-এর সময়ের দাম নিয়ে প্রকল্পভেদে সিদ্ধান্ত আলাদা হয়।

প্র ০৪Thread আর async কোডে exception কোথায় যায়? Call stack-ই যদি না থাকে, unwinding কাকে ধরে?

এই পর্বের পুরো ছবি একটি ধারণার ওপর দাঁড়িয়ে: exception call stack ধরে নিচে নামে, আর ডাকা-পক্ষই handler. কিন্তু একটি thread-এর stack অন্য thread-এর stack-এর সঙ্গে যুক্ত নয়। নতুন thread-এ exception ধরা না পড়লে তা কোথায় যাবে? Java-তে সেই thread শেষ হয়, আর একটি “uncaught exception handler” (ডিফল্টে stack trace ছাপে) চলে; যে thread সেটি শুরু করেছিল, সে কিছুই টের পায় না, যদি না ফল নিতে Future.get() ডাকে, তখন exception একটি মোড়কে (ExecutionException) ফিরে আসে। C++-এর std::thread-এ ধরা না পড়া exception সরাসরি std::terminate; ফল আর exception দুটিই অন্য thread-এ পাঠাতে std::future আর std::exception_ptr লাগে।

Async কোডে সমস্যা আরও সূক্ষ্ম। await-এর আগে আর পরের কোড একই function-এ লেখা, কিন্তু চলার সময় মাঝখানে function-টি থেমে event loop-এ ফিরে গিয়েছিল; “ডাকা-পক্ষ” তখন event loop নিজে। তাই ভাষাগুলো exception-কে একটি মান হিসেবে বয়ে নেয়: JavaScript-এর Promise reject হলে মানটি promise-এর ভেতরে থাকে, আর await সেটি আবার throw করে, ফলে উৎস-কোডে try/catch স্বাভাবিক দেখায়। কেউ কখনো await বা .catch না করলে তা “unhandled rejection”; Node-এর নতুন সংস্করণগুলো ডিফল্টে এতে process থামায় বলে জানা যায়। Python 3.11 একসাথে চলা কয়েকটি task-এর একাধিক ব্যর্থতা জানাতে ExceptionGroup আর except* আনে (PEP 654), কারণ একটির বেশি exception একসাথে হতে পারে, যা পুরোনো “একটি exception, একটি stack” মডেলে ধরা যেত না।

এখানে Result-ধাঁচের পথ আবার সুবিধা পায়: ব্যর্থতা একটি সাধারণ মান, তাই thread, queue বা channel দিয়ে অন্য সব মানের মতোই পাঠানো যায়। Exception-ও শেষ পর্যন্ত এই সীমানায় একটি মানে রূপান্তরিত হয় (exception_ptr, rejected promise), তারপর অন্য পাশে আবার throw হয়। Coroutine আর async কীভাবে stack ছাড়া থামে আর চলে, তার বাস্তবায়ন পর্ব ৩১-এ; concurrency-র ভাষাগত মডেল পর্ব ১১-এ.

মূল উপলব্ধি: Stack unwinding শুধু একটি stack-এর ভেতরে কাজ করে; thread আর async-এর সীমানায় exception-কে মান হিসেবে বয়ে নিতে হয়, যেখানে error value-এর ধারণাই ফিরে আসে।

প্র ০৫“ধরো আর সামলাও” না “ভেঙে পড়তে দাও”? Haat v1-এর “runtime error মানে থামা” সিদ্ধান্ত কি ঠিক?

Exception handling-এর একটি অলিখিত অনুমান হলো, ব্যর্থতার পরে program একটি বৈধ অবস্থায় ফিরে কাজ চালাতে পারবে। প্রোগ্রামারের ভুলের ক্ষেত্রে এই অনুমান প্রায়ই মিথ্যা: সীমার বাইরে index বা অসম্ভব একটি শর্ত বলে দেয় program-এর অবস্থা আর বিশ্বাসযোগ্য নয়। তখন ধরে চালিয়ে যাওয়া ভুলকে আরও দূরে ছড়ায়, যেমন একটি ভুল মোট টাকা ডেটাবেসে লেখা হয়ে যাওয়া।

Erlang (১৯৮০-এর দশকের শেষে, টেলিফোন সুইচের জন্য) এর বিপরীত দর্শন জনপ্রিয় করে, যা “let it crash” নামে পরিচিত। একটি কাজ ছোট, বিচ্ছিন্ন process-এ চলে; অপ্রত্যাশিত কিছু হলে process-টি সোজা মরে যায়, আর একটি supervisor process তাকে পরিষ্কার অবস্থা থেকে আবার শুরু করে। Joe Armstrong-এর লেখায় এই নকশা বিস্তারে আছে। এখানে মূল কথা: সামলানোর কোড ব্যর্থ কাজের ভেতরে নয়, বাইরে, যেখানে অবস্থা নষ্ট হয়নি। Rust-এর panic আর Go-র panic একই চিন্তার ছোট রূপ: প্রত্যাশিত ব্যর্থতা Result বা error মানে, আর “এটি হওয়া উচিত ছিল না” ধরনের ভুলে থেমে যাওয়া। Rust-এ panic = "abort" দিলে unwinding-ই হয় না; সেখানে পুনরুদ্ধারের দায় process-এর বাইরের সিস্টেমের।

এই আলোয় Haat v1-এর সিদ্ধান্ত ২৬ যুক্তিসংগত। Haat-এর runtime error-গুলো তিনটি: শূন্য দিয়ে ভাগ, প্রস্তুত না হওয়া global, আর stack overflow; তিনটিই সাধারণত প্রোগ্রামারের ভুল, আর তিনটিই আগে থেকে পরীক্ষা করে এড়ানো যায়। সব ভুলে থেমে যাওয়ায় ভাষা আর compiler সরল থাকে: কোনো landing pad, exception table বা unwinding-এর নিয়ম লাগে না, আর interpreter ও VM-এর আচরণ মেলানো সহজ (reference-এর differential test ঠিক এটাই যাচাই করে)। দুর্বলতা হলো প্রত্যাশিত ব্যর্থতা (যেমন অজানা পণ্য-কোড) প্রকাশের কোনো ভালো উপায় নেই; Int ফেরত দিয়ে −1-এর মতো sentinel দিয়েই কাজ চালাতে হয়, যা অংশ ১-এর টেবিলের সবচেয়ে দুর্বল নকশা। Haat-এর বর্ধিত রূপে তাই দুটি পথ খোলা: ADT এলে Result (পর্ব ২৪), আর অংশ ৮-এর try/catch. দুটিই যোগ করলে নির্দেশিকা লাগবে কোনটি কখন; Rust আর Swift-এর অভিজ্ঞতা বলে, প্রত্যাশিত ব্যর্থতায় ফেরত মান আর ভুলে থামা একসাথে ভালো চলে।

মূল উপলব্ধি: প্রোগ্রামারের ভুলে থেমে যাওয়া আর বাইরে থেকে পুনরুদ্ধার প্রায়ই নিরাপদ; ধরে সামলানো দরকার প্রত্যাশিত ব্যর্থতায়, আর সেখানে Haat-এর ভবিষ্যৎ Result বা try/catch-এ।

অনুশীলন

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

  1. আউটপুট অনুমান করুন: Python 3.14-এ নিচের program কী ছাপবে? তিনটি লাইন লিখুন, তারপর প্রতিটি অক্ষর কোন নিয়মে এল ব্যাখ্যা করুন। (else চলে শুধু try-এ কোনো exception না হলে।)
    def f(x):
        try:
            print("A", end=" ")
            if x == 0:
                raise ZeroDivisionError
            if x == 1:
                return "r1"
            print("B", end=" ")
        except ZeroDivisionError:
            print("C", end=" ")
            return "r2"
        else:
            print("D", end=" ")
        finally:
            print("E", end=" ")
        return "r3"
    
    for x in (0, 1, 2):
        print(f(x))

    সত্যিকারের run (CPython 3.14.4):

    A C E r2
    A E r1
    A B D E r3

    x = 0: A, তারপর raise; বাকি try বাদ (B নেই); except চলে (C), তার return "r2" একটি completion যা তোলা থাকে; finally চলে (E), স্বাভাবিকভাবে শেষ, তাই r2 ফেরে। x = 1: A, তারপর return "r1"; else চলে না, কারণ try return দিয়ে শেষ হয়েছে, স্বাভাবিকভাবে নয়; finally (E), তারপর r1. x = 2: কোনো exception বা return নেই: A, B, তারপর else (D), finally (E), আর শেষে try-এর বাইরের return "r3". লক্ষ্য করুন সব লাইনেই E আছে, আর তা সবসময় ফেরত মান ছাপার আগে, কারণ print(f(x)) আগে f(x) শেষ করে।

  2. ভুল খুঁজুন আর ঠিক করুন: C++20-এ বাজারঘরের অর্ডার ফাইলে লেখার function. write_line exception ছুড়তে পারে, যেমন disk full হলে। কোথায় সমস্যা, এটি কোন exception-safety স্তর দেয়, আর RAII দিয়ে কীভাবে ঠিক করবেন?
    void save(const Order &o) {
        std::FILE *f = std::fopen("orders.txt", "a");
        write_line(f, o);     // throw করতে পারে
        std::fclose(f);
    }

    write_line throw করলে unwinding save-এর frame সরায়, কিন্তু f একটি raw pointer, তার কোনো destructor নেই; fclose-এর লাইন কখনো চলে না, ফাইল খোলা থেকে যায় (resource leak). তাই এটি basic guarantee-ও দেয় না। আরও একটি ভুল: fopen ব্যর্থ হলে f null, তবু তা ব্যবহার হয়। ঠিক রূপ, একটি RAII class:

    class File {
        std::FILE *f;
    public:
        explicit File(const char *path) : f(std::fopen(path, "a")) {
            if (!f) throw std::runtime_error("cannot open");
        }
        ~File() { std::fclose(f); std::puts("fclose"); }
        File(const File &) = delete;
        File &operator=(const File &) = delete;
        std::FILE *get() const { return f; }
    };
    void save(const Order &o) {
        File file("orders.txt");
        write_line(file.get(), o);
    }

    যাচাই: Clang 22.1.8 (zig c++ -O2 -std=c++20 -Wall -Wextra), যেখানে পরীক্ষার write_line দ্বিতীয় ডাকে "disk full" ছোড়ে আর main দুবার save ডাকে। সত্যিকারের output: fclose, saved, fclose, error: disk full. দ্বিতীয় ক্ষেত্রেও fclose চলেছে। এখন basic guarantee আছে; strong নয়, কারণ ব্যর্থ লেখার আগে ফাইলে অর্ধেক লাইন যেতে পারে। Copy মুছে দেওয়া (= delete) জরুরি: নইলে দুটি কপি একই FILE* দুবার বন্ধ করত।

  3. নকশা ও বাস্তবায়ন — Haat-এর বর্ধিত রূপের interpreter: একটি ছোট tree-walking interpreter-এ throw আর try … catch (name) যোগ করুন। শর্ত: (ক) throw e; একটি Str ছোড়ে, (খ) শূন্য দিয়ে ভাগও "division by zero" message-সহ ধরা যায়, (গ) catch-এর নাম শুধু handler-এর scope-এ দেখা যায়, (ঘ) কেউ না ধরলে Haat-এর ধাঁচে line:col: runtime error: … ছাপা হয়। Statement-গুলো tuple হিসেবে দিন।
    # Haat-এর বর্ধিত রূপ: throw আর try/catch (খসড়া, reference-এ নেই)
    class HaatThrow(Exception):            # Haat-এর throw = host-এর exception
        def __init__(self, msg, line, col):
            self.msg, self.line, self.col = msg, line, col
    
    def exec_stmt(s, env, out):
        kind = s[0]
        if kind == "print":
            out.append(str(eval_expr(s[1], env)))
        elif kind == "throw":                          # ("throw", expr, line, col)
            raise HaatThrow(eval_expr(s[1], env), s[2], s[3])
        elif kind == "try":                            # ("try", body, name, handler)
            try:
                for t in s[1]: exec_stmt(t, env, out)
            except HaatThrow as e:
                inner = dict(env); inner[s[2]] = e.msg  # catch-এর নাম নতুন scope-এ
                for t in s[3]: exec_stmt(t, inner, out)
    
    def eval_expr(e, env):
        if isinstance(e, (int, str)): return e
        if e[0] == "var": return env[e[1]]
        if e[0] == "+": return eval_expr(e[1], env) + eval_expr(e[2], env)
        if e[0] == "/":
            b = eval_expr(e[2], env)
            if b == 0: raise HaatThrow("division by zero", e[3], e[4])
            a = eval_expr(e[1], env); return int(a / b)   # ছোট মানে C-র মতো কাটা
    
    prog = [("try", [("print", ("/", 996, 3, 2, 13)),
                     ("print", ("/", 996, 0, 3, 13)),
                     ("print", "not reached")],
             "msg", [("print", ("+", "error: ", ("var", "msg")))]),
            ("print", "done"),
            ("throw", "unpaid", 7, 1)]
    out = []
    try:
        for s in prog: exec_stmt(s, {}, out)
    except HaatThrow as e:
        out.append(f"{e.line}:{e.col}: runtime error: uncaught exception: {e.msg}")
    print("\n".join(out))

    সত্যিকারের run (CPython 3.14.4): 332, error: division by zero, done, 7:1: runtime error: uncaught exception: unpaid. Host-এর exception নিজেই unwinding করে: eval_expr-এর গভীর থেকে raise হলে Python-এর stack-এর সব frame পেরিয়ে নিকটতম except HaatThrow-এ আসে, ঠিক reference-এর ReturnSignal-এর মতো। dict(env) নতুন scope বানায়, তাই msg handler-এর বাইরে দেখা যায় না। খসড়ার সীমা: ভাগের আগে ভাজক (b) হিসাব হয়েছে, যা Haat-এর বাঁ-থেকে-ডান নিয়ম (সিদ্ধান্ত ১২) ভাঙে; দুই পাশে side effect থাকলে আগে a, পরে b হিসাব করে তারপর শূন্য পরীক্ষা করতে হবে। আর int(a / b) float দিয়ে ভাগ, যা বড় Int-এ ভুল; পূর্ণ বাস্তবায়নে reference-এর runtime.py-এর পূর্ণসংখ্যার ভাগ লাগবে।

  4. Trace করুন — destructor-এর ক্রম: নিচের C++20 program কী ছাপবে? প্রতিটি close কখন আসে, আর b-এর catch কেন কাজে আসে না? তারপর ভাবুন: a-র try/catch না থাকলে কী হতো?
    struct Guard {
        const char *n;
        Guard(const char *s) : n(s) { std::printf("open %s\n", n); }
        ~Guard() { std::printf("close %s\n", n); }
    };
    void c() { Guard g("c1"); Guard h("c2"); throw 7; }
    void b() {
        Guard g("b");
        try { c(); } catch (const char *) { std::puts("b caught"); }
        std::puts("b done");
    }
    void a() {
        Guard g("a");
        try { b(); } catch (int x) { std::printf("a caught %d\n", x); }
        std::puts("a done");
    }
    int main() { a(); }

    সত্যিকারের run (Clang 22.1.8, zig c++ -O2 -std=c++20):

    open a
    open b
    open c1
    open c2
    close c2
    close c1
    close b
    a caught 7
    a done
    close a

    ছোড়া মানটি int; b-এর catch (const char *) type মেলে না, তাই ধাপ ১-এ খোঁজা চলে a পর্যন্ত। ধাপ ২-এ c-এর দুটি Guard উল্টো ক্রমে (c2, তারপর c1), তারপর b-এর Guard; b done কখনো ছাপা হয় না। a-র Guard তার try-এর বাইরে তৈরি, তাই handler আর a done-এর পরে, function শেষে close a. a-র try/catch না থাকলে কেউ ধরত না, std::terminate চলত। একই compiler-এ এমন একটি ছোট program (main-এ একটি Guard, c-তে throw 7, কোথাও catch নেই) চালালে output: open main, open c1, তারপর libc++abi: terminating due to uncaught exception of type int, আর কোনো close লাইন নেই। এই যন্ত্রে unwinding হয়নি; standard এটি implementation-defined রেখেছে, তাই অন্য compiler বা platform-এ ভিন্ন হতে পারে।

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

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

ক্রমLinux-এর C++ (Itanium ABI)-তে একটি throw থেকে catch block চলা পর্যন্ত ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Exception object তৈরি হয় আর unwinder ডাকা হয়
  2. ধাপ ১: প্রতিটি frame-এর টেবিল দেখে মেলা catch খোঁজা, কিছু না বদলে
  3. মেলা catch আছে এমন frame পাওয়া যায়
  4. ধাপ ২: পথের frame-গুলোর landing pad চলে, destructor চলে, frame সরে
  5. Handler-এর frame-এ catch block চলে

JavaScript-এ function f() { try { return 1; } finally { return 2; } } হলে f()-এর মান কত?

  • 1
  • SyntaxError
  • 2
  • [1, 2]

Exception handling-এর termination model-এর সঠিক বর্ণনা কোনটি?

  • Handler চলার পর throw-এর জায়গায় ফেরা হয় না; কাজ এগোয় try কাঠামোর পর থেকে
  • Handler সমস্যা মিটিয়ে throw-এর পরের লাইন থেকে আবার চালায়
  • যেকোনো exception-এ পুরো program থেমে যায়
  • Compiler compile-এর সময়েই ঠিক করে কোন handler চলবে

Table-based (“zero-cost”) exception বাস্তবায়নে exception কখনো না ঘটলে খরচ কোথায় পড়ে?

  • প্রতিটি try-তে ঢোকার সময় একটি jmp_buf push করতে হয়
  • প্রতিটি call-এর পরে একটি error flag পরীক্ষা হয়
  • Garbage collector-কে প্রতিটি frame স্ক্যান করতে হয়
  • মূলত program-এর আকারে (টেবিল আর landing pad) আর কিছু optimization-এর সীমায়

C++-এ void g() { std::string s = "x"; h(); }, আর h() exception ছোড়ে যা g-এর বাইরের একটি catch ধরে। s-এর কী হয়?

  • s-এর মেমরি leak হয়, কারণ g স্বাভাবিকভাবে ফেরেনি
  • Unwinding-এর সময় g-এর landing pad s-এর destructor চালায়
  • catch block শেষ হলে s-এর destructor চলে
  • Garbage collector পরে কোনো এক সময় s মুক্ত করে

Java-তে নিচের কোনটি checked exception, অর্থাৎ ধরতে বা throws-এ ঘোষণা করতে compiler বাধ্য করে?

  • NullPointerException
  • ArrayIndexOutOfBoundsException
  • IOException
  • StackOverflowError

Haat v1 (reference বাস্তবায়ন)-এ print(1); print(10 / 0); print(2); চালালে কী ঘটে?

  • 10 / 0 একটি exception, যা try দিয়ে ধরা যায়
  • 1, 0, 2 ছাপা হয়
  • কিছুই ছাপা হয় না, শুধু error
  • 1 ছাপা হয়, তারপর runtime error: division by zero, আর program থামে

C-তে setjmp/longjmp দিয়ে বানানো “exception” আর C++-এর exception-এর মূল পার্থক্য কী?

  • longjmp পথের frame-গুলোর কোনো পরিষ্কারের কাজ (destructor, finally) চালায় না
  • longjmp মাঝের frame বাদ দিতে পারে না
  • longjmp শুধু বিশেষ hardware-এ কাজ করে
  • longjmp সফল পথে zero-cost, C++ exception নয়

শব্দকোষ

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

মনে রাখুন

  1. পাঁচটি নকশা: error code/errno, Result, exception, panic; Haat v1-এ runtime error মানে থামা (সিদ্ধান্ত ২৬), আগের output থাকে।
  2. Termination model আর unwinding: throw-এর পরে বাকি কাজ বাদ, handler না পাওয়া পর্যন্ত frame সরে, পথে finally বা destructor চলে।
  3. finally সবসময় চলে, আর তার নিজের return বা throw আগের ফল মুছে দেয়; ফেরত মান finally-র আগেই হিসাব হয়।
  4. RAII unwinding-এর পথে সম্পদ ফেরত দেয়; exception safety-র তিন স্তর basic, strong, nothrow; unwinding-এর সময় destructor থেকে throw মানে std::terminate.
  5. বাস্তবায়ন: setjmp/longjmp প্রতিটি try-এ খরচ করে; zero-cost table (landing pad, .gcc_except_table, CPython-এর ExceptionTable) খরচ রাখে throw-এর মুহূর্তে আর আকারে।

পরের পর্বে: পর্ব ২৯-এর বিষয় parameter passing: by value, by reference, by sharing আর by name. একই function ডাক বিভিন্ন passing mode-এ কেন ভিন্ন ফল দেয়, aliasing-এর বিপদ, আর Python ও Java-র “by sharing” আসলে কী।

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

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