LStrLib.cs

// Port of lstrlib.c - the library for string operations and pattern matching.
// See LICENSE_LUA.txt.

using System.Runtime.InteropServices;

namespace LinkBridge.Lua;

public static unsafe partial class LuaApi
{
    /*
    ** maximum number of captures that a pattern can do during
    ** pattern-matching.
    */
    private const int LUA_MAXCAPTURES = 32;

    private static int str_len(lua_State* L)
    {
        nuint l;
        luaL_checklstring(L, 1, &l);
        lua_pushinteger(L, (lua_Integer)l);
        return 1;
    }

    /*
    ** translate a relative initial string position.
    */
    private static nuint posrelatI(lua_Integer pos, nuint len)
    {
        if (pos > 0)
            return (nuint)pos;
        else if (pos == 0)
            return 1;
        else if (pos < -(lua_Integer)len)  // inverted comparison
            return 1;  // clip to 1
        else return len + (nuint)pos + 1;
    }

    /*
    ** Gets an optional ending string position from argument 'arg'.
    */
    private static nuint getendpos(lua_State* L, int arg, lua_Integer def, nuint len)
    {
        lua_Integer pos = luaL_optinteger(L, arg, def);
        if (pos > (lua_Integer)len)
            return len;
        else if (pos >= 0)
            return (nuint)pos;
        else if (pos < -(lua_Integer)len)
            return 0;
        else return len + (nuint)pos + 1;
    }

    private static int str_sub(lua_State* L)
    {
        nuint l;
        byte* s = luaL_checklstring(L, 1, &l);
        nuint start = posrelatI(luaL_checkinteger(L, 2), l);
        nuint end = getendpos(L, 3, -1, l);
        if (start <= end)
            lua_pushlstring(L, s + start - 1, end - start + 1);
        else lua_pushstring(L, CSTR(""u8));
        return 1;
    }

    private static int str_reverse(lua_State* L)
    {
        nuint l, i;
        luaL_Buffer b;
        byte* s = luaL_checklstring(L, 1, &l);
        byte* p = luaL_buffinitsize(L, &b, l);
        for (i = 0; i < l; i++)
            p[i] = s[l - i - 1];
        luaL_pushresultsize(&b, l);
        return 1;
    }

    private static int str_lower(lua_State* L)
    {
        nuint l, i;
        luaL_Buffer b;
        byte* s = luaL_checklstring(L, 1, &l);
        byte* p = luaL_buffinitsize(L, &b, l);
        for (i = 0; i < l; i++)
            p[i] = (byte)tolower(s[i]);
        luaL_pushresultsize(&b, l);
        return 1;
    }

    private static int str_upper(lua_State* L)
    {
        nuint l, i;
        luaL_Buffer b;
        byte* s = luaL_checklstring(L, 1, &l);
        byte* p = luaL_buffinitsize(L, &b, l);
        for (i = 0; i < l; i++)
            p[i] = (byte)toupper(s[i]);
        luaL_pushresultsize(&b, l);
        return 1;
    }

    private static int str_rep(lua_State* L)
    {
        nuint len, lsep;
        byte* s = luaL_checklstring(L, 1, &len);
        lua_Integer n = luaL_checkinteger(L, 2);
        byte* sep = luaL_optlstring(L, 3, CSTR(""u8), &lsep);
        if (n <= 0 || (len | lsep) == 0)
            lua_pushstring(L, CSTR(""u8));  // no repetitions or both strings empty
        else if (l_unlikely(len > MAX_SIZE - lsep ||
                            cast_st2S(len + lsep) > cast_st2S(MAX_SIZE) / n))
            return luaL_error(L, CSTR("resulting string too large"u8));
        else
        {
            nuint totallen = (nuint)n * (len + lsep) - lsep;
            luaL_Buffer b;
            byte* p = luaL_buffinitsize(L, &b, totallen);
            while (n-- > 1)
            {  // first n-1 copies (followed by separator)
                memcpy(p, s, len); p += len;
                if (lsep > 0)
                {  // empty 'memcpy' is not that cheap
                    memcpy(p, sep, lsep); p += lsep;
                }
            }
            memcpy(p, s, len);  // last copy without separator
            luaL_pushresultsize(&b, totallen);
        }
        return 1;
    }

    private static int str_byte(lua_State* L)
    {
        nuint l;
        byte* s = luaL_checklstring(L, 1, &l);
        lua_Integer pi = luaL_optinteger(L, 2, 1);
        nuint posi = posrelatI(pi, l);
        nuint pose = getendpos(L, 3, pi, l);
        int n, i;
        if (posi > pose) return 0;  // empty interval; return no values
        if (l_unlikely(pose - posi >= (nuint)int.MaxValue))  // arithmetic overflow?
            return luaL_error(L, CSTR("string slice too long"u8));
        n = (int)(pose - posi) + 1;
        luaL_checkstack(L, n, CSTR("string slice too long"u8));
        for (i = 0; i < n; i++)
            lua_pushinteger(L, s[posi + (uint)i - 1]);
        return n;
    }

    private static int str_char(lua_State* L)
    {
        int n = lua_gettop(L);  // number of arguments
        luaL_Buffer b;
        byte* p = luaL_buffinitsize(L, &b, (uint)n);
        for (int i = 1; i <= n; i++)
        {
            lua_Unsigned c = (lua_Unsigned)luaL_checkinteger(L, i);
            luaL_argcheck(L, c <= 255, i, CSTR("value out of range"u8));
            p[i - 1] = (byte)c;
        }
        luaL_pushresultsize(&b, (uint)n);
        return 1;
    }

    /*
    ** Buffer to store the result of 'string.dump'.
    */
    [StructLayout(LayoutKind.Sequential)]
    private struct str_Writer
    {
        public int init;  // true iff buffer has been initialized
        public luaL_Buffer B;
    }

    private static int writer(lua_State* L, void* b, nuint size, void* ud)
    {
        str_Writer* state = (str_Writer*)ud;
        if (state->init == 0)
        {
            state->init = 1;
            luaL_buffinit(L, &state->B);
        }
        if (b == null)
        {  // finishing dump?
            luaL_pushresult(&state->B);  // push result
            lua_replace(L, 1);  // move it to reserved slot
        }
        else
            luaL_addlstring(&state->B, (byte*)b, size);
        return 0;
    }

    private static int str_dump(lua_State* L)
    {
        str_Writer state;
        int strip = lua_toboolean(L, 2);
        luaL_argcheck(L, lua_type(L, 1) == LUA_TFUNCTION && lua_iscfunction(L, 1) == 0,
                      1, CSTR("Lua function expected"u8));
        // ensure function is on the top of the stack and vacate slot 1
        lua_pushvalue(L, 1);
        state.init = 0;
        lua_dump(L, &writer, &state, strip);
        lua_settop(L, 1);  // leave final result on top
        return 1;
    }

    /*
    ** {======================================================
    ** METAMETHODS
    ** =======================================================
    */

    private static int tonum(lua_State* L, int arg)
    {
        if (lua_type(L, arg) == LUA_TNUMBER)
        {  // already a number?
            lua_pushvalue(L, arg);
            return 1;
        }
        else
        {  // check whether it is a numerical string
            nuint len;
            byte* s = lua_tolstring(L, arg, &len);
            return s != null && lua_stringtonumber(L, s) == len + 1 ? 1 : 0;
        }
    }

