MiniLua.cs

// MiniLua for a Timberborn mod in development - marvinb
// No external dependencies! No more moonscript dll
// Supports:
// Variables (local + global), if/elseif/else, while, repeat/until,
// numeric for, generic for (ipairs/pairs), functions (closures),
// tables, multiple return values, string concatenation, basic stdlib.

using System;
using System.Collections.Generic;
using System.Text;

namespace Mods.DamLogic {

// ─────────────────────────────────────────────────────────────────────────────
// VALUES
// ─────────────────────────────────────────────────────────────────────────────

public class LuaError : Exception {
    public LuaError(string msg) : base(msg) { }
}

public class LuaValue {
    public enum Kind { Nil, Bool, Number, String, Table, Function }

    public static readonly LuaValue Nil   = new LuaValue();
    public static readonly LuaValue True  = new LuaValue(true);
    public static readonly LuaValue False = new LuaValue(false);

    public readonly Kind Type;
    private readonly bool   _b;
    private readonly double _n;
    private readonly string _s;
    public  readonly LuaTable  Table;
    public  readonly Func<LuaValue[], LuaValue[]> Func;

    public LuaValue()                                         { Type = Kind.Nil; }
    public LuaValue(bool b)                                   { Type = Kind.Bool;     _b = b; }
    public LuaValue(double n)                                 { Type = Kind.Number;   _n = n; }
    public LuaValue(string s)                                 { Type = Kind.String;   _s = s; }
    public LuaValue(LuaTable t)                               { Type = Kind.Table;    Table = t; }
    public LuaValue(Func<LuaValue[], LuaValue[]> f)           { Type = Kind.Function; Func = f; }

    public bool   IsNil      => Type == Kind.Nil;
    public bool   IsBool     => Type == Kind.Bool;
    public bool   IsNumber   => Type == Kind.Number;
    public bool   IsString   => Type == Kind.String;
    public bool   IsTable    => Type == Kind.Table;
    public bool   IsFunction => Type == Kind.Function;

    public bool   BoolVal => _b;
    public double NumVal  => _n;
    public string StrVal  => _s;

    public bool Truthy => !(Type == Kind.Nil || (Type == Kind.Bool && !_b));

    public static LuaValue Of(bool b)   => b ? True : False;
    public static LuaValue Of(double n) => new LuaValue(n);
    public static LuaValue Of(string s) => s == null ? Nil : new LuaValue(s);

    public string ToLuaString() {
        switch (Type) {
            case Kind.Nil:      return "nil";
            case Kind.Bool:     return _b ? "true" : "false";
            case Kind.Number:
                if (double.IsNaN(_n))      return "-nan";
                if (double.IsInfinity(_n)) return _n > 0 ? "inf" : "-inf";
                if (_n == Math.Floor(_n) && Math.Abs(_n) < 1e15)
                    return ((long)_n).ToString();
                return _n.ToString("G14", System.Globalization.CultureInfo.InvariantCulture);
            case Kind.String:   return _s;
            case Kind.Table:    return "table: 0x" + Table.GetHashCode().ToString("x");
            case Kind.Function: return "function: 0x" + Func.GetHashCode().ToString("x");
            default:            return "nil";
        }
    }

    public override string ToString() => ToLuaString();
}

public class LuaTable {
    private readonly List<LuaValue>              _arr  = new List<LuaValue>();
    private readonly Dictionary<string, LuaValue> _hash = new Dictionary<string, LuaValue>();

    public LuaValue Get(LuaValue key) {
        if (key.IsNumber) {
            int i = (int)key.NumVal - 1;
            if (i >= 0 && i < _arr.Count && !_arr[i].IsNil) return _arr[i];
        }
        if (key.IsString && _hash.TryGetValue(key.StrVal, out var sv)) return sv;
        if (key.IsNumber && _hash.TryGetValue(key.NumVal.ToString(), out var nv)) return nv;
        return LuaValue.Nil;
    }

    public LuaValue Get(string key) =>
        _hash.TryGetValue(key, out var v) ? v : LuaValue.Nil;

    public void Set(LuaValue key, LuaValue val) {
        if (key.IsNil) throw new LuaError("table index is nil");
        if (key.IsNumber) {
            int i = (int)key.NumVal - 1;
            if (i >= 0 && (int)key.NumVal == key.NumVal) {
                while (_arr.Count <= i) _arr.Add(LuaValue.Nil);
                _arr[i] = val;
                return;
            }
        }
        string sk = key.IsString ? key.StrVal : key.ToLuaString();
        if (val.IsNil) _hash.Remove(sk);
        else           _hash[sk] = val;
    }

    public void Set(string key, LuaValue val) {
        if (val.IsNil) _hash.Remove(key);
        else           _hash[key] = val;
    }

    public int Length() {
        // Binary search
        int n = _arr.Count;
        while (n > 0 && _arr[n - 1].IsNil) n--;
        return n;
    }

    public IEnumerable<(LuaValue k, LuaValue v)> Pairs() {
        for (int i = 0; i < _arr.Count; i++)
            if (!_arr[i].IsNil) yield return (LuaValue.Of(i + 1.0), _arr[i]);
        foreach (var kv in _hash)
            yield return (LuaValue.Of(kv.Key), kv.Value);
    }

    public void Append(LuaValue val) {
        _arr.Add(val);
    }

    public void RemoveAt(int oneBasedIdx) {
        int i = oneBasedIdx - 1;
        if (i >= 0 && i < _arr.Count) _arr.RemoveAt(i);
    }
}


enum TK {
    Number, Str, Name,
    Plus, Minus, Star, Slash, Percent, Caret, Hash,
    DotDot, DotDotDot, Dot,
    Eq, Neq, Lt, Gt, Leq, Geq, Assign,
    LParen, RParen, LBrack, RBrack, LBrace, RBrace,
    Comma, Semi, Colon,
    KAnd, KBreak, KDo, KElse, KElseif, KEnd, KFalse, KFor,
    KFunction, KIf, KIn, KLocal, KNil, KNot, KOr, KRepeat,
    KReturn, KThen, KTrue, KUntil, KWhile,
    EOF
}

struct Token {
    public TK     Type;
    public string Raw;   // identifier / string value
    public double Num;   // numeric value
    public int    Line;
}

class Lexer {
    private readonly string _src;
    private int _pos;
    public int Line = 1;

    private static readonly Dictionary<string, TK> _kw = new Dictionary<string, TK> {
        {"and",TK.KAnd},{"break",TK.KBreak},{"do",TK.KDo},{"else",TK.KElse},
        {"elseif",TK.KElseif},{"end",TK.KEnd},{"false",TK.KFalse},{"for",TK.KFor},
        {"function",TK.KFunction},{"if",TK.KIf},{"in",TK.KIn},{"local",TK.KLocal},
        {"nil",TK.KNil},{"not",TK.KNot},{"or",TK.KOr},{"repeat",TK.KRepeat},
        {"return",TK.KReturn},{"then",TK.KThen},{"true",TK.KTrue},
        {"until",TK.KUntil},{"while",TK.KWhile}
    };

