update error handle

Author: CppCXY

crates/luars/src/lua_vm/mod.rs

@@ -2015,9 +2015,35 @@ impl LuaVM {
     // ===== Lightweight Error Handling API =====
 
     /// Set runtime error and return lightweight error enum
-    #[inline]
+    /// If an error handler is set (via xpcall), it will be called immediately
     pub fn error(&mut self, message: impl Into<String>) -> LuaError {
-        self.error_message = message.into();
+        let msg = message.into();
+        
+        // Check if there's an error handler (set by xpcall)
+        if let Some(handler) = self.error_handler.clone() {
+            // Call the error handler with the error message
+            // Note: The call stack is still intact at this point
+            let err_value = self.create_string(&msg);
+            
+            match self.call_function_internal(handler, vec![err_value]) {
+                Ok(handler_results) => {
+                    // Error handler succeeded, use its return value as the new error message
+                    if let Some(result) = handler_results.first() {
+                        self.error_message = self.value_to_string_raw(result);
+                    } else {
+                        self.error_message = msg;
+                    }
+                }
+                Err(_) => {
+                    // Error handler itself failed, use original message
+                    self.error_message = format!("error in error handler: {}", msg);
+                }
+            }
+        } else {
+            // No error handler, just set the message
+            self.error_message = msg;
+        }
+        
         LuaError::RuntimeError
     }
 
@@ -2413,58 +2439,43 @@ impl LuaVM {
         }
     }
 
-    /// Protected call with error handler
+    /// Protected call with error handler (xpcall semantics)
+    /// The error handler is registered and will be called by error() when an error occurs
     /// Note: Yields are NOT caught by xpcall - they propagate through
     pub fn protected_call_with_handler(
         &mut self,
         func: LuaValue,
         args: Vec<LuaValue>,
         err_handler: LuaValue,
     ) -> LuaResult<(bool, Vec<LuaValue>)> {
+        // Save old error handler and set the new one
         let old_handler = self.error_handler.clone();
         self.error_handler = Some(err_handler.clone());
 
         let initial_frame_count = self.frame_count;
 
+        // Call the function - if it errors, error() will call the handler
         let result = self.call_function_internal(func, args);
 
+        // Restore old error handler
         self.error_handler = old_handler;
 
         match result {
             Ok(values) => Ok((true, values)),
             Err(LuaError::Yield) => Err(LuaError::Yield),
             Err(_) => {
-                // IMPORTANT: For xpcall, we call the error handler BEFORE cleaning up frames
-                // This allows the handler to access the full call stack for traceback generation
-                
-                // Get the error message (which already includes traceback)
-                let msg = self.error_message.clone();
-                let err_value = self.create_string(&msg);
-                let err_display = format!("Runtime Error: {}", msg);
-
-                // Call error handler with the error message BEFORE cleaning up frames
-                let handler_result = self.call_function_internal(err_handler, vec![err_value]);
-
-                // NOW clean up frames created by the failed function call
+                // Error occurred (and handler was already called in error())
+                // Clean up frames created by the failed function call
                 while self.frame_count > initial_frame_count {
                     let frame = self.pop_frame().unwrap();
                     // Close upvalues belonging to this frame
                     self.close_upvalues_from(frame.base_ptr);
                 }
-
-                match handler_result {
-                    Ok(handler_values) => Ok((false, handler_values)),
-                    Err(LuaError::Yield) => {
-                        // Yield from error handler - propagate it
-                        let values = self.take_yield_values();
-                        Err(self.do_yield(values))
-                    }
-                    Err(_) => {
-                        let err_str =
-                            self.create_string(&format!("Error in error handler: {}", err_display));
-                        Ok((false, vec![err_str]))
-                    }
-                }
+                
+                // Return the error message (which may have been modified by the handler)
+                let msg = self.error_message.clone();
+                let err_str = self.create_string(&msg);
+                Ok((false, vec![err_str]))
             }
         }
     }

crates/luars/src/stdlib/debug.rs

@@ -15,14 +15,73 @@ pub fn create_debug_lib() -> LibraryModule {
 }
 
 fn debug_traceback(vm: &mut LuaVM) -> LuaResult<MultiValue> {
-    // Simple traceback
+    // debug.traceback([thread,] [message [, level]])
+    // For now, we don't support the thread parameter
+    
+    // Get message argument (can be nil)
     let message = crate::lib_registry::get_arg(vm, 0).unwrap_or(LuaValue::nil());
-    // .and_then(|v| v.as_lua_string())
-    // .map(|s| s.as_str().to_string())
-    // .unwrap_or_else(|| "stack traceback:".to_string());
-
-    // let result = vm.create_string(message);
-    Ok(MultiValue::single(message))
+    let message_str = if message.is_nil() {
+        None
+    } else {
+        // Try to convert to string
+        Some(vm.value_to_string_raw(&message))
+    };
+    
+    // Get level argument (default is 1)
+    let level = crate::lib_registry::get_arg(vm, 1)
+        .and_then(|v| v.as_integer())
+        .unwrap_or(1) as usize;
+    
+    // Generate traceback, skipping the first 'level' frames
+    let mut trace = String::new();
+    
+    if let Some(msg) = message_str {
+        trace.push_str(&msg);
+        trace.push('\n');
+    }
+    
+    trace.push_str("stack traceback:");
+    
+    // Iterate through call frames, starting from 'level'
+    let total_frames = vm.frame_count;
+    if level < total_frames {
+        for i in (level..total_frames).rev() {
+            let frame = &vm.frames[i];
+            
+            if frame.is_lua() {
+                if let Some(func_id) = frame.get_function_id() {
+                    if let Some(func) = vm.object_pool.get_function(func_id) {
+                        let chunk = &func.chunk;
+                        let source = chunk.source_name.as_deref().unwrap_or("?");
+                        
+                        // Get line number from pc
+                        let pc = frame.pc.saturating_sub(1);
+                        let line = if !chunk.line_info.is_empty() && pc < chunk.line_info.len() {
+                            chunk.line_info[pc]
+                        } else {
+                            0
+                        };
+                        
+                        if line > 0 {
+                            trace.push_str(&format!("\n\t{}:{}: in function", source, line));
+                        } else {
+                            trace.push_str(&format!("\n\t{}: in function", source));
+                        }
+                    } else {
+                        trace.push_str("\n\t?: in function");
+                    }
+                } else {
+                    trace.push_str("\n\t?: in function");
+                }
+            } else {
+                // C function
+                trace.push_str("\n\t[C]: in function");
+            }
+        }
+    }
+    
+    let result = vm.create_string(&trace);
+    Ok(MultiValue::single(result))
 }
 
 fn debug_getinfo(_vm: &mut LuaVM) -> LuaResult<MultiValue> {