    private static void trymt(lua_State* L, byte* mtkey, byte* opname)
    {
        lua_settop(L, 2);  // back to the original arguments
        if (l_unlikely(lua_type(L, 2) == LUA_TSTRING || luaL_getmetafield(L, 2, mtkey) == 0))
            luaL_error(L, CSTR("attempt to %s a '%s' with a '%s'"u8), opname,
                       luaL_typename(L, -2), luaL_typename(L, -1));
        lua_insert(L, -3);  // put metamethod before arguments
        lua_call(L, 2, 1);  // call metamethod
    }

    private static int arith(lua_State* L, int op, byte* mtname)
    {
        if (tonum(L, 1) != 0 && tonum(L, 2) != 0)
            lua_arith(L, op);  // result will be on the top
        else
            trymt(L, mtname, mtname + 2);
        return 1;
    }

    private static int arith_add(lua_State* L) => arith(L, LUA_OPADD, CSTR("__add"u8));
    private static int arith_sub(lua_State* L) => arith(L, LUA_OPSUB, CSTR("__sub"u8));
    private static int arith_mul(lua_State* L) => arith(L, LUA_OPMUL, CSTR("__mul"u8));
    private static int arith_mod(lua_State* L) => arith(L, LUA_OPMOD, CSTR("__mod"u8));
    private static int arith_pow(lua_State* L) => arith(L, LUA_OPPOW, CSTR("__pow"u8));
    private static int arith_div(lua_State* L) => arith(L, LUA_OPDIV, CSTR("__div"u8));
    private static int arith_idiv(lua_State* L) => arith(L, LUA_OPIDIV, CSTR("__idiv"u8));
    private static int arith_unm(lua_State* L) => arith(L, LUA_OPUNM, CSTR("__unm"u8));

    private static readonly IntPtr _stringmetamethods = create_stringmetamethods();

    private static IntPtr create_stringmetamethods()
    {
        luaL_Reg* r = newregs(9);
        int i = 0;
        reg(r, ref i, "__add"u8, &arith_add);
        reg(r, ref i, "__sub"u8, &arith_sub);
        reg(r, ref i, "__mul"u8, &arith_mul);
        reg(r, ref i, "__mod"u8, &arith_mod);
        reg(r, ref i, "__pow"u8, &arith_pow);
        reg(r, ref i, "__div"u8, &arith_div);
        reg(r, ref i, "__idiv"u8, &arith_idiv);
        reg(r, ref i, "__unm"u8, &arith_unm);
        reg(r, ref i, "__index"u8, null);  // placeholder
        return (IntPtr)r;
    }

    /*
    ** {======================================================
    ** PATTERN MATCHING
    ** =======================================================
    */

    private const int CAP_UNFINISHED = -1;
    private const int CAP_POSITION = -2;

    [StructLayout(LayoutKind.Sequential)]
    private struct Capture
    {
        public byte* init;
        public nint len;  // length or special value (CAP_*)
    }

    [StructLayout(LayoutKind.Sequential)]
    private struct MatchState
    {
        public byte* src_init;  // init of source string
        public byte* src_end;   // end ('\0') of source string
        public byte* p_end;     // end ('\0') of pattern
        public lua_State* L;
        public int matchdepth;  // control for recursive depth
        public int level;       // total number of captures
        public Capture capture0;  // 'capture[LUA_MAXCAPTURES]' (trailing array)
        private fixed byte _rest[(LUA_MAXCAPTURES - 1) * 16];
    }

    private static Capture* captures(MatchState* ms) => &ms->capture0;

    /* maximum recursion depth for 'match' */
    private const int MAXCCALLS = 200;

    private const int L_ESC = '%';

    private static ReadOnlySpan<byte> SPECIALS => "^$*+?.([%-"u8;

    private static int check_capture(MatchState* ms, int l)
    {
        l -= '1';
        if (l_unlikely(l < 0 || l >= ms->level || captures(ms)[l].len == CAP_UNFINISHED))
            return luaL_error(ms->L, CSTR("invalid capture index %%%d"u8), l + 1);
        return l;
    }

    private static int capture_to_close(MatchState* ms)
    {
        int level = ms->level;
        for (level--; level >= 0; level--)
            if (captures(ms)[level].len == CAP_UNFINISHED) return level;
        return luaL_error(ms->L, CSTR("invalid pattern capture"u8));
    }

    private static byte* classend(MatchState* ms, byte* p)
    {
        switch (*p++)
        {
            case L_ESC:
            {
                if (l_unlikely(p == ms->p_end))
                    luaL_error(ms->L, CSTR("malformed pattern (ends with '%%')"u8));
                return p + 1;
            }
            case (byte)'[':
            {
                if (*p == '^') p++;
                do
                {  // look for a ']'
                    if (l_unlikely(p == ms->p_end))
                        luaL_error(ms->L, CSTR("malformed pattern (missing ']')"u8));
                    if (*p++ == L_ESC && p < ms->p_end)
                        p++;  // skip escapes (e.g. '%]')
                } while (*p != ']');
                return p + 1;
            }
            default:
            {
                return p;
            }
        }
    }

    private static bool isalpha_(int c) => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    private static bool iscntrl_(int c) => c < 0x20 || c == 0x7f;
    private static bool isgraph_(int c) => c > 0x20 && c < 0x7f;
    private static bool islower_(int c) => c >= 'a' && c <= 'z';
    private static bool isupper_(int c) => c >= 'A' && c <= 'Z';
    private static bool isspace_(int c) => c == ' ' || (c >= 0x09 && c <= 0x0d);
    private static bool isxdigit_(int c)
        => isdigit_(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
    private static bool ispunct_(int c) => isgraph_(c) && !isalnum_(c);

    private static int match_class(int c, int cl)
    {
        bool res;
        switch (tolower(cl))
        {
            case 'a': res = isalpha_(c); break;
            case 'c': res = iscntrl_(c); break;
            case 'd': res = isdigit_(c); break;
            case 'g': res = isgraph_(c); break;
            case 'l': res = islower_(c); break;
            case 'p': res = ispunct_(c); break;
            case 's': res = isspace_(c); break;
            case 'u': res = isupper_(c); break;
            case 'w': res = isalnum_(c); break;
            case 'x': res = isxdigit_(c); break;
            case 'z': res = c == 0; break;  // deprecated option
            default: return cl == c ? 1 : 0;
        }
        return (islower_(cl) ? res : !res) ? 1 : 0;
    }

    private static int matchbracketclass(int c, byte* p, byte* ec)
    {
        int sig = 1;
        if (*(p + 1) == '^')
        {
            sig = 0;
            p++;  // skip the '^'
        }
        while (++p < ec)
        {
            if (*p == L_ESC)
            {
                p++;
                if (match_class(c, *p) != 0)
                    return sig;
            }
            else if (*(p + 1) == '-' && p + 2 < ec)
            {
                p += 2;
                if (*(p - 2) <= c && c <= *p)
                    return sig;
            }
            else if (*p == c) return sig;
        }
        return sig != 0 ? 0 : 1;
    }

    private static int singlematch(MatchState* ms, byte* s, byte* p, byte* ep)
    {
        if (s >= ms->src_end)
            return 0;
        else
        {
            int c = *s;
            switch (*p)
            {
                case (byte)'.': return 1;  // matches any char
                case L_ESC: return match_class(c, *(p + 1));
                case (byte)'[': return matchbracketclass(c, p, ep - 1);
                default: return *p == c ? 1 : 0;
            }
        }
    }

    private static byte* matchbalance(MatchState* ms, byte* s, byte* p)
    {
        if (l_unlikely(p >= ms->p_end - 1))
            luaL_error(ms->L, CSTR("malformed pattern (missing arguments to '%%b')"u8));
        if (*s != *p) return null;
        else
        {
            int b = *p;
            int e = *(p + 1);
            int cont = 1;
            while (++s < ms->src_end)
            {
                if (*s == e)
                {
                    if (--cont == 0) return s + 1;
                }
                else if (*s == b) cont++;
            }
        }
        return null;  // string ends out of balance
    }

    private static byte* max_expand(MatchState* ms, byte* s, byte* p, byte* ep)
    {
        nint i = 0;  // counts maximum expand for item
        while (singlematch(ms, s + i, p, ep) != 0)
            i++;
        // keeps trying to match with the maximum repetitions
        while (i >= 0)
        {
            byte* res = match(ms, s + i, ep + 1);
            if (res != null) return res;
            i--;  // else didn't match; reduce 1 repetition to try again
        }
        return null;
    }

    private static byte* min_expand(MatchState* ms, byte* s, byte* p, byte* ep)
    {
        for (; ; )
        {
            byte* res = match(ms, s, ep + 1);
            if (res != null)
                return res;
            else if (singlematch(ms, s, p, ep) != 0)
                s++;  // try with one more repetition
            else return null;
        }
    }

    private static byte* start_capture(MatchState* ms, byte* s, byte* p, int what)
    {
        byte* res;
        int level = ms->level;
        if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, CSTR("too many captures"u8));
        captures(ms)[level].init = s;
        captures(ms)[level].len = what;
        ms->level = level + 1;
        if ((res = match(ms, s, p)) == null)  // match failed?
            ms->level--;  // undo capture
        return res;
    }