    public Lexer(string src) { _src = src ?? ""; }

    private char C(int offset = 0) {
        int p = _pos + offset;
        return p < _src.Length ? _src[p] : '\0';
    }

    private char Eat() {
        char c = C();
        _pos++;
        if (c == '\n') Line++;
        return c;
    }

    public Token Next() {
        // skip whitespace and comments
        while (_pos < _src.Length) {
            if (char.IsWhiteSpace(C())) { Eat(); continue; }
            if (C() == '-' && C(1) == '-') {
                if (C(2) == '[' && C(3) == '[') {
                    // long comment
                    _pos += 4;
                    while (_pos < _src.Length - 1 && !(C() == ']' && C(1) == ']')) Eat();
                    _pos += 2;
                } else {
                    while (_pos < _src.Length && C() != '\n') _pos++;
                }
                continue;
            }
            break;
        }

        int line = Line;
        if (_pos >= _src.Length) return Tok(TK.EOF, line);

        char c = C();

        // numbers
        if (char.IsDigit(c) || (c == '.' && char.IsDigit(C(1)))) {
            var sb = new StringBuilder();
            bool hasDot = false, hasExp = false;
            while (_pos < _src.Length) {
                char ch = C();
                if (char.IsDigit(ch)) { sb.Append(Eat()); }
                else if (ch == '.' && !hasDot && !hasExp) { hasDot = true; sb.Append(Eat()); }
                else if ((ch == 'e' || ch == 'E') && !hasExp) {
                    hasExp = true; sb.Append(Eat());
                    if (C() == '+' || C() == '-') sb.Append(Eat());
                } else break;
            }
            double.TryParse(sb.ToString(),
                System.Globalization.NumberStyles.Float,
                System.Globalization.CultureInfo.InvariantCulture, out double n);
            return new Token { Type = TK.Number, Num = n, Line = line };
        }

        // strings
        if (c == '"' || c == '\'') {
            Eat();
            var sb = new StringBuilder();
            while (_pos < _src.Length && C() != c) {
                if (C() == '\\') {
                    Eat();
                    char e = Eat();
                    switch (e) {
                        case 'n': sb.Append('\n'); break; case 't': sb.Append('\t'); break;
                        case 'r': sb.Append('\r'); break; case '\\': sb.Append('\\'); break;
                        case '"': sb.Append('"');  break; case '\'': sb.Append('\''); break;
                        default:  sb.Append(e);    break;
                    }
                } else sb.Append(Eat());
            }
            if (_pos < _src.Length) Eat(); // closing quote
            return new Token { Type = TK.Str, Raw = sb.ToString(), Line = line };
        }

        // long strings [[...]]
        if (c == '[' && C(1) == '[') {
            _pos += 2;
            var sb = new StringBuilder();
            while (_pos < _src.Length - 1 && !(C() == ']' && C(1) == ']')) sb.Append(Eat());
            _pos += 2;
            return new Token { Type = TK.Str, Raw = sb.ToString(), Line = line };
        }

        // identifiers / keywords
        if (char.IsLetter(c) || c == '_') {
            var sb = new StringBuilder();
            while (_pos < _src.Length && (char.IsLetterOrDigit(C()) || C() == '_')) sb.Append(Eat());
            var name = sb.ToString();
            if (_kw.TryGetValue(name, out var kw)) return new Token { Type = kw, Raw = name, Line = line };
            return new Token { Type = TK.Name, Raw = name, Line = line };
        }

        Eat();
        switch (c) {
            case '+': return Tok(TK.Plus,   line);
            case '*': return Tok(TK.Star,   line);
            case '^': return Tok(TK.Caret,  line);
            case '#': return Tok(TK.Hash,   line);
            case '%': return Tok(TK.Percent,line);
            case '(': return Tok(TK.LParen, line);
            case ')': return Tok(TK.RParen, line);
            case '[': return Tok(TK.LBrack, line);
            case ']': return Tok(TK.RBrack, line);
            case '{': return Tok(TK.LBrace, line);
            case '}': return Tok(TK.RBrace, line);
            case ',': return Tok(TK.Comma,  line);
            case ';': return Tok(TK.Semi,   line);
            case ':': return Tok(TK.Colon,  line);
            case '-': return Tok(TK.Minus,  line);
            case '/': return Tok(TK.Slash,  line);
            case '~': if (C() == '=') { Eat(); return Tok(TK.Neq, line); }
                      throw new LuaError($"line {line}: unexpected '~'");
            case '<': if (C() == '=') { Eat(); return Tok(TK.Leq, line); } return Tok(TK.Lt, line);
            case '>': if (C() == '=') { Eat(); return Tok(TK.Geq, line); } return Tok(TK.Gt, line);
            case '=': if (C() == '=') { Eat(); return Tok(TK.Eq,  line); } return Tok(TK.Assign, line);
            case '.':
                if (C() == '.') { Eat(); if (C() == '.') { Eat(); return Tok(TK.DotDotDot, line); } return Tok(TK.DotDot, line); }
                return Tok(TK.Dot, line);
            default:
                throw new LuaError($"line {line}: unexpected character '{c}'");
        }
    }

    private static Token Tok(TK t, int line) => new Token { Type = t, Line = line };
}


abstract class Node { public int Line; }
abstract class Stmt : Node { }
abstract class Expr : Node { }

class Block { public List<Stmt> Stmts = new List<Stmt>(); }

class LocalDecl  : Stmt { public List<string> Names; public List<Expr> Values; }
class AssignStmt : Stmt { public List<Expr> Targets; public List<Expr> Values; }
class DoStmt     : Stmt { public Block Body; }
class WhileStmt  : Stmt { public Expr Cond; public Block Body; }
class RepeatStmt : Stmt { public Block Body; public Expr Cond; }
class IfStmt     : Stmt { public List<(Expr Cond, Block Body)> Clauses; public Block Else; }
class NumFor     : Stmt { public string Var; public Expr Start, Limit, Step; public Block Body; }
class GenFor     : Stmt { public List<string> Vars; public List<Expr> Iters; public Block Body; }
class ReturnStmt : Stmt { public List<Expr> Values; }
class BreakStmt  : Stmt { }
class FuncDeclStmt : Stmt { public string[] Path; public bool IsMethod; public FuncDef Def; }
class LocalFuncStmt : Stmt { public string Name; public FuncDef Def; }
class ExprStmt   : Stmt { public Expr E; }

class NumberLit : Expr { public double Val; }
class StringLit : Expr { public string Val; }
class BoolLit   : Expr { public bool   Val; }
class NilLit    : Expr { }
class VarArgExpr : Expr { }
class NameExpr  : Expr { public string Name; }
class BinOpExpr : Expr { public string Op; public Expr L, R; }
class UnOpExpr  : Expr { public string Op; public Expr E; }
class IndexExpr : Expr { public Expr Tbl, Key; }
class FieldExpr : Expr { public Expr Tbl; public string Field; }
class CallExpr  : Expr { public Expr Fn; public List<Expr> Args; }
class MethodCallExpr : Expr { public Expr Obj; public string Method; public List<Expr> Args; }
class FuncExpr  : Expr { public FuncDef Def; }
class TableCtor : Expr { public List<(Expr Key, Expr Val)> Fields; }

class FuncDef { public List<string> Params; public bool VarArg; public Block Body; }

// ─────────────────────────────────────────────────────────────────────────────
// PARSER
// ─────────────────────────────────────────────────────────────────────────────

class Parser {
    private readonly Lexer _lex;
    private Token _cur, _peek;

