feat: Implement try-catch-finally exception handling and throw statements.

Author: zuisong

TRY_CATCH.md

@@ -0,0 +1,8 @@
+# Basic try-catch test
+try {
+    throw "Something went wrong!"
+} catch error {
+    println("Caught error: " + error)
+}
+
+println("Program continues...")

demo_codes/test_try_catch_basic.ch

@@ -0,0 +1,14 @@
+# Try-catch with finally
+let cleanup_called = false
+
+try {
+    println("In try block")
+    throw "Error occurred"
+} catch error {
+    println("In catch block: " + error)
+} finally {
+    println("In finally block")
+    cleanup_called = true
+}
+
+println("Cleanup called: " + cleanup_called)

demo_codes/test_try_catch_finally.ch

@@ -0,0 +1,19 @@
+# Function with exception
+def divide(a, b) {
+    if b == 0 {
+        throw "Division by zero"
+    }
+    a / b
+}
+
+try {
+    let result = divide(10, 2)
+    println("Result: " + result)
+    
+    let bad_result = divide(10, 0)
+    println("This should not print")
+} catch error {
+    println("Caught: " + error)
+}
+
+println("Program completed")

demo_codes/test_try_catch_function.ch

@@ -0,0 +1,18 @@
+# Nested try-catch
+try {
+    println("Outer try")
+    
+    try {
+        println("Inner try")
+        throw "Inner error"
+    } catch inner_error {
+        println("Inner catch: " + inner_error)
+        throw "Outer error"
+    }
+    
+    println("This should not print")
+} catch outer_error {
+    println("Outer catch: " + outer_error)
+}
+
+println("Done")

demo_codes/test_try_catch_nested.ch

@@ -17,11 +17,15 @@ TRUE = @{ "true" ~ !(ASCII_ALPHANUMERIC | "_") }
 FALSE = @{ "false" ~ !(ASCII_ALPHANUMERIC | "_") }
 BREAK = @{ "break" ~ !(ASCII_ALPHANUMERIC | "_") }
 CONTINUE = @{ "continue" ~ !(ASCII_ALPHANUMERIC | "_") }
+TRY = @{ "try" ~ !(ASCII_ALPHANUMERIC | "_") }
+CATCH = @{ "catch" ~ !(ASCII_ALPHANUMERIC | "_") }
+FINALLY = @{ "finally" ~ !(ASCII_ALPHANUMERIC | "_") }
+THROW = @{ "throw" ~ !(ASCII_ALPHANUMERIC | "_") }
 // NULL removed
 
 // 标识符 (不能是关键字)
 identifier = @{ !keyword ~ (ASCII_ALPHA | "_") ~ (ASCII_ALPHANUMERIC | "_")* }
-keyword = { LET | FOR | DEF | RETURN | IF | ELSE | TRUE | FALSE | BREAK | CONTINUE }
+keyword = { LET | FOR | DEF | RETURN | IF | ELSE | TRUE | FALSE | BREAK | CONTINUE | TRY | CATCH | FINALLY | THROW }
 
 // 字面量
 integer = @{ "-"? ~ ASCII_DIGIT+ }
@@ -94,6 +98,8 @@ statement = {
     return_stmt |
     break_stmt |
     continue_stmt |
+    try_catch |
+    throw_stmt |
     assignment |
     expression
 }
@@ -107,6 +113,8 @@ function_def = { DEF ~ identifier? ~ "(" ~ NEWLINE* ~ parameters? ~ NEWLINE* ~ "
 return_stmt = { RETURN ~ NEWLINE* ~ expression }
 break_stmt = { BREAK }
 continue_stmt = { CONTINUE }
+try_catch = { TRY ~ block ~ CATCH ~ identifier? ~ block ~ (FINALLY ~ block)? }
+throw_stmt = { THROW ~ NEWLINE* ~ expression }
 
 // 复合结构
 block = { "{" ~ NEWLINE* ~ (statement ~ stmt_sep)* ~ statement? ~ NEWLINE* ~ "}" }

docs/pkg/chen_lang_bg.wasm

@@ -233,6 +233,11 @@ impl<'a> Compiler<'a> {
                 self.compile_expression(value);
                 self.emit(Instruction::SetIndex, line);
             }
+            Statement::TryCatch(tc) => self.compile_try_catch(tc),
+            Statement::Throw { value, line } => {
+                self.compile_expression(value);
+                self.emit(Instruction::Throw, line);
+            }
         }
     }
 
@@ -603,4 +608,102 @@ impl<'a> Compiler<'a> {
             },
         );
     }