    private static byte* end_capture(MatchState* ms, byte* s, byte* p)
    {
        int l = capture_to_close(ms);
        byte* res;
        captures(ms)[l].len = (nint)(s - captures(ms)[l].init);  // close capture
        if ((res = match(ms, s, p)) == null)  // match failed?
            captures(ms)[l].len = CAP_UNFINISHED;  // undo capture
        return res;
    }

    private static byte* match_capture(MatchState* ms, byte* s, int l)
    {
        nuint len;
        l = check_capture(ms, l);
        len = (nuint)captures(ms)[l].len;
        if ((nuint)(ms->src_end - s) >= len &&
            memcmp(captures(ms)[l].init, s, len) == 0)
            return s + len;
        else return null;
    }

    private static byte* match(MatchState* ms, byte* s, byte* p)
    {
        if (l_unlikely(ms->matchdepth-- == 0))
            luaL_error(ms->L, CSTR("pattern too complex"u8));
    init:  // using goto to optimize tail recursion
        if (p != ms->p_end)
        {  // end of pattern?
            switch (*p)
            {
                case (byte)'(':
                {  // start capture
                    if (*(p + 1) == ')')  // position capture?
                        s = start_capture(ms, s, p + 2, CAP_POSITION);
                    else
                        s = start_capture(ms, s, p + 1, CAP_UNFINISHED);
                    break;
                }
                case (byte)')':
                {  // end capture
                    s = end_capture(ms, s, p + 1);
                    break;
                }
                case (byte)'$':
                {
                    if (p + 1 != ms->p_end)  // is the '$' the last char in pattern?
                        goto dflt;  // no; go to default
                    s = s == ms->src_end ? s : null;  // check end of string
                    break;
                }
                case L_ESC:
                {  // escaped sequences not in the format class[*+?-]?
                    switch (*(p + 1))
                    {
                        case (byte)'b':
                        {  // balanced string?
                            s = matchbalance(ms, s, p + 2);
                            if (s != null)
                            {
                                p += 4; goto init;
                            }  // else fail (s == NULL)
                            break;
                        }
                        case (byte)'f':
                        {  // frontier?
                            byte* ep;
                            byte previous;
                            p += 2;
                            if (l_unlikely(*p != '['))
                                luaL_error(ms->L,
                                    CSTR("missing '[' after '%%f' in pattern"u8));
                            ep = classend(ms, p);  // points to what is next
                            previous = s == ms->src_init ? (byte)0 : *(s - 1);
                            if (matchbracketclass(previous, p, ep - 1) == 0 &&
                                matchbracketclass(*s, p, ep - 1) != 0)
                            {
                                p = ep; goto init;
                            }
                            s = null;  // match failed
                            break;
                        }
                        case (byte)'0':
                        case (byte)'1':
                        case (byte)'2':
                        case (byte)'3':
                        case (byte)'4':
                        case (byte)'5':
                        case (byte)'6':
                        case (byte)'7':
                        case (byte)'8':
                        case (byte)'9':
                        {  // capture results (%0-%9)?
                            s = match_capture(ms, s, *(p + 1));
                            if (s != null)
                            {
                                p += 2; goto init;
                            }
                            break;
                        }
                        default: goto dflt;
                    }
                    break;
                }
                default:
                dflt:
                {  // pattern class plus optional suffix
                    byte* ep = classend(ms, p);  // points to optional suffix
                    // does not match at least once?
                    if (singlematch(ms, s, p, ep) == 0)
                    {
                        if (*ep == '*' || *ep == '?' || *ep == '-')
                        {  // accept empty?
                            p = ep + 1; goto init;
                        }
                        else  // '+' or no suffix
                            s = null;  // fail
                    }
                    else
                    {  // matched once
                        switch (*ep)
                        {  // handle optional suffix
                            case (byte)'?':
                            {  // optional
                                byte* res;
                                if ((res = match(ms, s + 1, ep + 1)) != null)
                                    s = res;
                                else
                                {
                                    p = ep + 1; goto init;
                                }
                                break;
                            }
                            case (byte)'+':  // 1 or more repetitions
                                s++;  // 1 match already done
                                goto case (byte)'*';  // FALLTHROUGH
                            case (byte)'*':  // 0 or more repetitions
                                s = max_expand(ms, s, p, ep);
                                break;
                            case (byte)'-':  // 0 or more repetitions (minimum)
                                s = min_expand(ms, s, p, ep);
                                break;
                            default:  // no suffix
                                s++; p = ep; goto init;
                        }
                    }
                    break;
                }
            }
        }
        ms->matchdepth++;
        return s;
    }

    private static byte* lmemfind(byte* s1, nuint l1, byte* s2, nuint l2)
    {
        if (l2 == 0) return s1;  // empty strings are everywhere
        else if (l2 > l1) return null;  // avoids a negative 'l1'
        else
        {
            byte* init;  // to search for a '*s2' inside 's1'
            l2--;  // 1st char will be checked by 'memchr'
            l1 = l1 - l2;  // 's2' cannot be found after that
            while (l1 > 0 && (init = memchr(s1, *s2, l1)) != null)
            {
                init++;  // 1st char is already checked
                if (memcmp(init, s2 + 1, l2) == 0)
                    return init - 1;
                else
                {  // correct 'l1' and 's1' to try again
                    l1 -= ct_diff2sz((nint)(init - s1));
                    s1 = init;
                }
            }
            return null;  // not found
        }
    }

    /*
    ** get information about the i-th capture.
    */
    private static nint get_onecapture(MatchState* ms, int i, byte* s, byte* e, byte** cap)
    {
        if (i >= ms->level)
        {
            if (l_unlikely(i != 0))
                luaL_error(ms->L, CSTR("invalid capture index %%%d"u8), i + 1);
            *cap = s;
            return (nint)(e - s);
        }
        else
        {
            nint capl = captures(ms)[i].len;
            *cap = captures(ms)[i].init;
            if (l_unlikely(capl == CAP_UNFINISHED))
                luaL_error(ms->L, CSTR("unfinished capture"u8));
            else if (capl == CAP_POSITION)
                lua_pushinteger(ms->L,
                    ct_diff2S((nint)(captures(ms)[i].init - ms->src_init)) + 1);
            return capl;
        }
    }