    public Parser(string src) {
        _lex = new Lexer(src);
        _cur  = _lex.Next();
        _peek = _lex.Next();
    }

    private Token Advance() {
        var t = _cur; _cur = _peek; _peek = _lex.Next(); return t;
    }

    private bool Check(TK t) => _cur.Type == t;
    private bool CheckPeek(TK t) => _peek.Type == t;

    private bool Match(TK t) { if (Check(t)) { Advance(); return true; } return false; }

    private Token Expect(TK t) {
        if (!Check(t)) throw new LuaError($"line {_cur.Line}: expected {t}, got {_cur.Type} '{_cur.Raw}'");
        return Advance();
    }

    // ── Blocks & Statements ──────────────────────────────────────────────────

    public Block ParseBlock() {
        var b = new Block();
        while (true) {
            while (Match(TK.Semi)) { }
            var t = _cur.Type;
            if (t == TK.EOF || t == TK.KEnd || t == TK.KElse ||
                t == TK.KElseif || t == TK.KUntil) break;
            if (t == TK.KReturn) { b.Stmts.Add(ParseReturn()); Match(TK.Semi); break; }
            b.Stmts.Add(ParseStmt());
        }
        return b;
    }

    private Stmt ParseStmt() {
        int line = _cur.Line;
        Stmt s;
        switch (_cur.Type) {
            case TK.KLocal:    s = ParseLocal();    break;
            case TK.KFunction: s = ParseFuncDecl(); break;
            case TK.KIf:       s = ParseIf();       break;
            case TK.KWhile:    s = ParseWhile();    break;
            case TK.KRepeat:   s = ParseRepeat();   break;
            case TK.KFor:      s = ParseFor();      break;
            case TK.KDo:
                Advance();
                var body = ParseBlock();
                Expect(TK.KEnd);
                s = new DoStmt { Body = body };
                break;
            case TK.KBreak:
                Advance();
                s = new BreakStmt();
                break;
            default:
                s = ParseExprStat();
                break;
        }
        s.Line = line;
        return s;
    }

    private Stmt ParseLocal() {
        Expect(TK.KLocal);
        if (Check(TK.KFunction)) {
            Advance();
            var name = Expect(TK.Name).Raw;
            var def  = ParseFuncDef();
            return new LocalFuncStmt { Name = name, Def = def };
        }
        var names = new List<string> { Expect(TK.Name).Raw };
        while (Match(TK.Comma)) names.Add(Expect(TK.Name).Raw);
        var vals = new List<Expr>();
        if (Match(TK.Assign)) vals = ParseExprList();
        return new LocalDecl { Names = names, Values = vals };
    }

    private Stmt ParseFuncDecl() {
        Expect(TK.KFunction);
        var path = new List<string> { Expect(TK.Name).Raw };
        while (Check(TK.Dot)) { Advance(); path.Add(Expect(TK.Name).Raw); }
        bool isMethod = false;
        if (Check(TK.Colon)) {
            Advance(); path.Add(Expect(TK.Name).Raw); isMethod = true;
        }
        var def = ParseFuncDef();
        if (isMethod) def.Params.Insert(0, "self");
        return new FuncDeclStmt { Path = path.ToArray(), IsMethod = isMethod, Def = def };
    }

    private FuncDef ParseFuncDef() {
        Expect(TK.LParen);
        var parms  = new List<string>();
        bool vararg = false;
        if (!Check(TK.RParen)) {
            if (Check(TK.DotDotDot)) { Advance(); vararg = true; }
            else {
                parms.Add(Expect(TK.Name).Raw);
                while (!Check(TK.RParen) && Match(TK.Comma)) {
                    if (Check(TK.DotDotDot)) { Advance(); vararg = true; break; }
                    parms.Add(Expect(TK.Name).Raw);
                }
            }
        }
        Expect(TK.RParen);
        var body = ParseBlock();
        Expect(TK.KEnd);
        return new FuncDef { Params = parms, VarArg = vararg, Body = body };
    }

    private Stmt ParseIf() {
        Expect(TK.KIf);
        var clauses = new List<(Expr, Block)>();
        clauses.Add((ParseExpr(), (Expect(TK.KThen), ParseBlock()).Item2));
        while (Check(TK.KElseif)) {
            Advance();
            clauses.Add((ParseExpr(), (Expect(TK.KThen), ParseBlock()).Item2));
        }
        Block elseBlock = null;
        if (Match(TK.KElse)) elseBlock = ParseBlock();
        Expect(TK.KEnd);
        return new IfStmt { Clauses = clauses, Else = elseBlock };
    }

    private Stmt ParseWhile() {
        Expect(TK.KWhile);
        var cond = ParseExpr();
        Expect(TK.KDo);
        var body = ParseBlock();
        Expect(TK.KEnd);
        return new WhileStmt { Cond = cond, Body = body };
    }

    private Stmt ParseRepeat() {
        Expect(TK.KRepeat);
        var body = ParseBlock();
        Expect(TK.KUntil);
        return new RepeatStmt { Body = body, Cond = ParseExpr() };
    }

    private Stmt ParseFor() {
        Expect(TK.KFor);
        var name = Expect(TK.Name).Raw;
        if (Match(TK.Assign)) {
            var start = ParseExpr(); Expect(TK.Comma);
            var limit = ParseExpr();
            Expr step = new NumberLit { Val = 1 };
            if (Match(TK.Comma)) step = ParseExpr();
            Expect(TK.KDo); var body = ParseBlock(); Expect(TK.KEnd);
            return new NumFor { Var = name, Start = start, Limit = limit, Step = step, Body = body };
        }
        var names = new List<string> { name };
        while (Match(TK.Comma)) names.Add(Expect(TK.Name).Raw);
        Expect(TK.KIn);
        var iters = ParseExprList();
        Expect(TK.KDo); var gbody = ParseBlock(); Expect(TK.KEnd);
        return new GenFor { Vars = names, Iters = iters, Body = gbody };
    }

    private Stmt ParseReturn() {
        Expect(TK.KReturn);
        var vals = new List<Expr>();
        if (!Check(TK.KEnd) && !Check(TK.KElse) && !Check(TK.KElseif) &&
            !Check(TK.KUntil) && !Check(TK.EOF) && !Check(TK.Semi))
            vals = ParseExprList();
        return new ReturnStmt { Values = vals };
    }

    private Stmt ParseExprStat() {
        var e = ParseSuffixExpr();
        if (Check(TK.Assign) || Check(TK.Comma)) {
            var targets = new List<Expr> { e };
            while (Match(TK.Comma)) targets.Add(ParseSuffixExpr());
            Expect(TK.Assign);
            return new AssignStmt { Targets = targets, Values = ParseExprList() };
        }
        if (!(e is CallExpr || e is MethodCallExpr))
            throw new LuaError($"line {_cur.Line}: syntax error near expression");
        return new ExprStmt { E = e };
    }

