Cleaning up

1 files changed, 0 insertions, 769 deletions

diff --git a/compiler.lua b/compiler.lua
deleted file mode 100644
index 0e852c0..0000000
--- a/compiler.lua
+++ /dev/null
@@ -1,769 +0,0 @@
---[[
-    This file is part of cratera.lua - pure-Lua Cratera-to-Lua transpiler
-    Copyright (C) 2019  Soni L.
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
---]]
-
---[[
-    This software is based on Lua 5.1 and Lua 5.3
-
-    Lua 5.1 license:
-
-/******************************************************************************
-* Copyright (C) 1994-2012 Lua.org, PUC-Rio.  All rights reserved.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/
-
-    Lua 5.3 license:
-
-/******************************************************************************
-* Copyright (C) 1994-2018 Lua.org, PUC-Rio.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-******************************************************************************/
---]]
-
--- this is basically just a straight translation of the lparser.c
--- main difference is we don't care about lua_State *L
-
-local parser = require "parser"
-local selfify = parser.selfify
-local STATE = parser.STATE
-local TK = require "luatokens".TK
-local error, assert = error, assert
--- try to avoid making too many locals because Lua has a limit to how many locals you can have
-local coroutine = {create = coroutine.create,
-                   resume = coroutine.resume,
-                   yield  = coroutine.yield}
-local math = {huge  = math.huge,
-              floor = math.floor}
-local string = {format = string.format}
-
-local luaX = {} -- lexer
-local luaK = {} -- code generator
-
-luaK.ret = function() end -- FIXME
-
-luaX.next = (function()
-    local extra_tokens = {[TK.NAME] = true, [TK.INT] = true, [TK.FLT] = true, [TK.STRING] = true}
-    return function(ls)
-        ls.lastline = ls.linenumber
-        if ls.lookahead_token then
-            ls.t_token = ls.lookahead_token
-            ls.lookahead_token = nil
-            ls.t_seminfo = ls.lookahead_seminfo
-        end
-        local token = coroutine.yield()
-        ls.t_token = token
-        if extra_tokens[token] then
-            ls.t_seminfo = coroutine.yield()
-        end
-    end
-end)()
-
-local function save_token(ls)
-    local tk = ls.t_token
-    local seminfo = ls.t_seminfo
-    local c = ls[parser.COLLECT] or ls
-    if tk == TK.FLOAT then
-        local token = seminfo
-        local extra, num, den = 1, token, 1
-        assert(token == token and token >= 0, "NYI") -- the tokenizer should never output NaNs or negative values
-        if token == math.huge then
-            num, den = 1, 0
-        else
-            while num ~= math.floor(num) do
-                num = num * 2 -- always safe (I think)
-                local oldden = den
-                den = den * 2
-                if den == math.huge then -- subnormals or something?
-                    extra = oldden
-                    den = 2
-                end
-            end
-        end
-        c[#c+1] = string.format('((%d/%d)/%d)', num, den, extra)
-    elseif tk == TK.INT then
-        c[#c+1] = string.format('%d', seminfo)
-    elseif tk == TK.STRING then
-        c[#c+1] = string.format('%q', seminfo)
-    elseif tk == TK.NAME then
-        c[#c+1] = seminfo
-    else
-        c[#c+1] = tostring(tk)
-    end
-end
-
-function luaX.syntaxerror(ls, msg)
-    error("NYI")
-end
-
--- maximum number of local variables per function (must be smaller
--- than 250, due to the bytecode format)
-local MAXVARS = 200
-
--- hasmultret TODO
--- eqstr TODO
-
--- prototypes for recursive non-terminal functions
-local statement, expr
-
--- semantic error
-local function semerror(ls, msg)
-    ls.t_token = nil -- remove "near <token>" from final message
-    luaX.syntaxerror(ls, msg)
-end
-
-local function error_expected(ls, token)
-    luaX.syntaxerror(ls, string.format("%s expected", tostring(token)))
-end
-
--- errorlimit TODO
--- checklimit TODO
-
-local function testnext(ls, c)
-    if ls.t_token == c then
-        save_token(ls)
-        luaX.next(ls)
-        return true
-    end
-    return false
-end
-
-local function check(ls, c)
-    if ls.t_token ~= c then
-        error_expected(ls, c)
-    end
-end
-
-local function checknext(ls, c)
-    check(ls, c)
-    save_token(ls)
-    luaX.next(ls)
-end
-
-local function check_condition(ls, c, msg) if not c then luaX.syntaxerror(ls, msg) end end
-
-local function check_match(ls, what, who, where)
-    if not testnext(ls, what) then
-        if where == ls.linenumber then
-            error_expected(ls, what)
-        else
-            luaX.syntaxerror(ls, string.format("%s expected (to close %s at line %d)", tostring(what), tostring(who), where))
-        end
-    end
-end
-
-local function str_checkname(ls)
-    check(ls, TK.NAME)
-    local ts = ls.t_seminfo
-    save_token(ls)
-    luaX.next(ls)
-    return ts
-end
-
-local function init_exp(expdesc, expkind, i)
-    expdesc.t = NO_JUMP
-    expdesc.f = expdesc.t
-    expdesc.k = expkind
-    expdesc.val = i
-end
-
-local function codestring(ls, e, s)
-    init_exp(e, VK, luaK.stringK(ls.fs, s))
-end
-
--- checkname TODO
--- registerlocalvar TODO
--- new_localvar TODO
--- new_localvarliteral_ TODO
--- new_localvarliteral TODO
--- getlocvar TODO
--- adjustlocalvars TODO
--- removevars TODO
--- searchupvalue TODO
--- newupvalue TODO
--- searchvar TODO
--- markupval TODO
--- singlevaraux TODO
--- singlevar TODO
--- adjust_assign TODO
-
-local function enterlevel(ls)
-    -- don't bother
-    --local L = ls.L
-    --L.nCcalls = L.nCcalls + 1
-    --checklimit(ls.fs, L.nCcalls, LUAI_MAXCCALLS, "C levels")
-end
-
-local function leavelevel(ls)
-    --ls.L.nCcalls = ls.L.nCcalls - 1
-end
-
--- closegoto TODO
--- findlabel TODO
--- newlabelentry TODO
--- findgotos TODO
--- movegotosout TODO
-
-local function enterblock(fs, bl, isloop)
-    bl.isloop = isloop
-    bl.nactvar = fs.nactvar
-    bl.firstlabel = #fs.ls.dyd.label
-    bl.firstgoto = #fs.ls.dyd.gt
-    bl.upval = 0
-    bl.previous = fs.bl
-    fs.bl = bl
-    --lua_assert(fs.freereg == fs.nactvar)
-end
-
--- breaklabel TODO
--- undefgoto TODO
-
-local function leaveblock(fs)
-    local bl = fs.bl
-    local ls = fs.ls
-    if bl.previous and bl.upval then
-        -- create a 'jump to here' to close upvalues
-        local j = luaK.jump(fs)
-        luaK.patchclose(fs, j, bl.nactvar)
-        luaK.patchtohere(fs, j)
-    end
-    if bl.isloop then
-        breaklabel(ls) -- close pending breaks
-    end
-    fs.bl = bl.previous
-    removevars(fs, bl.nactvar)
-    --lua_assert(bl.nactvar == fs.nactvar)
-    fs.freereg = fs.nactvar -- free registers
-    for i=bl.firstlabel,#ls.dyd.label do ls.dyd.label[i]=nil end -- remove local labels
-    if bl.previous then
-        movegotosout(fs, bl)
-    elseif bl.firstgoto < #ls.dyd.gt then
-        undefgoto(ls, ls.dyd.gt[bl.firstgoto])
-    end
-end
-
--- addprototype TODO
-
--- codes instruction to create new closure in parent function.
--- The OP_CLOSURe instruction must use the last available register,
--- so that, if it invokes the GC, the GC knows which registers
--- are in use at that time.
-local function codeclosure(ls, v)
-    local fs = ls.fs.prev
-    init_exp(v, VRELOCABLE, luaK.codeABx(fs, OP_CLOSURE, 0, #fs.f.p - 1))
-    luaK.exp2nextreg(fs, v) -- fix it at the last register
-end
-
-local function open_func(ls, fs, bl)
-    fs.prev = ls.fs
-    fs.ls = ls
-    ls.fs = fs
-    fs.pc = 0
-    fs.lasttarget = 0
-    fs.jpc = NO_JUMP
-    fs.freereg = 0
-    fs.nactvar = 0
-    fs.firstlocal = #ls.dyd.actvar
-    fs.bl = nil
-    local f = fs.f
-    f.source = ls.source
-    f.maxstacksize = 2 -- registers 0/1 are always valid
-    enterblock(fs, bl, false)
-end
-
-local function close_func(ls)
-    local fs = ls.fs
-    local f = fs.f
-    luaK.ret(fs, 0, 0) -- final return
-    leaveblock(fs)
-    -- don't need to worry about reallocating vectors
-    --lua_assert(fs.bl == nil)
-    ls.fs = fs.prev
-end
-
-local block_follow = (function()
-    local tokens = {[TK.ELSE] = true, [TK.ELSEIF] = true, [TK.END] = true, [parser.EOZ] = true}
-    return function(ls, withuntil)
-        local tk = ls.t_token
-        return tokens[tk] or (withuntil and tk == TK.UNTIL)
-    end
-end)()
-
-local function statlist(ls)
-    -- statlist -> { stat [';'] }
-    while not block_follow(ls, true) do
-        if ls.t_token == TK_RETURN then
-            statement(ls)
-            return -- 'return' must be last statement
-        end
-        statement(ls)
-    end
-end
-
--- fieldsel TODO
-
-local function yindex(ls, v)
-    -- index -> '[' expr ']'
-    save_token(ls)
-    luaX.next(ls) -- skip the '['
-    expr(ls, v)
-    luaK.exp2val(ls.fs, v)
-    checknext(ls, ']')
-end
-
--- recfield TODO
--- closelistfield TODO
--- lastlistfield TODO
--- listfield TODO
--- field TODO
--- constructor TODO
--- parlist TODO
-
-local function body(ls, e, ismethod, line)
-    -- body -> '(' parlist ')' block END
-    -- TODO
-    error("NYI")
-end
-
-local function explist(ls, v)
-    -- explist -> expr { ',' expr }
-    local n = 1 -- at least one expression
-    expr(ls, v)
-    while testnext(ls, ',') do
-        luaK.exp2nextreg(ls.fs, v)
-        expr(ls, v)
-        n = n + 1
-    end
-    return n
-end
-
-local function funcargs(ls, f, line)
-    local fs = ls.fs
-    local args = {}
-    local base, nparams
-    local tk = ls.t_token
-    if tk == '(' then -- funcargs -> '(' [ explist ] ')'
-        save_token(ls)
-        luaX.next(ls)
-        if ls.t_token == ')' then -- arg list is empty?
-            args.k = VVOID
-        else
-            explist(ls, args)
-            luaK.setmultret(fs, args)
-        end
-        check_match(ls, ')', '(', line)
-    elseif tk == '{' then -- funcargs -> constructor
-        constructor(ls, args)
-    elseif tk == TK.STRING then -- funcargs -> STRING
-        codestring(ls, args, ls.t_seminfo)
-        save_token(ls)
-        luaX.next(ls) -- must use 'seminfo' before 'next'
-    else
-        luaX.syntaxerror(ls, "function arguments expected")
-    end
-    --lua_assert(f.k == VNONRELOC)
-    base = f.val -- base register for call
-    if hasmultret(args.k) then
-        nparams = LUA_MULTRET -- open call
-    else
-        if args.k ~= VVOID then
-            luaK.exp2nextreg(fs, args) -- close last argument
-        end
-        nparams = fs.freereg - (base+1)
-    end
-    init_exp(f, VCALL, luaK.codeABC(fs, OP_CALL, base, nparams+1, 2))
-    luaK.fixline(fs, line)
-    fs.freereg = base+1 -- call remove function and arguments and leaves
-                        -- (unless changed) one result
-end
-
-local suffixedexp -- hm.
-
-;(function() -- avoid issues with 200 locals or w/e
-    local function primaryexp(ls, v)
-        local tk = ls.t_token
-        if tk == '(' then
-            local line = ls.linenumber
-            save_token(ls)
-            luaX.next(ls)
-            expr(ls, v)
-            check_match(ls, ')', '(', line)
-            luaK.dischargevars(ls.fs, v)
-        elseif tk == TK.NAME then
-            singlevar(ls, v)
-        else
-            luaX.syntaxerror(ls, "unexpected symbol")
-        end
-    end
-
-    function suffixedexp(ls, v)
-        -- suffixedexp ->
-        --   primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs }
-        local fs = ls.fs
-        local line = ls.linenumber
-        primaryexp(ls, v)
-        repeat
-            local tk = ls.t_token
-            if tk == '.' then -- fieldsel
-                fieldsel(ls, v)
-            elseif tk == '[' then -- '[' exp1 ']'
-                local key = {}
-                luaK.exp2anyregup(fs, v)
-                yindex(ls, key)
-                luaK.indexed(fs, v, key)
-            elseif tk == ':' then -- ':' NAME funcargs
-                local key = {}
-                save_token(ls)
-                luaX.next(ls)
-                checkname(ls, key)
-                luaK.self(fs, v, key)
-                funcargs(ls, v, line)
-            elseif tk == '(' or tk == TK.STRING or tk == '{' then -- funcargs
-                luaK.exp2nextreg(fs, v)
-                funcargs(ls, v, line)
-            else
-                return
-            end
-        until nil
-    end
-
-    local function simpleexp(ls, v)
-        -- simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |
-        --              constructor | FUNCTION body | suffixedexp
-        local tk = ls.t_token
-        if tk == TK.FLT then
-            init_exp(v, VKFLT, 0)
-            v.val = ls.t_seminfo
-        elseif tk == TK.INT then
-            init_exp(v, VKINT, 0)
-            v.val = ls.t_seminfo
-        elseif tk == TK.STRING then
-            codestring(ls, v, ls.t_seminfo)
-        elseif tk == TK.NIL then
-            init_exp(v, VNIL, 0)
-        elseif tk == TK.TRUE then
-            init_exp(v, VTRUE, 0)
-        elseif tk == TK.FALSE then
-            init_exp(v, VFALSE, 0)
-        elseif tk == TK.DOTS then -- vararg
-            local fs = ls.fs
-            check_condition(ls, fs.f.is_vararg,
-                            "cannot use '...' outside a vararg function")
-            init_exp(v, VVARARG, luaK.codeABC(fs, OP.VARARG, 0, 1, 0))
-        elseif tk == '{' then
-            constructor(ls, v)
-        elseif tk == TK.FUNCTION then
-            save_token(ls)
-            luaX.next(ls)
-            body(ls, v, 0, ls.linenumber)
-        else
-            suffixedexp(ls, v)
-        end
-        save_token(ls)
-        luaX.next(ls)
-    end
-
-    local function getunopr(op)
-        if op == TK.NOT or
-           op == '-' or
-           op == '~' or
-           op == '#' then
-            return op
-        end
-    end
-
-    -- order intentionally swapped
-    local priority = {
-        ['+'] =       {left=10, right=10},
-        ['-'] =       {left=10, right=10},
-        ['*'] =       {left=11, right=11},
-        ['%'] =       {left=11, right=11},
-        ['^'] =       {left=14, right=13},
-        ['/'] =       {left=11, right=11},
-        [TK.IDIV] =   {left=11, right=11},
-        ['&'] =       {left=6,  right=6},
-        ['|'] =       {left=4,  right=4},
-        ['~'] =       {left=5,  right=5},
-        [TK.SHL] =    {left=7,  right=7},
-        [TK.SHR] =    {left=7,  right=7},
-        [TK.CONCAT] = {left=9,  right=8},
-        [TK.EQ] =     {left=3,  right=3},
-        ['<'] =       {left=3,  right=3},
-        [TK.LE] =     {left=3,  right=3},
-        [TK.NE] =     {left=3,  right=3},
-        ['>'] =       {left=3,  right=3},
-        [TK.GE] =     {left=3,  right=3},
-        [TK.AND] =    {left=2,  right=2},
-        [TK.OR] =     {left=1,  right=1},
-    }
-
-    -- order intentionally swapped
-    local function getbinopr(op)
-        if priority[op] then
-            return op
-        end
-    end
-
-    local UNARY_PRIORITY = 12
-
-    -- subexpr -> (simpleexp | unop subexpr) { binop subexpr }
-    -- where 'binop' is any binary operator with a priority higher than 'limit'
-    local function subexpr(ls, v, limit)
-        enterlevel(ls)
-        local uop = getunopr(ls.t_token)
-        if uop then
-            local line = ls.linenumber
-            save_token(ls)
-            luaX.next(ls)
-            subexpr(ls, v, UNARY_PRIORITY)
-            luaK.prefix(ls.fs, uop, v, line)
-        else
-            simpleexp(ls, v)
-        end
-        -- expand while operators have priorities higher than 'limit'
-        local op = getbinopr(ls.t_token)
-        while op and priority[op].left > limit do
-            local line = ls.linenumber
-            save_token(ls)
-            luaX.next(ls)
-            luaK.infix(ls.fs, op, v)
-            -- read sub-expression with higher priority
-            local nextop = subexpr(ls, v2, priority[op].right)
-            luaK_posfix(ls.fs, op, v, v2, line)
-            op = nextop
-        end
-        leavelevel(ls)
-        return op -- return first untreated operator
-    end
-
-    function expr(ls, v)
-        subexpr(ls, v, 0)
-    end
-end)()
-
-;(function() -- avoid issues with 200 locals or w/e
-    -- block TODO
-    -- check_conflict TODO
-    -- assignment TODO
-    -- cond TODO
-
-    local function gotostat(ls, pc)
-        local line = ls.linenumber
-        local label
-        if testnext(ls, TK.GOTO) then
-            label = str_checkname(ls)
-        else
-            save_token(ls)
-            luaX.next(ls) -- skip break
-            label = "break" -- ?
-        end
-        local g = newlabelentry(ls, ls.dyd.gt, label, line, pc)
-        findlabel(ls, g) -- close it if label already defined
-    end
-
-    -- checkrepeated TODO
-
-    local function skipnoopstat(ls)
-        while ls.t_token == ';' or ls.t_token == TK.DBCOLON do
-            statement(ls)
-        end
-    end
-
-    -- labelstat TODO
-    -- whilestat TODO
-    -- repeatstat TODO
-    -- exp1 TODO
-    -- forbody TODO
-    -- fornum TODO
-    -- forlist TODO
-    -- forstat TODO
-    -- test_then_block TODO
-    -- ifstat TODO
-    -- localfunc TODO
-    -- localstat TODO
-    -- funcname TODO
-    -- funcstat TODO
-    -- exprstat TODO
-
-    local function retstat(ls)
-        local fs = ls.fs
-        local e = {}
-        local first, nret
-        if block_follow(ls, true) or ls.t_token == ';' then
-            first, nret = 0, 0
-        else
-            nret = explist(ls, e)
-            if hasmultret(e.k) then
-                luaK.setmultret(fs, e)
-                if e.k == VCALL and nret == 1 then -- tail call?
-                    --SET_OPCODE(getinstruction(fs,e), OP_TAILCALL)
-                    --lua_assert(GETARG_A(getinstruction(fs,e)) == fs.nactvar)
-                end
-                first = fs.nactvar
-                nret = LUA_MULTRET
-            else
-                if nret == 1 then
-                    first = luaK.exp2anyreg(fs, e)
-                else
-                    luaK.exp2nextreg(fs, e)
-                    first = fs.nactvar
-                    --lua_assert(nret == fs.freereg - first)
-                end
-            end
-        end
-        luaK.ret(fs, first, nret)
-        testnext(ls, ';') -- skip optional semicolon
-    end
-
-    function statement(ls)
-        local line = ls.linenumber
-        enterlevel(ls)
-        local tk = ls.t_token
-        if tk == ';' then -- stat -> ';' (empty statement)
-            save_token(ls)
-            luaX.next(ls) -- skip ';'
-        elseif tk == TK.IF then -- stat -> ifstat
-            ifstat(ls, line)
-        elseif tk == TK.WHILE then -- stat -> whilestat
-            whilestat(ls, line)
-        elseif tk == TK.DO then --> stat -> DO block END
-            save_token(ls)
-            luaX.next(ls) -- skip DO
-            block(ls)
-            check_match(ls, TK_END, TK_DO, line)
-        elseif tk == TK.FOR then -- stat -> forstat
-            forstat(ls, line)
-        elseif tk == TK.REPEAT then -- stat -> repeatstat
-            repeatstat(ls, line)
-        elseif tk == TK.FUNCTION then -- stat -> funcstat
-            funcstat(ls, line)
-        elseif tk == TK.LOCAL then -- stat -> localstat
-            save_token(ls)
-            luaX.next(ls) -- skip LOCAL
-            if testnext(ls, TK.FUNCTION) then -- local function?
-                localfunc(ls)
-            else
-                localstat(ls)
-            end
-        elseif tk == TK.DBCOLON then -- stat -> label
-            save_token(ls)
-            luaX.next(ls) -- skip double colon
-            labelstat(ls, str_checkname(ls), line)
-        elseif tk == TK.RETURN then -- stat -> retstat
-            save_token(ls)
-            luaX.next(ls) -- skip RETURN
-            retstat(ls)
-        elseif tk == TK.BREAK     -- stat -> breakstat
-            or tk == TK.GOTO then -- stat -> 'goto' NAME
-            gotostat(ls, luaK.jump(ls.fs))
-        else
-            exprstat(ls)
-        end
-        --lua_assert(ls.fs.f.maxstacksize >= ls.fs.freereg and
-        --           ls.fs.freereg >= ls.fs.nactvar)
-        ls.fs.freereg = ls.fs.nactvar -- free registers
-        leavelevel(ls)
-    end
-end)()
-
-local function mainfunc(ls, fs)
-    local bl = {}
-    open_func(ls, fs, bl)
-    fs.f.is_vararg = true
-    -- we don't worry about these:
-    --local v = {}
-    --init_exp(v, VLOCAL, 0)
-    --newupvalue(fs, ls.envn, &v)
-    luaX.next(ls)
-    statlist(ls)
-    check(ls, parser.EOZ)
-    close_func(ls)
-end
-
-local function worst_cratera_parser(ls) -- luaY.parser
-    local lexstate, funcstate, cl
-    lexstate = ls
-    funcstate = {}
-    cl = {}
-    lexstate.h = {}
-    cl.p = {}
-    funcstate.f = cl.p
-    funcstate.f.source = lexstate.source
-    --lua_assert(iswhite(funcstate.f))
-    --lexstate.buff = {} -- ???
-    lexstate.dyd = {actvar = {}, gt = {}, label = {}} -- ???
-    if not lexstate.linenumber then lexstate.linenumber = 1 end -- not managed by us
-    lexstate.lastline = 1
-    mainfunc(lexstate, funcstate)
-    --lua_assert(!funcstate.prev and funcstate.nups == 1 and !lexstate.fs)
-    --lua_assert(#dyd.actvar == 0 and #dyd.gt == 0 and #dyd.label == 0)
-    return cl -- close enough
-end
-
-local defs = selfify({})
-defs[parser.EOZ] = parser.FALLBACK
-defs[parser.FALLBACK] = function(state, token)
-    local coro = state.coro
-    if not coro then
-        coro = coroutine.create(worst_cratera_parser)
-        state.coro = coro
-        state.t = {} -- token
-        assert(coroutine.resume(coro, state))
-    end
-    local _, override = assert(coroutine.resume(coro, token))
-    if override then return override end
-    return "self"
-end
-
-return {
-    defs = defs,
-}