    /*
    ** Push the i-th capture on the stack.
    */
    private static void push_onecapture(MatchState* ms, int i, byte* s, byte* e)
    {
        byte* cap;
        nint l = get_onecapture(ms, i, s, e, &cap);
        if (l != CAP_POSITION)
            lua_pushlstring(ms->L, cap, (nuint)l);
        // else position was already pushed
    }

    private static int push_captures(MatchState* ms, byte* s, byte* e)
    {
        int nlevels = ms->level == 0 && s != null ? 1 : ms->level;
        luaL_checkstack(ms->L, nlevels, CSTR("too many captures"u8));
        for (int i = 0; i < nlevels; i++)
            push_onecapture(ms, i, s, e);
        return nlevels;  // number of strings pushed
    }

    /* check whether pattern has no special characters */
    private static int nospecials(byte* p, nuint l)
    {
        nuint upto = 0;
        do
        {
            if (strpbrk(p + upto, CSTR(SPECIALS)) != null)
                return 0;  // pattern has a special character
            upto += strlen(p + upto) + 1;  // may have more after \0
        } while (upto <= l);
        return 1;  // no special chars found
    }

    /*
    ** Prepare state for matches.
    */
    private static void prepstate(MatchState* ms, lua_State* L,
                                  byte* s, nuint ls, byte* p, nuint lp)
    {
        ms->L = L;
        ms->src_init = s;
        ms->src_end = s + ls;
        ms->p_end = p + lp;
    }

    private static void reprepstate(MatchState* ms)
    {
        ms->matchdepth = MAXCCALLS;
        ms->level = 0;
    }

    private static int str_find_aux(lua_State* L, int find)
    {
        nuint ls, lp;
        byte* s = luaL_checklstring(L, 1, &ls);
        byte* p = luaL_checklstring(L, 2, &lp);
        nuint init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
        if (init > ls)
        {  // start after string's end?
            luaL_pushfail(L);  // cannot find anything
            return 1;
        }
        // explicit request or no special characters?
        if (find != 0 && (lua_toboolean(L, 4) != 0 || nospecials(p, lp) != 0))
        {
            // do a plain search
            byte* s2 = lmemfind(s + init, ls - init, p, lp);
            if (s2 != null)
            {
                lua_pushinteger(L, ct_diff2S((nint)(s2 - s)) + 1);
                lua_pushinteger(L, cast_st2S(ct_diff2sz((nint)(s2 - s)) + lp));
                return 2;
            }
        }
        else
        {
            MatchState ms;
            byte* s1 = s + init;
            int anchor = *p == '^' ? 1 : 0;
            if (anchor != 0)
            {
                p++; lp--;  // skip anchor character
            }
            prepstate(&ms, L, s, ls, p, lp);
            do
            {
                byte* res;
                reprepstate(&ms);
                if ((res = match(&ms, s1, p)) != null)
                {
                    if (find != 0)
                    {
                        lua_pushinteger(L, ct_diff2S((nint)(s1 - s)) + 1);  // start
                        lua_pushinteger(L, ct_diff2S((nint)(res - s)));  // end
                        return push_captures(&ms, null, null) + 2;
                    }
                    else
                        return push_captures(&ms, s1, res);
                }
            } while (s1++ < ms.src_end && anchor == 0);
        }
        luaL_pushfail(L);  // not found
        return 1;
    }

    private static int str_find(lua_State* L) => str_find_aux(L, 1);

    private static int str_match(lua_State* L) => str_find_aux(L, 0);

    /* state for 'gmatch' */
    [StructLayout(LayoutKind.Sequential)]
    private struct GMatchState
    {
        public byte* src;        // current position
        public byte* p;          // pattern
        public byte* lastmatch;  // end of last match
        public MatchState ms;    // match state
    }

    private static int gmatch_aux(lua_State* L)
    {
        GMatchState* gm = (GMatchState*)lua_touserdata(L, lua_upvalueindex(3));
        byte* src;
        gm->ms.L = L;
        for (src = gm->src; src <= gm->ms.src_end; src++)
        {
            byte* e;
            reprepstate(&gm->ms);
            if ((e = match(&gm->ms, src, gm->p)) != null && e != gm->lastmatch)
            {
                gm->src = gm->lastmatch = e;
                return push_captures(&gm->ms, src, e);
            }
        }
        return 0;  // not found
    }

    private static int gmatch(lua_State* L)
    {
        nuint ls, lp;
        byte* s = luaL_checklstring(L, 1, &ls);
        byte* p = luaL_checklstring(L, 2, &lp);
        nuint init = posrelatI(luaL_optinteger(L, 3, 1), ls) - 1;
        GMatchState* gm;
        lua_settop(L, 2);  // keep strings on closure to avoid being collected
        gm = (GMatchState*)lua_newuserdatauv(L, (nuint)sizeof(GMatchState), 0);
        if (init > ls)  // start after string's end?
            init = ls + 1;  // avoid overflows in 's + init'
        prepstate(&gm->ms, L, s, ls, p, lp);
        gm->src = s + init; gm->p = p; gm->lastmatch = null;
        lua_pushcclosure(L, &gmatch_aux, 3);
        return 1;
    }

    private static void add_s(MatchState* ms, luaL_Buffer* b, byte* s, byte* e)
    {
        nuint l;
        lua_State* L = ms->L;
        byte* news = lua_tolstring(L, 3, &l);
        byte* p;
        while ((p = memchr(news, L_ESC, l)) != null)
        {
            luaL_addlstring(b, news, ct_diff2sz((nint)(p - news)));
            p++;  // skip ESC
            if (*p == L_ESC)  // '%%'
                luaL_addchar(b, *p);
            else if (*p == '0')  // '%0'
                luaL_addlstring(b, s, ct_diff2sz((nint)(e - s)));
            else if (isdigit_(*p))
            {  // '%n'
                byte* cap;
                nint resl = get_onecapture(ms, *p - '1', s, e, &cap);
                if (resl == CAP_POSITION)
                    luaL_addvalue(b);  // add position to accumulated result
                else
                    luaL_addlstring(b, cap, (nuint)resl);
            }
            else
                luaL_error(L, CSTR("invalid use of '%c' in replacement string"u8), L_ESC);
            l -= ct_diff2sz((nint)(p + 1 - news));
            news = p + 1;
        }
        luaL_addlstring(b, news, l);
    }

    /*
    ** Add the replacement value to the string buffer 'b'.
    */
    private static int add_value(MatchState* ms, luaL_Buffer* b, byte* s, byte* e, int tr)
    {
        lua_State* L = ms->L;
        switch (tr)
        {
            case LUA_TFUNCTION:
            {  // call the function
                int n;
                lua_pushvalue(L, 3);  // push the function
                n = push_captures(ms, s, e);  // all captures as arguments
                lua_call(L, n, 1);  // call it
                break;
            }
            case LUA_TTABLE:
            {  // index the table
                push_onecapture(ms, 0, s, e);  // first capture is the index
                lua_gettable(L, 3);
                break;
            }
            default:
            {  // LUA_TNUMBER or LUA_TSTRING
                add_s(ms, b, s, e);  // add value to the buffer
                return 1;  // something changed
            }
        }
        if (lua_toboolean(L, -1) == 0)
        {  // nil or false?
            lua_pop(L, 1);  // remove value
            luaL_addlstring(b, s, ct_diff2sz((nint)(e - s)));  // keep original text
            return 0;  // no changes
        }
        else if (l_unlikely(lua_isstring(L, -1) == 0))
            return luaL_error(L, CSTR("invalid replacement value (a %s)"u8),
                              luaL_typename(L, -1));
        else
        {
            luaL_addvalue(b);  // add result to accumulator
            return 1;  // something changed
        }
    }