    private List<Expr> ParseExprList() {
        var list = new List<Expr> { ParseExpr() };
        while (Match(TK.Comma)) list.Add(ParseExpr());
        return list;
    }

    // ── Expressions ──

    public Expr ParseExpr() => ParseOr();

    private Expr ParseOr() {
        var e = ParseAnd();
        while (Check(TK.KOr))  { Advance(); e = new BinOpExpr { Op="or",  L=e, R=ParseAnd() }; }
        return e;
    }
    private Expr ParseAnd() {
        var e = ParseCmp();
        while (Check(TK.KAnd)) { Advance(); e = new BinOpExpr { Op="and", L=e, R=ParseCmp() }; }
        return e;
    }
    private Expr ParseCmp() {
        var e = ParseConcat();
        while (true) {
            string op = null;
            switch (_cur.Type) {
                case TK.Lt:  op="<";  break; case TK.Gt:  op=">";  break;
                case TK.Leq: op="<="; break; case TK.Geq: op=">="; break;
                case TK.Eq:  op="=="; break; case TK.Neq: op="~="; break;
            }
            if (op == null) break;
            Advance();
            e = new BinOpExpr { Op=op, L=e, R=ParseConcat() };
        }
        return e;
    }
    private Expr ParseConcat() {
        var e = ParseAdd();
        if (Check(TK.DotDot)) { Advance(); return new BinOpExpr { Op="..", L=e, R=ParseConcat() }; }
        return e;
    }
    private Expr ParseAdd() {
        var e = ParseMul();
        while (Check(TK.Plus) || Check(TK.Minus)) {
            var op = Advance().Type == TK.Plus ? "+" : "-";
            e = new BinOpExpr { Op=op, L=e, R=ParseMul() };
        }
        return e;
    }
    private Expr ParseMul() {
        var e = ParseUnary();
        while (Check(TK.Star) || Check(TK.Slash) || Check(TK.Percent)) {
            var t = Advance().Type;
            var op = t==TK.Star?"*":t==TK.Slash?"/":"%";
            e = new BinOpExpr { Op=op, L=e, R=ParseUnary() };
        }
        return e;
    }
    private Expr ParseUnary() {
        if (Check(TK.KNot))  { Advance(); return new UnOpExpr { Op="not", E=ParseUnary() }; }
        if (Check(TK.Minus)) { Advance(); return new UnOpExpr { Op="-",   E=ParseUnary() }; }
        if (Check(TK.Hash))  { Advance(); return new UnOpExpr { Op="#",   E=ParseUnary() }; }
        return ParsePow();
    }
    private Expr ParsePow() {
        var e = ParseSuffixExpr();
        if (Check(TK.Caret)) { Advance(); return new BinOpExpr { Op="^", L=e, R=ParseUnary() }; }
        return e;
    }

    private Expr ParseSuffixExpr() {
        var e = ParsePrimary();
        while (true) {
            if (Match(TK.Dot)) {
                e = new FieldExpr { Tbl=e, Field=Expect(TK.Name).Raw };
            } else if (Check(TK.LBrack)) {
                Advance(); var key=ParseExpr(); Expect(TK.RBrack);
                e = new IndexExpr { Tbl=e, Key=key };
            } else if (Check(TK.Colon)) {
                Advance(); var m=Expect(TK.Name).Raw; var args=ParseCallArgs();
                e = new MethodCallExpr { Obj=e, Method=m, Args=args };
            } else if (Check(TK.LParen)||Check(TK.LBrace)||Check(TK.Str)) {
                e = new CallExpr { Fn=e, Args=ParseCallArgs() };
            } else break;
        }
        return e;
    }

    private List<Expr> ParseCallArgs() {
        if (Check(TK.LParen)) {
            Advance();
            var args = Check(TK.RParen) ? new List<Expr>() : ParseExprList();
            Expect(TK.RParen);
            return args;
        }
        if (Check(TK.LBrace)) return new List<Expr> { ParseTableCtorExpr() };
        if (Check(TK.Str)) { var s=Advance(); return new List<Expr> { new StringLit{Val=s.Raw} }; }
        throw new LuaError($"line {_cur.Line}: expected function args");
    }

    private Expr ParsePrimary() {
        int line = _cur.Line;
        switch (_cur.Type) {
            case TK.Number:    { var v=Advance().Num;  return new NumberLit{Val=v, Line=line}; }
            case TK.Str:       { var v=Advance().Raw;  return new StringLit{Val=v, Line=line}; }
            case TK.KTrue:     Advance(); return new BoolLit{Val=true,  Line=line};
            case TK.KFalse:    Advance(); return new BoolLit{Val=false, Line=line};
            case TK.KNil:      Advance(); return new NilLit{Line=line};
            case TK.DotDotDot: Advance(); return new VarArgExpr{Line=line};
            case TK.Name:      { var n=Advance().Raw;  return new NameExpr{Name=n, Line=line}; }
            case TK.LParen:
                Advance(); var e=ParseExpr(); Expect(TK.RParen);
                return e;
            case TK.KFunction:
                Advance(); return new FuncExpr{Def=ParseFuncDef(), Line=line};
            case TK.LBrace:
                return ParseTableCtorExpr();
            default:
                throw new LuaError($"line {line}: unexpected token {_cur.Type} '{_cur.Raw}'");
        }
    }

    private Expr ParseTableCtorExpr() {
        Expect(TK.LBrace);
        var fields = new List<(Expr, Expr)>();
        int arrIdx = 1;
        while (!Check(TK.RBrace) && !Check(TK.EOF)) {
            if (Check(TK.LBrack)) {
                Advance(); var k=ParseExpr(); Expect(TK.RBrack); Expect(TK.Assign);
                fields.Add((k, ParseExpr()));
            } else if (Check(TK.Name) && CheckPeek(TK.Assign)) {
                var k = new StringLit { Val = Advance().Raw }; Advance();
                fields.Add((k, ParseExpr()));
            } else {
                fields.Add((new NumberLit{Val=arrIdx++}, ParseExpr()));
            }
            if (!Match(TK.Comma)) Match(TK.Semi);
        }
        Expect(TK.RBrace);
        return new TableCtor { Fields = fields };
    }
}

// ─────────────────────────────────────────────────────────────────────────────
// ENVIRONMENT
// ─────────────────────────────────────────────────────────────────────────────

class LuaEnv {
    private readonly Dictionary<string, LuaValue> _vars = new Dictionary<string, LuaValue>();
    private readonly LuaEnv _parent;

    public LuaEnv(LuaEnv parent = null) { _parent = parent; }

    public LuaValue Get(string name) {
        if (_vars.TryGetValue(name, out var v)) return v;
        return _parent != null ? _parent.Get(name) : LuaValue.Nil;
    }

    public void SetLocal(string name, LuaValue val) => _vars[name] = val;

