update

Author: CppCXY

crates/luars/src/compiler/code.rs

@@ -1415,7 +1415,16 @@ fn constfolding(_fs: &FuncState, op: BinaryOperator, e1: &mut ExpDesc, e2: &ExpD
                     OpSub => i1.checked_sub(i2),
                     OpMul => i1.checked_mul(i2),
                     OpIDiv => i1.checked_div(i2),
-                    OpMod => Some(i1.rem_euclid(i2)),
+                    OpMod => {
+                        // Use Lua's modulo definition: a % b = a - floor(a/b) * b
+                        // NOT Rust's rem_euclid which differs for negative divisors
+                        let quot = (i1 as f64) / (i2 as f64);
+                        let floor_quot = quot.floor() as i64;
+                        match floor_quot.checked_mul(i2) {
+                            Some(prod) => i1.checked_sub(prod),
+                            None => None,
+                        }
+                    }
                     _ => unreachable!(),
                 };
 
@@ -1990,9 +1999,15 @@ fn is_kstr(e: &ExpDesc) -> bool {
     e.kind == ExpKind::VK || e.kind == ExpKind::VKSTR
 }
 
-// Check if expression is a constant integer in valid range
+// Check if expression is a constant integer in valid range for SETI
+// SETI's B field is only 8 bits (0-255), matching Lua C's isCint check
 fn is_cint(e: &ExpDesc) -> bool {
-    e.kind == ExpKind::VKINT
+    if e.kind == ExpKind::VKINT {
+        let val = unsafe { e.u.ival };
+        val >= 0 && val <= 255
+    } else {
+        false
+    }
 }
 
 // Port of luaK_self from lcode.c:1087-1097

crates/luars/src/compiler/expr_parser.rs

@@ -506,10 +506,24 @@ fn field(fs: &mut FuncState, cc: &mut ConsControl) -> Result<(), String> {
             code::code_abrk(fs, OpCode::SetField, cc.table_reg as u32, key_idx, &mut val);
         }
         // Check if key is integer constant for SetI optimization
+        // IMPORTANT: SETI's B field is only 8 bits (0-255), so we must check the range
         else if key.kind == ExpKind::VKINT {
-            let key_int = unsafe { key.u.ival as u32 };
-            // Use code_abrk to allow constant value optimization (e.g., [1] = 10)
-            code::code_abrk(fs, OpCode::SetI, cc.table_reg as u32, key_int, &mut val);
+            let key_int = unsafe { key.u.ival };
+            // Only use SETI if key fits in 8 bits (matches Lua's isCint check)
+            if key_int >= 0 && key_int <= 255 {
+                // Use code_abrk to allow constant value optimization (e.g., [1] = 10)
+                code::code_abrk(fs, OpCode::SetI, cc.table_reg as u32, key_int as u32, &mut val);
+            } else {
+                // Key too large for SETI, use SETTABLE instead
+                let key_reg = code::exp2anyreg(fs, &mut key);
+                code::code_abrk(
+                    fs,
+                    OpCode::SetTable,
+                    cc.table_reg as u32,
+                    key_reg as u32,
+                    &mut val,
+                );
+            }
         } else {
             // General case: SetTable instruction with RK optimization
             let key_reg = code::exp2anyreg(fs, &mut key);

crates/luars/src/compiler/parser/lua_token_data.rs

@@ -4,10 +4,15 @@ use crate::compiler::parser::{lua_token_kind::LuaTokenKind, text_range::SourceRa
 pub struct LuaTokenData {
     pub kind: LuaTokenKind,
     pub range: SourceRange,
+    pub line: usize, // line number at the END of this token (matches Lua's linenumber)
 }
 
 impl LuaTokenData {
     pub fn new(kind: LuaTokenKind, range: SourceRange) -> Self {
-        LuaTokenData { kind, range }
+        LuaTokenData { kind, range, line: 1 }
+    }
+
+    pub fn with_line(kind: LuaTokenKind, range: SourceRange, line: usize) -> Self {
+        LuaTokenData { kind, range, line }
     }
 }

crates/luars/src/compiler/parser/lua_tokenize.rs

@@ -30,7 +30,8 @@ impl<'a> LuaTokenize<'a> {
                 break;
             }
 
-            tokens.push(LuaTokenData::new(kind, self.reader.current_range()));
+            // Save token with its ending line number (matches Lua's linenumber)
+            tokens.push(LuaTokenData::with_line(kind, self.reader.current_range(), self.line));
         }
 
         if let Some(err) = &self.error {

crates/luars/src/compiler/parser/mod.rs

@@ -52,6 +52,9 @@ impl<'a> LuaLexer<'a> {
         if self.tokens.is_empty() {
             self.current_token = LuaTokenKind::TkEof;
         } else {
+            // Initialize line from first token
+            self.line = self.tokens[0].line;
+            self.lastline = 1; // lastline starts at 1
             self.current_token = self.tokens[0].kind;
         }
 
@@ -128,14 +131,19 @@ impl<'a> LuaLexer<'a> {
         self.lastline = self.line;
 
         let mut next_index = self.token_index + 1;
-        self.skip_trivia_and_update_line(&mut next_index);
+        // Skip trivia tokens to find next real token
+        self.skip_trivia(&mut next_index);
         self.token_index = next_index;
 
         if self.token_index >= self.tokens.len() {
             self.current_token = LuaTokenKind::TkEof;
             return;
         }
 
+        // CRITICAL FIX: Update line from token's ending line number
+        // This ensures multi-line tokens (long strings, multi-line comments)  
+        // correctly update linenumber (matches Lua C's behavior in llex)
+        self.line = self.tokens[self.token_index].line;
         self.current_token = self.tokens[self.token_index].kind;
     }
 
@@ -164,24 +172,6 @@ impl<'a> LuaLexer<'a> {
             kind = self.tokens[*index].kind;
         }
     }
-
-    fn skip_trivia_and_update_line(&mut self, index: &mut usize) {
-        if index >= &mut self.tokens.len() {
-            return;
-        }
-
-        let mut kind = self.tokens[*index].kind;
-        while is_trivia_kind(kind) {
-            if kind == LuaTokenKind::TkEndOfLine {
-                self.line += 1;
-            }
-            *index += 1;
-            if *index >= self.tokens.len() {
-                break;
-            }
-            kind = self.tokens[*index].kind;
-        }
-    }
 }
 
 fn is_trivia_kind(kind: LuaTokenKind) -> bool {

crates/luars_interpreter/src/bin/bytecode_dump.rs

@@ -172,15 +172,6 @@ fn dump_chunk(
         let sbx = Instruction::get_sbx(instr);
         let k = Instruction::get_k(instr);
 
-        // Debug: check instruction 227 (pc=227, shown as instruction 228)
-        if pc == 227 {
-            eprintln!(
-                "DEBUG instr 228 (pc=227): raw=0x{:08X}, opcode={:?} ({}), a={}, b={}, c={}",
-                instr, opcode, opcode as u8, a, b, c
-            );
-            eprintln!("  Expected: CALL (opcode=24) 3 2 1");
-        }
-
         // Get line number for this instruction (luac format)
         let line = if pc < chunk.line_info.len() {
             chunk.line_info[pc]