    private static int str_gsub(lua_State* L)
    {
        nuint srcl, lp;
        byte* src = luaL_checklstring(L, 1, &srcl);  // subject
        byte* p = luaL_checklstring(L, 2, &lp);  // pattern
        byte* lastmatch = null;  // end of last match
        int tr = lua_type(L, 3);  // replacement type
        lua_Integer max_s = luaL_optinteger(L, 4, cast_st2S(srcl) + 1);  // max replacements
        int anchor = *p == '^' ? 1 : 0;
        lua_Integer n = 0;  // replacement count
        int changed = 0;  // change flag
        MatchState ms;
        luaL_Buffer b;
        luaL_argexpected(L, tr == LUA_TNUMBER || tr == LUA_TSTRING ||
                         tr == LUA_TFUNCTION || tr == LUA_TTABLE, 3,
                         CSTR("string/function/table"u8));
        luaL_buffinit(L, &b);
        if (anchor != 0)
        {
            p++; lp--;  // skip anchor character
        }
        prepstate(&ms, L, src, srcl, p, lp);
        while (n < max_s)
        {
            byte* e;
            reprepstate(&ms);  // (re)prepare state for new match
            if ((e = match(&ms, src, p)) != null && e != lastmatch)
            {  // match?
                n++;
                changed = add_value(&ms, &b, src, e, tr) != 0 || changed != 0 ? 1 : 0;
                src = lastmatch = e;
            }
            else if (src < ms.src_end)  // otherwise, skip one character
                luaL_addchar(&b, *src++);
            else break;  // end of subject
            if (anchor != 0) break;
        }
        if (changed == 0)  // no changes?
            lua_pushvalue(L, 1);  // return original string
        else
        {  // something changed
            luaL_addlstring(&b, src, ct_diff2sz((nint)(ms.src_end - src)));
            luaL_pushresult(&b);  // create and return new string
        }
        lua_pushinteger(L, n);  // number of substitutions
        return 2;
    }

    /*
    ** {======================================================
    ** STRING FORMAT
    ** =======================================================
    */

    private const int MAX_ITEMF = 110 + l_floatatt_MAX_10_EXP;

    private const int MAX_ITEM = 120;

    /* valid flags in a format specification */
    private static ReadOnlySpan<byte> L_FMTFLAGSF => "-+#0 "u8;
    private static ReadOnlySpan<byte> L_FMTFLAGSX => "-#0"u8;
    private static ReadOnlySpan<byte> L_FMTFLAGSI => "-+0 "u8;
    private static ReadOnlySpan<byte> L_FMTFLAGSU => "-0"u8;
    private static ReadOnlySpan<byte> L_FMTFLAGSC => "-"u8;

    private const int MAX_FORMAT = 32;

    private static void addquoted(luaL_Buffer* b, byte* s, nuint len)
    {
        luaL_addchar(b, '"');
        while (len-- != 0)
        {
            if (*s == '"' || *s == '\\' || *s == '\n')
            {
                luaL_addchar(b, '\\');
                luaL_addchar(b, *s);
            }
            else if (iscntrl_(*s))
            {
                byte* buff = stackalloc byte[10];
                if (!isdigit_(*(s + 1)))
                    fmt_d(buff, 10, *s);
                else
                {
                    // "%03d"
                    string t = ((int)*s).ToString("000");
                    for (int i = 0; i < t.Length; i++) buff[i] = (byte)t[i];
                    buff[t.Length] = 0;
                }
                luaL_addchar(b, '\\');
                luaL_addstring(b, buff);
            }
            else
                luaL_addchar(b, *s);
            s++;
        }
        luaL_addchar(b, '"');
    }

    /*
    ** Serialize a floating-point number so that it can be read back by Lua.
    */
    private static int quotefloat(lua_State* L, byte* buff, lua_Number n)
    {
        byte* s;  // for the fixed representations
        if (n == double.PositiveInfinity)  // inf?
            s = CSTR("1e9999"u8);
        else if (n == double.NegativeInfinity)  // -inf?
            s = CSTR("-1e9999"u8);
        else if (n != n)  // NaN?
            s = CSTR("(0/0)"u8);
        else
        {  // format number as hexadecimal
            int nb = fmt_a(buff, MAX_ITEM, n, -1, false);
            return nb;
        }
        strcpy(buff, s);
        return (int)strlen(s);
    }

    private static void addliteral(lua_State* L, luaL_Buffer* b, int arg)
    {
        switch (lua_type(L, arg))
        {
            case LUA_TSTRING:
            {
                nuint len;
                byte* s = lua_tolstring(L, arg, &len);
                addquoted(b, s, len);
                break;
            }
            case LUA_TNUMBER:
            {
                byte* buff = luaL_prepbuffsize(b, MAX_ITEM);
                int nb;
                if (lua_isinteger(L, arg) == 0)  // float?
                    nb = quotefloat(L, buff, lua_tonumber(L, arg));
                else
                {  // integers
                    lua_Integer n = lua_tointeger(L, arg);
                    if (n == LUA_MININTEGER)  // corner case?
                        nb = l_sprintf(buff, MAX_ITEM, CSTR("%#x"u8), n);  // use hex
                    else
                        nb = fmt_d(buff, MAX_ITEM, n);
                }
                luaL_addsize(b, (uint)nb);
                break;
            }
            case LUA_TNIL:
            case LUA_TBOOLEAN:
            {
                luaL_tolstring(L, arg, null);
                luaL_addvalue(b);
                break;
            }
            default:
            {
                luaL_argerror(L, arg, CSTR("value has no literal form"u8));
                break;
            }
        }
    }

    private static byte* get2digits(byte* s)
    {
        if (isdigit_(*s))
        {
            s++;
            if (isdigit_(*s)) s++;  // (2 digits at most)
        }
        return s;
    }

    /*
    ** Check whether a conversion specification is valid.
    */
    private static void checkformat(lua_State* L, byte* form, byte* flags, int precision)
    {
        byte* spec = form + 1;  // skip '%'
        spec += strspn(spec, flags);  // skip flags
        if (*spec != '0')
        {  // a width cannot start with '0'
            spec = get2digits(spec);  // skip width
            if (*spec == '.' && precision != 0)
            {
                spec++;
                spec = get2digits(spec);  // skip precision
            }
        }
        if (!isalpha_(*spec))  // did not go to the end?
            luaL_error(L, CSTR("invalid conversion specification: '%s'"u8), form);
    }

    /*
    ** Get a conversion specification and copy it to 'form'.
    */
    private static byte* getformat(lua_State* L, byte* strfrmt, byte* form)
    {
        // spans flags, width, and precision ('0' is included as a flag)
        nuint len = strspn(strfrmt, CSTR("-+#0 123456789."u8));
        len++;  // adds following character (should be the specifier)
        // still needs space for '%', '\0', plus a length modifier
        if (len >= MAX_FORMAT - 10)
            luaL_error(L, CSTR("invalid format (too long)"u8));
        *form++ = (byte)'%';
        memcpy(form, strfrmt, len);
        *(form + len) = 0;
        return strfrmt + len - 1;
    }