    public void SetExisting(string name, LuaValue val) {
        if (_vars.ContainsKey(name)) { _vars[name] = val; return; }
        if (_parent != null) { _parent.SetExisting(name, val); return; }
        _vars[name] = val; // global fallback
    }
}

// ─────────────────────────────────────────────────────────────────────────────
// CONTROL FLOW SIGNALS
// ─────────────────────────────────────────────────────────────────────────────

class ReturnSignal  : Exception { public LuaValue[] Vals; public ReturnSignal(LuaValue[] v): base("") { Vals=v; } }
class BreakSignal   : Exception { public BreakSignal() : base("") { } }

// ─────────────────────────────────────────────────────────────────────────────
// INTERPRETER
// ─────────────────────────────────────────────────────────────────────────────

public class MiniLua {
    private readonly LuaEnv     _globals;
    private readonly StringBuilder _output;
    private LuaValue[]          _varArgs = new LuaValue[0];

    public MiniLua(Action<string> printCallback = null) {
        _output = new StringBuilder();
        _globals = new LuaEnv();
        RegisterStdlib(printCallback);
    }

    /// Running the lua code
    public string Execute(string code) {
        _output.Clear();
        var parser = new Parser(code);
        var block  = parser.ParseBlock();
        ExecBlock(block, _globals);
        return _output.ToString().TrimEnd();
    }

    // ── Standard library ─────────────────────────────────────────────────────