+
+    fn compile_try_catch(&mut self, tc: TryCatch) {
+        let line = tc.line;
+        let unique_id = self.unique_id();
+        let catch_label = format!("catch_{}", unique_id);
+        let finally_label = format!("finally_{}", unique_id);
+        let end_label = format!("end_try_{}", unique_id);
+
+        // Set up exception handler
+        self.emit(Instruction::PushExceptionHandler(catch_label.clone()), line);
+
+        // Compile try block
+        self.begin_scope();
+        for stmt in tc.try_body {
+            self.compile_statement(stmt);
+        }
+        self.end_scope();
+
+        // Pop exception handler if no exception occurred
+        self.emit(Instruction::PopExceptionHandler, line);
+
+        // Jump to finally or end
+        if tc.finally_body.is_some() {
+            self.emit(Instruction::Jump(finally_label.clone()), line);
+        } else {
+            self.emit(Instruction::Jump(end_label.clone()), line);
+        }
+
+        // Catch block
+        self.program.syms.insert(
+            catch_label.clone(),
+            Symbol {
+                location: self.program.instructions.len() as i32,
+                narguments: 0,
+                nlocals: 0,
+            },
+        );
+
+        self.begin_scope();
+        
+        // Define error variable if provided
+        if let Some(error_name) = tc.error_name {
+            let var_location = self.define_variable(error_name);
+            match var_location {
+                VarLocation::Local(offset) => {
+                    self.emit(Instruction::MovePlusFP(offset as usize), line);
+                }
+                VarLocation::Global(name) => {
+                    self.emit(Instruction::Store(name), line);
+                }
+            }
+        } else {
+            // Pop the error value if no variable to store it
+            self.emit(Instruction::Pop, line);
+        }
+
+        // Compile catch block
+        for stmt in tc.catch_body {
+            self.compile_statement(stmt);
+        }
+        
+        self.end_scope();
+
+        // Jump to finally or end after catch
+        if tc.finally_body.is_some() {
+            self.emit(Instruction::Jump(finally_label.clone()), line);
+        } else {
+            self.emit(Instruction::Jump(end_label.clone()), line);
+        }
+
+        // Finally block (if present)
+        if let Some(finally_body) = tc.finally_body {
+            self.program.syms.insert(
+                finally_label.clone(),
+                Symbol {
+                    location: self.program.instructions.len() as i32,
+                    narguments: 0,
+                    nlocals: 0,
+                },
+            );
+
+            self.begin_scope();
+            for stmt in finally_body {
+                self.compile_statement(stmt);
+            }
+            self.end_scope();
+        }
+
+        // End label
+        self.program.syms.insert(
+            end_label,
+            Symbol {
+                location: self.program.instructions.len() as i32,
+                narguments: 0,
+                nlocals: 0,
+            },
+        );
+    }
 }

src/chen.pest

@@ -106,6 +106,13 @@ pub enum Statement {
     },
     Break(u32),
     Continue(u32),
+    /// Try-Catch-Finally 异常处理
+    TryCatch(TryCatch),
+    /// Throw 抛出异常
+    Throw {
+        value: Expression,
+        line: u32,
+    },
 }
 
 pub type Ast = Vec<Statement>;
@@ -137,3 +144,17 @@ pub struct Loop {
     pub body: Vec<Statement>,
     pub line: u32,
 }
+
+/// Try-Catch-Finally 异常处理
+#[derive(Debug, PartialEq, Clone)]
+pub struct TryCatch {
+    /// try 块中的语句
+    pub try_body: Vec<Statement>,
+    /// catch 块中的错误变量名
+    pub error_name: Option<String>,
+    /// catch 块中的语句
+    pub catch_body: Vec<Statement>,
+    /// finally 块中的语句(可选)
+    pub finally_body: Option<Vec<Statement>>,
+    pub line: u32,
+}

src/compiler.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 
 use crate::expression::{
     Assign, Ast, BinaryOperation, Expression, FunctionCall, FunctionDeclaration, If, Literal, Local, Loop, Return,
-    Statement, Unary,
+    Statement, TryCatch, Unary,
 };
 use crate::token::Keyword;
 use crate::token::Operator;
@@ -162,6 +162,12 @@ impl Parser {
         if self.match_token(&Token::Keyword(Keyword::CONTINUE)) {
             return Ok(Statement::Continue(start_line));
         }
+        if self.match_token(&Token::Keyword(Keyword::TRY)) {
+            return self.parse_try_catch();
+        }
+        if self.match_token(&Token::Keyword(Keyword::THROW)) {
+            return self.parse_throw();
+        }
 
         // Assignment or Expression
         let expr = self.parse_expression_logic()?;
@@ -617,6 +623,65 @@ impl Parser {
         self.consume(&Token::RSquare, "Expected ']' after array elements")?;
         Ok(Expression::ArrayLiteral(elements, start_line))
     }
+
+    fn parse_try_catch(&mut self) -> Result<Statement, ParseError> {
+        let start_line = self.line;
+        
+        // Parse try block
+        self.skip_newlines();
+        self.consume(&Token::LBig, "Expected '{' after 'try'")?;
+        let try_body = self.parse_block()?;
+        self.consume(&Token::RBig, "Expected '}' after try block")?;
+        
+        // Parse catch
+        self.skip_newlines();
+        self.consume(&Token::Keyword(Keyword::CATCH), "Expected 'catch' after try block")?;
+        
+        // Optional error variable name
+        let error_name = if let Some(Token::Identifier(name)) = self.peek() {
+            let n = name.clone();
+            self.advance();
+            Some(n)
+        } else {
+            None
+        };
+        
+        // Parse catch block
+        self.skip_newlines();
+        self.consume(&Token::LBig, "Expected '{' after 'catch'")?;
+        let catch_body = self.parse_block()?;
+        self.consume(&Token::RBig, "Expected '}' after catch block")?;
+        
+        // Optional finally block
+        self.skip_newlines();
+        let finally_body = if self.match_token(&Token::Keyword(Keyword::FINALLY)) {
+            self.skip_newlines();
+            self.consume(&Token::LBig, "Expected '{' after 'finally'")?;
+            let body = self.parse_block()?;
+            self.consume(&Token::RBig, "Expected '}' after finally block")?;
+            Some(body)
+        } else {
+            None
+        };
+        
+        Ok(Statement::TryCatch(TryCatch {
+            try_body,
+            error_name,
+            catch_body,
+            finally_body,
+            line: start_line,
+        }))
+    }
+
+    fn parse_throw(&mut self) -> Result<Statement, ParseError> {
+        let start_line = self.line;
+        let value = self.parse_expression_logic()?;
+        
+        Ok(Statement::Throw {
+            value,
+            line: start_line,
+        })
+    }
 }
 
 pub fn parse(tokens: Vec<Token>) -> Result<Ast, ParseError> {