    private static int str_format(lua_State* L)
    {
        int top = lua_gettop(L);
        int arg = 1;
        nuint sfl;
        byte* strfrmt = luaL_checklstring(L, arg, &sfl);
        byte* strfrmt_end = strfrmt + sfl;
        byte* flags;
        luaL_Buffer b;
        luaL_buffinit(L, &b);
        while (strfrmt < strfrmt_end)
        {
            if (*strfrmt != L_ESC)
                luaL_addchar(&b, *strfrmt++);
            else if (*++strfrmt == L_ESC)
                luaL_addchar(&b, *strfrmt++);  // %%
            else
            {  // format item
                byte* form = stackalloc byte[MAX_FORMAT];  // to store the format
                uint maxitem = MAX_ITEM;  // maximum length for the result
                byte* buff = luaL_prepbuffsize(&b, maxitem);  // to put result
                int nb = 0;  // number of bytes in result
                if (++arg > top)
                    return luaL_argerror(L, arg, CSTR("no value"u8));
                strfrmt = getformat(L, strfrmt, form);
                byte conv = *strfrmt++;
                switch (conv)
                {
                    case (byte)'c':
                    {
                        checkformat(L, form, CSTR(L_FMTFLAGSC), 0);
                        nb = l_sprintf(buff, (int)maxitem, form, luaL_checkinteger(L, arg));
                        break;
                    }
                    case (byte)'d':
                    case (byte)'i':
                    case (byte)'u':
                    case (byte)'o':
                    case (byte)'x':
                    case (byte)'X':
                    {
                        flags = conv == 'd' || conv == 'i' ? CSTR(L_FMTFLAGSI)
                              : conv == 'u' ? CSTR(L_FMTFLAGSU)
                              : CSTR(L_FMTFLAGSX);
                        lua_Integer n = luaL_checkinteger(L, arg);
                        checkformat(L, form, flags, 1);
                        nb = l_sprintf(buff, (int)maxitem, form, n);
                        break;
                    }
                    case (byte)'a':
                    case (byte)'A':
                        checkformat(L, form, CSTR(L_FMTFLAGSF), 1);
                        nb = l_sprintf(buff, (int)maxitem, form, luaL_checknumber(L, arg));
                        break;
                    case (byte)'f':
                        maxitem = MAX_ITEMF;  // extra space for '%f'
                        buff = luaL_prepbuffsize(&b, maxitem);
                        goto case (byte)'g';  // FALLTHROUGH
                    case (byte)'e':
                    case (byte)'E':
                    case (byte)'g':
                    case (byte)'G':
                    {
                        lua_Number n = luaL_checknumber(L, arg);
                        checkformat(L, form, CSTR(L_FMTFLAGSF), 1);
                        nb = l_sprintf(buff, (int)maxitem, form, n);
                        break;
                    }
                    case (byte)'p':
                    {
                        void* p = lua_topointer(L, arg);
                        checkformat(L, form, CSTR(L_FMTFLAGSC), 0);
                        if (p == null)
                        {  // avoid calling 'printf' with argument NULL
                            nb = l_sprintf(buff, (int)maxitem, form, CSTR("(null)"u8));
                        }
                        else
                            nb = l_sprintf(buff, (int)maxitem, form, p);
                        break;
                    }
                    case (byte)'q':
                    {
                        if (form[2] != '\0')  // modifiers?
                            return luaL_error(L,
                                CSTR("specifier '%%q' cannot have modifiers"u8));
                        addliteral(L, &b, arg);
                        break;
                    }
                    case (byte)'s':
                    {
                        nuint l;
                        byte* s = luaL_tolstring(L, arg, &l);
                        if (form[2] == '\0')  // no modifiers?
                            luaL_addvalue(&b);  // keep entire string
                        else
                        {
                            luaL_argcheck(L, l == strlen(s), arg,
                                          CSTR("string contains zeros"u8));
                            checkformat(L, form, CSTR(L_FMTFLAGSC), 1);
                            if (strchr(form, '.') == null && l >= 100)
                            {
                                // no precision and string is too long
                                luaL_addvalue(&b);  // keep entire string
                            }
                            else
                            {  // format the string into 'buff'
                                nb = l_sprintf(buff, (int)maxitem, form, s);
                                lua_pop(L, 1);  // remove result from 'luaL_tolstring'
                            }
                        }
                        break;
                    }
                    default:
                    {  // also treat cases 'pnLlh'
                        return luaL_error(L, CSTR("invalid conversion '%s' to 'format'"u8),
                                          form);
                    }
                }
                lua_assert((uint)nb < maxitem);
                luaL_addsize(&b, (uint)nb);
            }
        }
        luaL_pushresult(&b);
        return 1;
    }

    /*
    ** {======================================================
    ** PACK/UNPACK
    ** =======================================================
    */

    /* value used for padding */
    private const byte LUAL_PACKPADBYTE = 0x00;

    /* maximum size for the binary representation of an integer */
    private const int MAXINTSIZE = 16;

    /* number of bits in a character */
    private const int NB = 8;

    /* mask for one character (NB 1's) */
    private const int MC = (1 << NB) - 1;

    /* size of a lua_Integer */
    private const int SZINT = 8;

    private static readonly int nativelittle = BitConverter.IsLittleEndian ? 1 : 0;

    /*
    ** information to pack/unpack stuff
    */
    [StructLayout(LayoutKind.Sequential)]
    private struct Header
    {
        public lua_State* L;
        public int islittle;
        public uint maxalign;
    }

    /*
    ** options for pack/unpack
    */
    private const int Kint = 0;
    private const int Kuint = 1;
    private const int Kfloat = 2;
    private const int Knumber = 3;
    private const int Kdouble = 4;
    private const int Kchar = 5;
    private const int Kstring = 6;
    private const int Kzstr = 7;
    private const int Kpadding = 8;
    private const int Kpaddalign = 9;
    private const int Knop = 10;

    private static int digit(int c) => '0' <= c && c <= '9' ? 1 : 0;

    private static nuint getnum(byte** fmt, nuint df)
    {
        if (digit(**fmt) == 0)  // no number?
            return df;  // return default value
        else
        {
            nuint a = 0;
            do
            {
                a = a * 10 + (uint)(*(*fmt)++ - '0');
            } while (digit(**fmt) != 0 && a <= (MAX_SIZE - 9) / 10);
            return a;
        }
    }

    private static uint getnumlimit(Header* h, byte** fmt, nuint df)
    {
        nuint sz = getnum(fmt, df);
        if (l_unlikely(sz - 1u >= MAXINTSIZE))
            return (uint)luaL_error(h->L,
                CSTR("integral size (%d) out of limits [1,%d]"u8), (int)sz, MAXINTSIZE);
        return (uint)sz;
    }

    private static void initheader(lua_State* L, Header* h)
    {
        h->L = L;
        h->islittle = nativelittle;
        h->maxalign = 1;
    }