    private void RegisterStdlib(Action<string> printCb) {
        void Print(string s) {
            _output.AppendLine(s);
            printCb?.Invoke(s);
        }

        SetGlobal("print", new LuaValue((LuaValue[] args) => {
            Print(string.Join("\t", System.Array.ConvertAll(args, a => a.ToLuaString())));
            return new LuaValue[0];
        }));

        SetGlobal("tostring", new LuaValue((LuaValue[] args) =>
            new[] { LuaValue.Of(Arg(args,0).ToLuaString()) }));

        SetGlobal("tonumber", new LuaValue((LuaValue[] args) => {
            var a = Arg(args, 0);
            if (a.IsNumber) return new[] { a };
            if (a.IsString && double.TryParse(a.StrVal,
                System.Globalization.NumberStyles.Float,
                System.Globalization.CultureInfo.InvariantCulture, out double n))
                return new[] { LuaValue.Of(n) };
            return new[] { LuaValue.Nil };
        }));

        SetGlobal("type", new LuaValue((LuaValue[] args) => {
            var a = Arg(args, 0);
            string t = a.Type.ToString().ToLower();
            if (t == "bool") t = "boolean";
            return new[] { LuaValue.Of(t) };
        }));

        SetGlobal("error", new LuaValue((LuaValue[] args) => {
            throw new LuaError(Arg(args, 0).ToLuaString());
        }));

        SetGlobal("assert", new LuaValue((LuaValue[] args) => {
            var a = Arg(args, 0);
            if (!a.Truthy) throw new LuaError(args.Length > 1 ? Arg(args,1).ToLuaString() : "assertion failed");
            return args;
        }));

        SetGlobal("ipairs", new LuaValue((LuaValue[] args) => {
            var tbl = Arg(args, 0); if (!tbl.IsTable) throw new LuaError("ipairs expects table");
            int i = 0;
            var iter = new LuaValue((LuaValue[] _) => {
                i++;
                var v = tbl.Table.Get(LuaValue.Of((double)i));
                if (v.IsNil) return new LuaValue[] { LuaValue.Nil };
                return new LuaValue[] { LuaValue.Of((double)i), v };
            });
            return new LuaValue[] { iter, tbl, LuaValue.Of(0.0) };
        }));

        SetGlobal("pairs", new LuaValue((LuaValue[] args) => {
            var tbl = Arg(args, 0); if (!tbl.IsTable) throw new LuaError("pairs expects table");
            var en = tbl.Table.Pairs().GetEnumerator();
            var iter = new LuaValue((LuaValue[] _) => {
                if (!en.MoveNext()) return new LuaValue[] { LuaValue.Nil };
                return new LuaValue[] { en.Current.k, en.Current.v };
            });
            return new LuaValue[] { iter, tbl, LuaValue.Nil };
        }));

        SetGlobal("select", new LuaValue((LuaValue[] args) => {
            var idx = Arg(args, 0);
            if (idx.IsString && idx.StrVal == "#") return new[] { LuaValue.Of((double)(args.Length - 1)) };
            int i = (int)idx.NumVal;
            if (i < 0) i = args.Length + i;
            var result = new List<LuaValue>();
            for (int j = i; j < args.Length; j++) result.Add(args[j]);
            return result.ToArray();
        }));

        SetGlobal("unpack", new LuaValue((LuaValue[] args) => {
            var tbl = Arg(args, 0); if (!tbl.IsTable) return new LuaValue[0];
            int from = args.Length > 1 ? (int)Arg(args,1).NumVal : 1;
            int to   = args.Length > 2 ? (int)Arg(args,2).NumVal : tbl.Table.Length();
            var result = new List<LuaValue>();
            for (int i = from; i <= to; i++) result.Add(tbl.Table.Get(LuaValue.Of((double)i)));
            return result.ToArray();
        }));

        // math table
        var math = new LuaTable();
        math.Set("pi",    LuaValue.Of(Math.PI));
        math.Set("huge",  LuaValue.Of(double.PositiveInfinity));
        math.Set("floor", Fn1(x => Math.Floor(x)));
        math.Set("ceil",  Fn1(x => Math.Ceiling(x)));
        math.Set("abs",   Fn1(x => Math.Abs(x)));
        math.Set("sqrt",  Fn1(x => Math.Sqrt(x)));
        math.Set("sin",   Fn1(x => Math.Sin(x)));
        math.Set("cos",   Fn1(x => Math.Cos(x)));
        math.Set("exp",   Fn1(x => Math.Exp(x)));
        math.Set("log",   Fn1(x => Math.Log(x)));
        math.Set("max",   new LuaValue((LuaValue[] a) => { double m=a[0].NumVal; for(int i=1;i<a.Length;i++) if(a[i].NumVal>m) m=a[i].NumVal; return new[]{LuaValue.Of(m)}; }));
        math.Set("min",   new LuaValue((LuaValue[] a) => { double m=a[0].NumVal; for(int i=1;i<a.Length;i++) if(a[i].NumVal<m) m=a[i].NumVal; return new[]{LuaValue.Of(m)}; }));
        math.Set("fmod",  new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of(a[0].NumVal % a[1].NumVal) }));
        math.Set("pow",   new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of(Math.Pow(a[0].NumVal, a[1].NumVal)) }));
        var rng = new Random();
        math.Set("random", new LuaValue((LuaValue[] a) => {
            if (a.Length == 0) return new[]{ LuaValue.Of(rng.NextDouble()) };
            int lo=1, hi=(int)a[0].NumVal;
            if (a.Length>1){lo=hi; hi=(int)a[1].NumVal;}
            return new[]{ LuaValue.Of((double)rng.Next(lo, hi+1)) };
        }));
        SetGlobal("math", new LuaValue(math));

        // string table
        var str = new LuaTable();
        str.Set("len",   new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of((double)Arg(a,0).StrVal.Length) }));
        str.Set("sub",   new LuaValue((LuaValue[] a) => {
            var s = Arg(a,0).StrVal;
            int i = LuaIdx(Arg(a,1).NumVal, s.Length);
            int j = a.Length>2 ? LuaIdx(Arg(a,2).NumVal, s.Length) : s.Length-1;
            if (i>j||i>=s.Length||j<0) return new[]{LuaValue.Of("")};
            i=Math.Max(0,i); j=Math.Min(s.Length-1,j);
            return new[]{ LuaValue.Of(s.Substring(i, j-i+1)) };
        }));
        str.Set("upper", new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of(Arg(a,0).StrVal.ToUpper()) }));
        str.Set("lower", new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of(Arg(a,0).StrVal.ToLower()) }));
        str.Set("rep",   new LuaValue((LuaValue[] a) => {
            var sb2 = new StringBuilder();
            int n=(int)Arg(a,1).NumVal;
            for(int i=0;i<n;i++) sb2.Append(Arg(a,0).StrVal);
            return new[]{ LuaValue.Of(sb2.ToString()) };
        }));
        str.Set("reverse", new LuaValue((LuaValue[] a) => {
            var ch = Arg(a,0).StrVal.ToCharArray();
            System.Array.Reverse(ch);
            return new[]{ LuaValue.Of(new string(ch)) };
        }));
        str.Set("format", new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of(LuaFormat(a)) }));
        str.Set("find",   new LuaValue((LuaValue[] a) => {
            var s=Arg(a,0).StrVal; var pat=Arg(a,1).StrVal;
            int from = a.Length>2 ? (int)Arg(a,2).NumVal-1 : 0;
            from = Math.Max(0,from);
            int idx = s.IndexOf(pat, from, StringComparison.Ordinal);
            if (idx<0) return new[]{LuaValue.Nil};
            return new[]{ LuaValue.Of((double)(idx+1)), LuaValue.Of((double)(idx+pat.Length)) };
        }));
        SetGlobal("string", new LuaValue(str));

        // table table
        var tbl = new LuaTable();
        tbl.Set("insert", new LuaValue((LuaValue[] a) => {
            var t2=Arg(a,0).Table;
            if(a.Length==2) t2.Append(Arg(a,1));
            else { /* insert at position — simplified */ t2.Append(Arg(a,2)); }
            return new LuaValue[0];
        }));
        tbl.Set("remove", new LuaValue((LuaValue[] a) => {
            var t2=Arg(a,0).Table;
            int i2=a.Length>1?(int)Arg(a,1).NumVal:t2.Length();
            var old=t2.Get(LuaValue.Of((double)i2));
            t2.RemoveAt(i2);
            return new[]{old};
        }));
        tbl.Set("concat", new LuaValue((LuaValue[] a) => {
            var t2=Arg(a,0).Table; var sep=a.Length>1?Arg(a,1).StrVal:"";
            int from=a.Length>2?(int)Arg(a,2).NumVal:1;
            int to2=a.Length>3?(int)Arg(a,3).NumVal:t2.Length();
            var parts=new List<string>();
            for(int i=from;i<=to2;i++) parts.Add(t2.Get(LuaValue.Of((double)i)).ToLuaString());
            return new[]{LuaValue.Of(string.Join(sep,parts))};
        }));
        SetGlobal("table", new LuaValue(tbl));

        SetGlobal("rawget", new LuaValue((LuaValue[] a) => new[]{ Arg(a,0).Table.Get(Arg(a,1)) }));
        SetGlobal("rawset", new LuaValue((LuaValue[] a) => { Arg(a,0).Table.Set(Arg(a,1),Arg(a,2)); return new[]{Arg(a,0)}; }));
    }

    private static LuaValue Arg(LuaValue[] a, int i) => i < a.Length ? a[i] : LuaValue.Nil;
    private static int LuaIdx(double d, int len) => d >= 0 ? (int)d - 1 : len + (int)d;
    private static LuaValue Fn1(Func<double,double> f) =>
        new LuaValue((LuaValue[] a) => new[]{ LuaValue.Of(f(Arg(a,0).NumVal)) });

    /// global variable, call before Execute() to inject API tables
    public void SetGlobal(string name, LuaValue val) => _globals.SetLocal(name, val);

    // ── Execution ─────────────────────────────────────────────────────────────

    private void ExecBlock(Block b, LuaEnv env) {
        foreach (var s in b.Stmts) ExecStmt(s, env);
    }

    private void ExecStmt(Stmt s, LuaEnv env) {
        switch (s) {
            case LocalDecl ld: {
                var vals = EvalList(ld.Values, ld.Names.Count, env);
                for (int i = 0; i < ld.Names.Count; i++)
                    env.SetLocal(ld.Names[i], i < vals.Length ? vals[i] : LuaValue.Nil);
                break;
            }
            case AssignStmt a: {
                var vals = EvalList(a.Values, a.Targets.Count, env);
                for (int i = 0; i < a.Targets.Count; i++) {
                    var v = i < vals.Length ? vals[i] : LuaValue.Nil;
                    Assign(a.Targets[i], v, env);
                }
                break;
            }
            case ExprStmt es:
                Eval(es.E, env);
                break;
            case DoStmt ds:
                ExecBlock(ds.Body, new LuaEnv(env));
                break;
            case WhileStmt ws:
                while (Eval(ws.Cond, env).Truthy) {
                    try { ExecBlock(ws.Body, new LuaEnv(env)); }
                    catch (BreakSignal) { break; }
                }
                break;
            case RepeatStmt rs: {
                while (true) {
                    var inner = new LuaEnv(env);
                    bool brk = false;
                    try { ExecBlock(rs.Body, inner); }
                    catch (BreakSignal) { brk = true; }
                    if (brk || Eval(rs.Cond, inner).Truthy) break;
                }
                break;
            }
            case IfStmt i: {
                foreach (var (cond, body) in i.Clauses) {
                    if (Eval(cond, env).Truthy) { ExecBlock(body, new LuaEnv(env)); return; }
                }
                if (i.Else != null) ExecBlock(i.Else, new LuaEnv(env));
                break;
            }
            case NumFor nf: {
                double cur = Eval(nf.Start, env).NumVal;
                double lim = Eval(nf.Limit, env).NumVal;
                double stp = Eval(nf.Step,  env).NumVal;
                if (stp == 0) throw new LuaError("'for' step is zero");
                while ((stp > 0 && cur <= lim) || (stp < 0 && cur >= lim)) {
                    var inner = new LuaEnv(env);
                    inner.SetLocal(nf.Var, LuaValue.Of(cur));
                    try { ExecBlock(nf.Body, inner); }
                    catch (BreakSignal) { break; }
                    cur += stp;
                }
                break;
            }
            case GenFor gf: {
                var iterVals = EvalList(gf.Iters, 3, env);
                var iterFn   = iterVals.Length > 0 ? iterVals[0] : LuaValue.Nil;
                var state    = iterVals.Length > 1 ? iterVals[1] : LuaValue.Nil;
                var control  = iterVals.Length > 2 ? iterVals[2] : LuaValue.Nil;
                while (true) {
                    var results = CallFunction(iterFn, new[]{ state, control }, env);
                    if (results.Length == 0 || results[0].IsNil) break;
                    control = results[0];
                    var inner = new LuaEnv(env);
                    for (int j = 0; j < gf.Vars.Count; j++)
                        inner.SetLocal(gf.Vars[j], j < results.Length ? results[j] : LuaValue.Nil);
                    try { ExecBlock(gf.Body, inner); }
                    catch (BreakSignal) { break; }
                }
                break;
            }
            case ReturnStmt r:
                var rv = EvalAll(r.Values, env);
                throw new ReturnSignal(rv);
            case BreakStmt _:
                throw new BreakSignal();
            case FuncDeclStmt fd: {
                LuaValue fn = MakeClosure(fd.Def, env);
                if (fd.Path.Length == 1) {
                    env.SetExisting(fd.Path[0], fn);
                } else {
                    var tbl = env.Get(fd.Path[0]);
                    for (int i = 1; i < fd.Path.Length - 1; i++)
                        tbl = tbl.Table.Get(fd.Path[i]);
                    tbl.Table.Set(fd.Path[fd.Path.Length - 1], fn);
                }
                break;
            }
            case LocalFuncStmt lf:
                env.SetLocal(lf.Name, LuaValue.Nil); // forward decl
                env.SetLocal(lf.Name, MakeClosure(lf.Def, env));
                break;
        }
    }

    private void Assign(Expr target, LuaValue val, LuaEnv env) {
        switch (target) {
            case NameExpr n:
                env.SetExisting(n.Name, val); break;
            case FieldExpr f: {
                var tbl = Eval(f.Tbl, env);
                if (!tbl.IsTable) throw new LuaError($"attempt to index a {tbl.Type} value");
                tbl.Table.Set(f.Field, val); break;
            }
            case IndexExpr ix: {
                var tbl = Eval(ix.Tbl, env);
                if (!tbl.IsTable) throw new LuaError($"attempt to index a {tbl.Type} value");
                tbl.Table.Set(Eval(ix.Key, env), val); break;
            }
            default: throw new LuaError("invalid assignment target");
        }
    }

    // ── Evaluation ────────────────────────────────────────────────────────────

    private LuaValue Eval(Expr e, LuaEnv env) {
        var results = EvalMulti(e, env);
        return results.Length > 0 ? results[0] : LuaValue.Nil;
    }

    // Returns potentially multiple values (for calls and vararg)
    private LuaValue[] EvalMulti(Expr e, LuaEnv env) {
        switch (e) {
            case NumberLit n:  return One(LuaValue.Of(n.Val));
            case StringLit s:  return One(LuaValue.Of(s.Val));
            case BoolLit b:    return One(LuaValue.Of(b.Val));
            case NilLit _:     return One(LuaValue.Nil);
            case VarArgExpr _: return _varArgs;
            case NameExpr n:   return One(env.Get(n.Name));
            case FuncExpr fe:  return One(MakeClosure(fe.Def, env));
            case TableCtor tc: {
                var tbl = new LuaTable();
                int arrIdx = 1;
                for (int i = 0; i < tc.Fields.Count; i++) {
                    var (key, val) = tc.Fields[i];
                    bool isAutoIdx = key is NumberLit nl && nl.Val == arrIdx;
                    if (isAutoIdx && i == tc.Fields.Count - 1) {
                        // Last field — expand multi-return
                        var mv = EvalMulti(val, env);
                        foreach (var v in mv) { tbl.Set(LuaValue.Of((double)arrIdx++), v); }
                    } else if (isAutoIdx) {
                        tbl.Set(LuaValue.Of((double)arrIdx++), Eval(val, env));
                    } else {
                        tbl.Set(Eval(key, env), Eval(val, env));
                    }
                }
                return One(new LuaValue(tbl));
            }
            case FieldExpr f: {
                var tbl = Eval(f.Tbl, env);
                if (!tbl.IsTable) throw new LuaError($"line {e.Line}: attempt to index a {tbl.Type} value (field '{f.Field}')");
                return One(tbl.Table.Get(f.Field));
            }
            case IndexExpr ix: {
                var tbl = Eval(ix.Tbl, env);
                if (!tbl.IsTable) throw new LuaError($"line {e.Line}: attempt to index a {tbl.Type} value");
                return One(tbl.Table.Get(Eval(ix.Key, env)));
            }
            case CallExpr ce: {
                var fn   = Eval(ce.Fn, env);
                var args = EvalArgs(ce.Args, env);
                return CallFunction(fn, args, env);
            }
            case MethodCallExpr mc: {
                var obj  = Eval(mc.Obj, env);
                if (!obj.IsTable) throw new LuaError($"line {e.Line}: attempt to index a {obj.Type} value");
                var fn   = obj.Table.Get(mc.Method);
                var args = EvalArgs(mc.Args, env);
                var full = new LuaValue[args.Length + 1];
                full[0] = obj;
                args.CopyTo(full, 1);
                return CallFunction(fn, full, env);
            }
            case UnOpExpr u:   return One(EvalUnOp(u.Op, Eval(u.E, env), u.Line));
            case BinOpExpr b:  return One(EvalBinOp(b, env));
            default:           throw new LuaError($"unknown expression type {e.GetType().Name}");
        }
    }

    private LuaValue[] EvalArgs(List<Expr> args, LuaEnv env) {
        if (args.Count == 0) return new LuaValue[0];
        var result = new List<LuaValue>();
        for (int i = 0; i < args.Count - 1; i++) result.Add(Eval(args[i], env));
        var last = EvalMulti(args[args.Count - 1], env);
        result.AddRange(last);
        return result.ToArray();
    }

    private LuaValue[] EvalList(List<Expr> exprs, int needed, LuaEnv env) {
        if (exprs.Count == 0) return new LuaValue[0];
        var result = new List<LuaValue>();
        for (int i = 0; i < exprs.Count - 1; i++) result.Add(Eval(exprs[i], env));
        var last = EvalMulti(exprs[exprs.Count - 1], env);
        result.AddRange(last);
        return result.ToArray();
    }

    private LuaValue[] EvalAll(List<Expr> exprs, LuaEnv env) => EvalArgs(exprs, env);

    private LuaValue[] CallFunction(LuaValue fn, LuaValue[] args, LuaEnv _) {
        if (fn.IsFunction) {
            return fn.Func(args);
        }
        if (fn.IsTable) throw new LuaError("attempt to call a table value");
        throw new LuaError($"attempt to call a {fn.Type} value");
    }

    private LuaValue MakeClosure(FuncDef def, LuaEnv closureEnv) {
        return new LuaValue((LuaValue[] args) => {
            var inner = new LuaEnv(closureEnv);
            for (int i = 0; i < def.Params.Count; i++)
                inner.SetLocal(def.Params[i], i < args.Length ? args[i] : LuaValue.Nil);
            var oldVA = _varArgs;
            if (def.VarArg) {
                int extra = Math.Max(0, args.Length - def.Params.Count);
                _varArgs = new LuaValue[extra];
                for (int i = 0; i < extra; i++) _varArgs[i] = args[def.Params.Count + i];
            }
            try {
                ExecBlock(def.Body, inner);
                return new LuaValue[0];
            } catch (ReturnSignal r) {
                return r.Vals;
            } finally {
                _varArgs = oldVA;
            }
        });
    }

    private LuaValue EvalUnOp(string op, LuaValue v, int line) {
        switch (op) {
            case "-":
                if (!v.IsNumber) throw new LuaError($"line {line}: attempt to perform arithmetic on a {v.Type} value");
                return LuaValue.Of(-v.NumVal);
            case "not":
                return LuaValue.Of(!v.Truthy);
            case "#":
                if (v.IsString) return LuaValue.Of((double)v.StrVal.Length);
                if (v.IsTable)  return LuaValue.Of((double)v.Table.Length());
                throw new LuaError($"line {line}: attempt to get length of a {v.Type} value");
            default:
                throw new LuaError($"unknown unop {op}");
        }
    }

    private LuaValue EvalBinOp(BinOpExpr b, LuaEnv env) { 
        if (b.Op == "and") { var l=Eval(b.L,env); return !l.Truthy ? l : Eval(b.R,env); }
        if (b.Op == "or")  { var l=Eval(b.L,env); return  l.Truthy ? l : Eval(b.R,env); }

        var lv = Eval(b.L, env);
        var rv = Eval(b.R, env);

        switch (b.Op) {
            case "+": return Arith(lv, rv, "+", b.Line);
            case "-": return Arith(lv, rv, "-", b.Line);
            case "*": return Arith(lv, rv, "*", b.Line);
            case "/": return Arith(lv, rv, "/", b.Line);
            case "%": return Arith(lv, rv, "%", b.Line);
            case "^": return LuaValue.Of(Math.Pow(NumCoerce(lv,b.Line), NumCoerce(rv,b.Line)));
            case "..": {
                if ((!lv.IsString && !lv.IsNumber) || (!rv.IsString && !rv.IsNumber))
                    throw new LuaError($"line {b.Line}: attempt to concatenate a {(lv.IsString||lv.IsNumber?rv.Type:lv.Type)} value");
                return LuaValue.Of(lv.ToLuaString() + rv.ToLuaString());
            }
            case "==": return LuaValue.Of(LuaEquals(lv, rv));
            case "~=": return LuaValue.Of(!LuaEquals(lv, rv));
            case "<":  return LuaValue.Of(LuaLt(lv, rv, b.Line));
            case ">":  return LuaValue.Of(LuaLt(rv, lv, b.Line));
            case "<=": return LuaValue.Of(!LuaLt(rv, lv, b.Line));
            case ">=": return LuaValue.Of(!LuaLt(lv, rv, b.Line));
            default:   throw new LuaError($"unknown binop {b.Op}");
        }
    }

    private LuaValue Arith(LuaValue l, LuaValue r, string op, int line) {
        double ln = NumCoerce(l, line), rn = NumCoerce(r, line);
        switch (op) {
            case "+": return LuaValue.Of(ln + rn);
            case "-": return LuaValue.Of(ln - rn);
            case "*": return LuaValue.Of(ln * rn);
            case "/": return LuaValue.Of(ln / rn);
            case "%": { double m = ln % rn; return LuaValue.Of(m < 0 ? m + rn : m); }
            default:  throw new LuaError($"unknown op {op}");
        }
    }

    private double NumCoerce(LuaValue v, int line) {
        if (v.IsNumber) return v.NumVal;
        if (v.IsString && double.TryParse(v.StrVal,
            System.Globalization.NumberStyles.Float,
            System.Globalization.CultureInfo.InvariantCulture, out double n)) return n;
        throw new LuaError($"line {line}: attempt to perform arithmetic on a {v.Type} value");
    }

    private bool LuaEquals(LuaValue l, LuaValue r) {
        if (l.Type != r.Type) {
            // number/string cross compare not equal in Lua
            return false;
        }
        switch (l.Type) {
            case LuaValue.Kind.Nil:      return true;
            case LuaValue.Kind.Bool:     return l.BoolVal == r.BoolVal;
            case LuaValue.Kind.Number:   return l.NumVal  == r.NumVal;
            case LuaValue.Kind.String:   return l.StrVal  == r.StrVal;
            case LuaValue.Kind.Table:    return ReferenceEquals(l.Table, r.Table);
            case LuaValue.Kind.Function: return ReferenceEquals(l.Func,  r.Func);
            default: return false;
        }
    }

    private bool LuaLt(LuaValue l, LuaValue r, int line) {
        if (l.IsNumber && r.IsNumber) return l.NumVal < r.NumVal;
        if (l.IsString && r.IsString) return string.Compare(l.StrVal, r.StrVal, StringComparison.Ordinal) < 0;
        throw new LuaError($"line {line}: attempt to compare {l.Type} with {r.Type}");
    }

    // ── Helpers ──

    private static LuaValue[] One(LuaValue v) => new[] { v };

    private static string LuaFormat(LuaValue[] args) {
        if (args.Length == 0) return "";
        var fmt = Arg(args, 0).StrVal;
        var sb  = new StringBuilder();
        int ai  = 1;
        int i   = 0;
        while (i < fmt.Length) {
            if (fmt[i] == '%') {
                i++;
                if (i >= fmt.Length) break;
                if (fmt[i] == '%') { sb.Append('%'); i++; continue; }
                // parse flags/width/precision
                var spec = new StringBuilder("%");
                while (i < fmt.Length && "+-0 #".IndexOf(fmt[i]) >= 0) spec.Append(fmt[i++]);
                while (i < fmt.Length && char.IsDigit(fmt[i])) spec.Append(fmt[i++]);
                if (i < fmt.Length && fmt[i] == '.') { spec.Append(fmt[i++]); while (i < fmt.Length && char.IsDigit(fmt[i])) spec.Append(fmt[i++]); }
                if (i >= fmt.Length) break;
                char conv = fmt[i++];
                var a = Arg(args, ai++);
                switch (conv) {
                    case 'd': case 'i': sb.Append(((long)a.NumVal).ToString()); break;
                    case 'f': {
                        int prec = 6;
                        var sp = spec.ToString();
                        int dot = sp.IndexOf('.');
                        if (dot >= 0 && dot < sp.Length - 1)
                            int.TryParse(sp.Substring(dot + 1), out prec);
                        sb.Append(a.NumVal.ToString("F" + prec, System.Globalization.CultureInfo.InvariantCulture));
                        break;
                    }
                    case 's': sb.Append(a.ToLuaString()); break;
                    case 'q': sb.Append('"'); sb.Append(a.ToLuaString().Replace("\\","\\\\").Replace("\"","\\\"")); sb.Append('"'); break;
                    case 'x': sb.Append(((long)a.NumVal).ToString("x")); break;
                    case 'X': sb.Append(((long)a.NumVal).ToString("X")); break;
                    default:  sb.Append(conv); break;
                }
            } else {
                sb.Append(fmt[i++]);
            }
        }
        return sb.ToString();
    }
}

}