    /*
    ** Read and classify next option. 'size' is filled with option's size.
    */
    private static int getoption(Header* h, byte** fmt, nuint* size)
    {
        int opt = *(*fmt)++;
        *size = 0;  // default
        switch (opt)
        {
            case 'b': *size = 1; return Kint;
            case 'B': *size = 1; return Kuint;
            case 'h': *size = 2; return Kint;
            case 'H': *size = 2; return Kuint;
            case 'l': *size = 8; return Kint;
            case 'L': *size = 8; return Kuint;
            case 'j': *size = (nuint)sizeof(lua_Integer); return Kint;
            case 'J': *size = (nuint)sizeof(lua_Integer); return Kuint;
            case 'T': *size = (nuint)sizeof(nuint); return Kuint;
            case 'f': *size = 4; return Kfloat;
            case 'n': *size = (nuint)sizeof(lua_Number); return Knumber;
            case 'd': *size = 8; return Kdouble;
            case 'i': *size = getnumlimit(h, fmt, 4); return Kint;
            case 'I': *size = getnumlimit(h, fmt, 4); return Kuint;
            case 's': *size = getnumlimit(h, fmt, (nuint)sizeof(nuint)); return Kstring;
            case 'c':
                *size = getnum(fmt, unchecked((nuint)(-1)));
                if (l_unlikely(*size == unchecked((nuint)(-1))))
                    luaL_error(h->L, CSTR("missing size for format option 'c'"u8));
                return Kchar;
            case 'z': return Kzstr;
            case 'x': *size = 1; return Kpadding;
            case 'X': return Kpaddalign;
            case ' ': break;
            case '<': h->islittle = 1; break;
            case '>': h->islittle = 0; break;
            case '=': h->islittle = nativelittle; break;
            case '!':
            {
                h->maxalign = getnumlimit(h, fmt, LUAI_MAXALIGN);
                break;
            }
            default: luaL_error(h->L, CSTR("invalid format option '%c'"u8), opt); break;
        }
        return Knop;
    }

    /*
    ** Read, classify, and fill other details about the next option.
    */
    private static int getdetails(Header* h, nuint totalsize, byte** fmt,
                                  nuint* psize, uint* ntoalign)
    {
        int opt = getoption(h, fmt, psize);
        nuint align = *psize;  // usually, alignment follows size
        if (opt == Kpaddalign)
        {  // 'X' gets alignment from following option
            if (**fmt == '\0' || getoption(h, fmt, &align) == Kchar || align == 0)
                luaL_argerror(h->L, 1, CSTR("invalid next option for option 'X'"u8));
        }
        if (align <= 1 || opt == Kchar)  // need no alignment?
            *ntoalign = 0;
        else
        {
            if (align > h->maxalign)  // enforce maximum alignment
                align = h->maxalign;
            if (l_unlikely(!ispow2(align)))
            {  // not a power of 2?
                *ntoalign = 0;  // to avoid warnings
                luaL_argerror(h->L, 1, CSTR("format asks for alignment not power of 2"u8));
            }
            else
            {
                uint szmoda = (uint)(totalsize & (align - 1));
                *ntoalign = (uint)((align - szmoda) & (align - 1));
            }
        }
        return opt;
    }

    /*
    ** Pack integer 'n' with 'size' bytes and 'islittle' endianness.
    */
    private static void packint(luaL_Buffer* b, lua_Unsigned n,
                                int islittle, uint size, int neg)
    {
        byte* buff = luaL_prepbuffsize(b, size);
        uint i;
        buff[islittle != 0 ? 0 : size - 1] = (byte)(n & MC);  // first byte
        for (i = 1; i < size; i++)
        {
            n >>= NB;
            buff[islittle != 0 ? i : size - 1 - i] = (byte)(n & MC);
        }
        if (neg != 0 && size > SZINT)
        {  // negative number need sign extension?
            for (i = SZINT; i < size; i++)  // correct extra bytes
                buff[islittle != 0 ? i : size - 1 - i] = MC;
        }
        luaL_addsize(b, size);  // add result to buffer
    }

    /*
    ** Copy 'size' bytes from 'src' to 'dest', correcting endianness.
    */
    private static void copywithendian(byte* dest, byte* src, uint size, int islittle)
    {
        if (islittle == nativelittle)
            memcpy(dest, src, size);
        else
        {
            dest += size - 1;
            while (size-- != 0)
                *dest-- = *src++;
        }
    }

    private static int str_pack(lua_State* L)
    {
        luaL_Buffer b;
        Header h;
        byte* fmt = luaL_checkstring(L, 1);  // format string
        int arg = 1;  // current argument to pack
        nuint totalsize = 0;  // accumulate total size of result
        initheader(L, &h);
        lua_pushnil(L);  // mark to separate arguments from string buffer
        luaL_buffinit(L, &b);
        while (*fmt != '\0')
        {
            uint ntoalign;
            nuint size;
            int opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
            luaL_argcheck(L, size + ntoalign <= MAX_SIZE - totalsize, arg,
                          CSTR("result too long"u8));
            totalsize += ntoalign + size;
            while (ntoalign-- > 0)
                luaL_addchar(&b, LUAL_PACKPADBYTE);  // fill alignment
            arg++;
            switch (opt)
            {
                case Kint:
                {  // signed integers
                    lua_Integer n = luaL_checkinteger(L, arg);
                    if (size < SZINT)
                    {  // need overflow check?
                        lua_Integer lim = (lua_Integer)1 << (int)(size * NB - 1);
                        luaL_argcheck(L, -lim <= n && n < lim, arg,
                                      CSTR("integer overflow"u8));
                    }
                    packint(&b, (lua_Unsigned)n, h.islittle, (uint)size, n < 0 ? 1 : 0);
                    break;
                }
                case Kuint:
                {  // unsigned integers
                    lua_Integer n = luaL_checkinteger(L, arg);
                    if (size < SZINT)  // need overflow check?
                        luaL_argcheck(L, (lua_Unsigned)n < (lua_Unsigned)1 << (int)(size * NB),
                                      arg, CSTR("unsigned overflow"u8));
                    packint(&b, (lua_Unsigned)n, h.islittle, (uint)size, 0);
                    break;
                }
                case Kfloat:
                {  // C float
                    float f = (float)luaL_checknumber(L, arg);  // get argument
                    byte* buff = luaL_prepbuffsize(&b, sizeof(float));
                    copywithendian(buff, (byte*)&f, sizeof(float), h.islittle);
                    luaL_addsize(&b, size);
                    break;
                }
                case Knumber:
                {  // Lua float
                    lua_Number f = luaL_checknumber(L, arg);  // get argument
                    byte* buff = luaL_prepbuffsize(&b, sizeof(lua_Number));
                    copywithendian(buff, (byte*)&f, sizeof(lua_Number), h.islittle);
                    luaL_addsize(&b, size);
                    break;
                }
                case Kdouble:
                {  // C double
                    double f = luaL_checknumber(L, arg);  // get argument
                    byte* buff = luaL_prepbuffsize(&b, sizeof(double));
                    copywithendian(buff, (byte*)&f, sizeof(double), h.islittle);
                    luaL_addsize(&b, size);
                    break;
                }
                case Kchar:
                {  // fixed-size string
                    nuint len;
                    byte* s = luaL_checklstring(L, arg, &len);
                    luaL_argcheck(L, len <= size, arg,
                                  CSTR("string longer than given size"u8));
                    luaL_addlstring(&b, s, len);  // add string
                    if (len < size)
                    {  // does it need padding?
                        nuint psize = size - len;  // pad size
                        byte* buff = luaL_prepbuffsize(&b, psize);
                        memset(buff, LUAL_PACKPADBYTE, psize);
                        luaL_addsize(&b, psize);
                    }
                    break;
                }
                case Kstring:
                {  // strings with length count
                    nuint len;
                    byte* s = luaL_checklstring(L, arg, &len);
                    luaL_argcheck(L, size >= (nuint)sizeof(lua_Unsigned) ||
                                  len < (nuint)1 << (int)(size * NB),
                                  arg, CSTR("string length does not fit in given size"u8));
                    packint(&b, len, h.islittle, (uint)size, 0);  // pack length
                    luaL_addlstring(&b, s, len);
                    totalsize += len;
                    break;
                }
                case Kzstr:
                {  // zero-terminated string
                    nuint len;
                    byte* s = luaL_checklstring(L, arg, &len);
                    luaL_argcheck(L, strlen(s) == len, arg,
                                  CSTR("string contains zeros"u8));
                    luaL_addlstring(&b, s, len);
                    luaL_addchar(&b, '\0');  // add zero at the end
                    totalsize += len + 1;
                    break;
                }
                case Kpadding:
                    luaL_addchar(&b, LUAL_PACKPADBYTE);
                    goto case Knop;  // FALLTHROUGH
                case Kpaddalign:
                case Knop:
                    arg--;  // undo increment
                    break;
            }
        }
        luaL_pushresult(&b);
        return 1;
    }

    private static int str_packsize(lua_State* L)
    {
        Header h;
        byte* fmt = luaL_checkstring(L, 1);  // format string
        nuint totalsize = 0;  // accumulate total size of result
        initheader(L, &h);
        while (*fmt != '\0')
        {
            uint ntoalign;
            nuint size;
            int opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
            luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1,
                          CSTR("variable-length format"u8));
            size += ntoalign;  // total space used by option
            luaL_argcheck(L, totalsize <= MAX_SIZE - size, 1,
                          CSTR("format result too large"u8));
            totalsize += size;
        }
        lua_pushinteger(L, cast_st2S(totalsize));
        return 1;
    }

    /*
    ** Unpack an integer with 'size' bytes and 'islittle' endianness.
    */
    private static lua_Integer unpackint(lua_State* L, byte* str,
                                         int islittle, int size, int issigned)
    {
        lua_Unsigned res = 0;
        int i;
        int limit = size <= SZINT ? size : SZINT;
        for (i = limit - 1; i >= 0; i--)
        {
            res <<= NB;
            res |= str[islittle != 0 ? i : size - 1 - i];
        }
        if (size < SZINT)
        {  // real size smaller than lua_Integer?
            if (issigned != 0)
            {  // needs sign extension?
                lua_Unsigned mask = (lua_Unsigned)1 << (size * NB - 1);
                res = (res ^ mask) - mask;  // do sign extension
            }
        }
        else if (size > SZINT)
        {  // must check unread bytes
            int mask = issigned == 0 || (lua_Integer)res >= 0 ? 0 : MC;
            for (i = limit; i < size; i++)
            {
                if (l_unlikely(str[islittle != 0 ? i : size - 1 - i] != mask))
                    luaL_error(L,
                        CSTR("%d-byte integer does not fit into Lua Integer"u8), size);
            }
        }
        return (lua_Integer)res;
    }

    private static int str_unpack(lua_State* L)
    {
        Header h;
        byte* fmt = luaL_checkstring(L, 1);
        nuint ld;
        byte* data = luaL_checklstring(L, 2, &ld);
        nuint pos = posrelatI(luaL_optinteger(L, 3, 1), ld) - 1;
        int n = 0;  // number of results
        luaL_argcheck(L, pos <= ld, 3, CSTR("initial position out of string"u8));
        initheader(L, &h);
        while (*fmt != '\0')
        {
            uint ntoalign;
            nuint size;
            int opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
            luaL_argcheck(L, ntoalign + size <= ld - pos, 2,
                          CSTR("data string too short"u8));
            pos += ntoalign;  // skip alignment
            // stack space for item + next position
            luaL_checkstack(L, 2, CSTR("too many results"u8));
            n++;
            switch (opt)
            {
                case Kint:
                case Kuint:
                {
                    lua_Integer res = unpackint(L, data + pos, h.islittle,
                                                (int)size, opt == Kint ? 1 : 0);
                    lua_pushinteger(L, res);
                    break;
                }
                case Kfloat:
                {
                    float f;
                    copywithendian((byte*)&f, data + pos, sizeof(float), h.islittle);
                    lua_pushnumber(L, f);
                    break;
                }
                case Knumber:
                {
                    lua_Number f;
                    copywithendian((byte*)&f, data + pos, sizeof(lua_Number), h.islittle);
                    lua_pushnumber(L, f);
                    break;
                }
                case Kdouble:
                {
                    double f;
                    copywithendian((byte*)&f, data + pos, sizeof(double), h.islittle);
                    lua_pushnumber(L, f);
                    break;
                }
                case Kchar:
                {
                    lua_pushlstring(L, data + pos, size);
                    break;
                }
                case Kstring:
                {
                    lua_Unsigned len = (lua_Unsigned)unpackint(L, data + pos,
                                            h.islittle, (int)size, 0);
                    luaL_argcheck(L, len <= ld - pos - size, 2,
                                  CSTR("data string too short"u8));
                    lua_pushlstring(L, data + pos + size, (nuint)len);
                    pos += (nuint)len;  // skip string
                    break;
                }
                case Kzstr:
                {
                    nuint len = strlen(data + pos);
                    luaL_argcheck(L, pos + len < ld, 2,
                                  CSTR("unfinished string for format 'z'"u8));
                    lua_pushlstring(L, data + pos, len);
                    pos += len + 1;  // skip string plus final '\0'
                    break;
                }
                case Kpaddalign:
                case Kpadding:
                case Knop:
                    n--;  // undo increment
                    break;
            }
            pos += size;
        }
        lua_pushinteger(L, cast_st2S(pos) + 1);  // next position
        return n + 1;
    }

    private static readonly IntPtr _strlib = create_strlib();

    private static IntPtr create_strlib()
    {
        luaL_Reg* r = newregs(17);
        int i = 0;
        reg(r, ref i, "byte"u8, &str_byte);
        reg(r, ref i, "char"u8, &str_char);
        reg(r, ref i, "dump"u8, &str_dump);
        reg(r, ref i, "find"u8, &str_find);
        reg(r, ref i, "format"u8, &str_format);
        reg(r, ref i, "gmatch"u8, &gmatch);
        reg(r, ref i, "gsub"u8, &str_gsub);
        reg(r, ref i, "len"u8, &str_len);
        reg(r, ref i, "lower"u8, &str_lower);
        reg(r, ref i, "match"u8, &str_match);
        reg(r, ref i, "rep"u8, &str_rep);
        reg(r, ref i, "reverse"u8, &str_reverse);
        reg(r, ref i, "sub"u8, &str_sub);
        reg(r, ref i, "upper"u8, &str_upper);
        reg(r, ref i, "pack"u8, &str_pack);
        reg(r, ref i, "packsize"u8, &str_packsize);
        reg(r, ref i, "unpack"u8, &str_unpack);
        return (IntPtr)r;
    }

    private static void createmetatable(lua_State* L)
    {
        // table to be metatable for strings
        luaL_newlibtable(L, (luaL_Reg*)_stringmetamethods, 9);
        luaL_setfuncs(L, (luaL_Reg*)_stringmetamethods, 0);
        lua_pushstring(L, CSTR(""u8));  // dummy string
        lua_pushvalue(L, -2);  // copy table
        lua_setmetatable(L, -2);  // set table as metatable for strings
        lua_pop(L, 1);  // pop dummy string
        lua_pushvalue(L, -2);  // get string library
        lua_setfield(L, -2, CSTR("__index"u8));  // metatable.__index = string
        lua_pop(L, 1);  // pop metatable
    }

    /*
    ** Open string library
    */
    public static int luaopen_string(lua_State* L)
    {
        luaL_newlib(L, (luaL_Reg*)_strlib, 17);
        createmetatable(L);
        return 1;
    }
}