@rbxts/zyntex-sdk 1.0.2 → 6.0.0

package/Loadstring/Yueliang.lua

@@ -1,4449 +0,0 @@
--- Adapted from the amazing Yueliang project
--- http://yueliang.luaforge.net/
-
---[[--------------------------------------------------------------------
-
-luac.lua
-Primitive luac in Lua
-This file is part of Yueliang.
-
-Copyright (c) 2005-2007 Kein-Hong Man <khman@users.sf.net>
-The COPYRIGHT file describes the conditions
-under which this software may be distributed.
-
-See the ChangeLog for more information.
-
-----------------------------------------------------------------------]]
-
---[[--------------------------------------------------------------------
--- Notes:
--- * based on luac.lua in the test directory of the 5.1.2 distribution
--- * usage: lua luac.lua file.lua
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- load and initialize the required modules
-------------------------------------------------------------------------
-local luaZ = {}
-local luaY = {}
-local luaX = {}
-local luaP = {}
-local luaU = {}
-local luaK = {}
-local size_size_t = 8
-
--- currently asserts are enabled because the codebase hasn't been tested
--- much (if you don't want asserts, just comment them out)
-local function lua_assert(test)
-	if not test then
-		error("assertion failed!")
-	end
-end
-
--- dofile("lzio.lua")
-
-------------------------------------------------------------------------
--- * reader() should return a string, or nil if nothing else to parse.
---   Additional data can be set only during stream initialization
--- * Readers are handled in lauxlib.c, see luaL_load(file|buffer|string)
--- * LUAL_BUFFERSIZE=BUFSIZ=512 in make_getF() (located in luaconf.h)
--- * Original Reader typedef:
---   const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
--- * This Lua chunk reader implementation:
---   returns string or nil, no arguments to function
-------------------------------------------------------------------------
-
-------------------------------------------------------------------------
--- create a chunk reader from a source string
-------------------------------------------------------------------------
-function luaZ:make_getS(buff)
-	local b = buff
-	return function() -- chunk reader anonymous function here
-		if not b then
-			return nil
-		end
-		local data = b
-		b = nil
-		return data
-	end
-end
-
-------------------------------------------------------------------------
--- create a chunk reader from a source file
-------------------------------------------------------------------------
--- function luaZ:make_getF(filename)
---   local LUAL_BUFFERSIZE = 512
---   local h = io.open(filename, "r")
---   if not h then return nil end
---   return function() -- chunk reader anonymous function here
---     if not h or io.type(h) == "closed file" then return nil end
---     local buff = h:read(LUAL_BUFFERSIZE)
---     if not buff then h:close(); h = nil end
---     return buff
---   end
--- end
-
-function luaZ:make_getF(source)
-	local LUAL_BUFFERSIZE = 512
-	local pos = 1
-
-	return function() -- chunk reader anonymous function here
-		local buff = source:sub(pos, pos + LUAL_BUFFERSIZE - 1)
-		pos = math.min(#source + 1, pos + LUAL_BUFFERSIZE)
-		return buff
-	end
-end
-
-------------------------------------------------------------------------
--- creates a zio input stream
--- returns the ZIO structure, z
-------------------------------------------------------------------------
-function luaZ:init(reader, data)
-	if not reader then
-		return
-	end
-	local z = {}
-	z.reader = reader
-	z.data = data or ""
-	z.name = name
-	-- set up additional data for reading
-	if not data or data == "" then
-		z.n = 0
-	else
-		z.n = #data
-	end
-	z.p = 0
-	return z
-end
-
-------------------------------------------------------------------------
--- fill up input buffer
-------------------------------------------------------------------------
-function luaZ:fill(z)
-	local buff = z.reader()
-	z.data = buff
-	if not buff or buff == "" then
-		return "EOZ"
-	end
-	z.n, z.p = #buff - 1, 1
-	return string.sub(buff, 1, 1)
-end
-
-------------------------------------------------------------------------
--- get next character from the input stream
--- * local n, p are used to optimize code generation
-------------------------------------------------------------------------
-function luaZ:zgetc(z)
-	local n, p = z.n, z.p + 1
-	if n > 0 then
-		z.n, z.p = n - 1, p
-		return string.sub(z.data, p, p)
-	else
-		return self:fill(z)
-	end
-end
-
--- dofile("llex.lua")
-
--- FIRST_RESERVED is not required as tokens are manipulated as strings
--- TOKEN_LEN deleted; maximum length of a reserved word not needed
-
-------------------------------------------------------------------------
--- "ORDER RESERVED" deleted; enumeration in one place: luaX.RESERVED
-------------------------------------------------------------------------
-
--- terminal symbols denoted by reserved words: TK_AND to TK_WHILE
--- other terminal symbols: TK_NAME to TK_EOS
-luaX.RESERVED = [[
-TK_AND and
-TK_BREAK break
-TK_DO do
-TK_ELSE else
-TK_ELSEIF elseif
-TK_END end
-TK_FALSE false
-TK_FOR for
-TK_FUNCTION function
-TK_IF if
-TK_IN in
-TK_LOCAL local
-TK_NIL nil
-TK_NOT not
-TK_OR or
-TK_REPEAT repeat
-TK_RETURN return
-TK_THEN then
-TK_TRUE true
-TK_UNTIL until
-TK_WHILE while
-TK_CONCAT ..
-TK_DOTS ...
-TK_EQ ==
-TK_GE >=
-TK_LE <=
-TK_NE ~=
-TK_NAME <name>
-TK_NUMBER <number>
-TK_STRING <string>
-TK_EOS <eof>]]
-
--- NUM_RESERVED is not required; number of reserved words
-
---[[--------------------------------------------------------------------
--- Instead of passing seminfo, the Token struct (e.g. ls.t) is passed
--- so that lexer functions can use its table element, ls.t.seminfo
---
--- SemInfo (struct no longer needed, a mixed-type value is used)
---
--- Token (struct of ls.t and ls.lookahead):
---   token  -- token symbol
---   seminfo  -- semantics information
---
--- LexState (struct of ls; ls is initialized by luaX:setinput):
---   current  -- current character (charint)
---   linenumber  -- input line counter
---   lastline  -- line of last token 'consumed'
---   t  -- current token (table: struct Token)
---   lookahead  -- look ahead token (table: struct Token)
---   fs  -- 'FuncState' is private to the parser
---   L -- LuaState
---   z  -- input stream
---   buff  -- buffer for tokens
---   source  -- current source name
---   decpoint -- locale decimal point
---   nestlevel  -- level of nested non-terminals
-----------------------------------------------------------------------]]
-
--- luaX.tokens (was luaX_tokens) is now a hash; see luaX:init
-
-luaX.MAXSRC = 80
-luaX.MAX_INT = 2147483645 -- constants from elsewhere (see above)
-luaX.LUA_QS = "'%s'"
-luaX.LUA_COMPAT_LSTR = 1
---luaX.MAX_SIZET = 4294967293
-
-------------------------------------------------------------------------
--- initialize lexer
--- * original luaX_init has code to create and register token strings
--- * luaX.tokens: TK_* -> token
--- * luaX.enums:  token -> TK_* (used in luaX:llex)
-------------------------------------------------------------------------
-function luaX:init()
-	local tokens, enums = {}, {}
-	for v in string.gmatch(self.RESERVED, "[^\n]+") do
-		local _, _, tok, str = string.find(v, "(%S+)%s+(%S+)")
-		tokens[tok] = str
-		enums[str] = tok
-	end
-	self.tokens = tokens
-	self.enums = enums
-end
-
-------------------------------------------------------------------------
--- returns a suitably-formatted chunk name or id
--- * from lobject.c, used in llex.c and ldebug.c
--- * the result, out, is returned (was first argument)
-------------------------------------------------------------------------
-function luaX:chunkid(source, bufflen)
-	local out
-	local first = string.sub(source, 1, 1)
-	if first == "=" then
-		out = string.sub(source, 2, bufflen) -- remove first char
-	else -- out = "source", or "...source"
-		if first == "@" then
-			source = string.sub(source, 2) -- skip the '@'
-			bufflen = bufflen - #" '...' "
-			local l = #source
-			out = ""
-			if l > bufflen then
-				source = string.sub(source, 1 + l - bufflen) -- get last part of file name
-				out = out .. "..."
-			end
-			out = out .. source
-		else -- out = [string "string"]
-			local len = string.find(source, "[\n\r]") -- stop at first newline
-			len = len and (len - 1) or #source
-			bufflen = bufflen - #' [string "..."] '
-			if len > bufflen then
-				len = bufflen
-			end
-			out = '[string "'
-			if len < #source then -- must truncate?
-				out = out .. string.sub(source, 1, len) .. "..."
-			else
-				out = out .. source
-			end
-			out = out .. '"]'
-		end
-	end
-	return out
-end
-
---[[--------------------------------------------------------------------
--- Support functions for lexer
--- * all lexer errors eventually reaches lexerror:
-		 syntaxerror -> lexerror
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- look up token and return keyword if found (also called by parser)
-------------------------------------------------------------------------
-function luaX:token2str(ls, token)
-	if string.sub(token, 1, 3) ~= "TK_" then
-		if string.find(token, "%c") then
-			return string.format("char(%d)", string.byte(token))
-		end
-		return token
-	else
-		return self.tokens[token]
-	end
-end
-
-------------------------------------------------------------------------
--- throws a lexer error
--- * txtToken has been made local to luaX:lexerror
--- * can't communicate LUA_ERRSYNTAX, so it is unimplemented
-------------------------------------------------------------------------
-function luaX:lexerror(ls, msg, token)
-	local function txtToken(ls, token)
-		if token == "TK_NAME" or token == "TK_STRING" or token == "TK_NUMBER" then
-			return ls.buff
-		else
-			return self:token2str(ls, token)
-		end
-	end
-	local buff = self:chunkid(ls.source, self.MAXSRC)
-	local msg = string.format("%s:%d: %s", buff, ls.linenumber, msg)
-	if token then
-		msg = string.format("%s near " .. self.LUA_QS, msg, txtToken(ls, token))
-	end
-	-- luaD_throw(ls->L, LUA_ERRSYNTAX)
-	error(msg)
-end
-
-------------------------------------------------------------------------
--- throws a syntax error (mainly called by parser)
--- * ls.t.token has to be set by the function calling luaX:llex
---   (see luaX:next and luaX:lookahead elsewhere in this file)
-------------------------------------------------------------------------
-function luaX:syntaxerror(ls, msg)
-	self:lexerror(ls, msg, ls.t.token)
-end
-
-------------------------------------------------------------------------
--- move on to next line
-------------------------------------------------------------------------
-function luaX:currIsNewline(ls)
-	return ls.current == "\n" or ls.current == "\r"
-end
-
-function luaX:inclinenumber(ls)
-	local old = ls.current
-	-- lua_assert(currIsNewline(ls))
-	self:nextc(ls) -- skip '\n' or '\r'
-	if self:currIsNewline(ls) and ls.current ~= old then
-		self:nextc(ls) -- skip '\n\r' or '\r\n'
-	end
-	ls.linenumber = ls.linenumber + 1
-	if ls.linenumber >= self.MAX_INT then
-		self:syntaxerror(ls, "chunk has too many lines")
-	end
-end
-
-------------------------------------------------------------------------
--- initializes an input stream for lexing
--- * if ls (the lexer state) is passed as a table, then it is filled in,
---   otherwise it has to be retrieved as a return value
--- * LUA_MINBUFFER not used; buffer handling not required any more
-------------------------------------------------------------------------
-function luaX:setinput(L, ls, z, source)
-	if not ls then
-		ls = {}
-	end -- create struct
-	if not ls.lookahead then
-		ls.lookahead = {}
-	end
-	if not ls.t then
-		ls.t = {}
-	end
-	ls.decpoint = "."
-	ls.L = L
-	ls.lookahead.token = "TK_EOS" -- no look-ahead token
-	ls.z = z
-	ls.fs = nil
-	ls.linenumber = 1
-	ls.lastline = 1
-	ls.source = source
-	self:nextc(ls) -- read first char
-end
-
---[[--------------------------------------------------------------------
--- LEXICAL ANALYZER
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- checks if current character read is found in the set 'set'
-------------------------------------------------------------------------
-function luaX:check_next(ls, set)
-	if not string.find(set, ls.current, 1, 1) then
-		return false
-	end
-	self:save_and_next(ls)
-	return true
-end
-
-------------------------------------------------------------------------
--- retrieve next token, checking the lookahead buffer if necessary
--- * note that the macro next(ls) in llex.c is now luaX:nextc
--- * utilized used in lparser.c (various places)
-------------------------------------------------------------------------
-function luaX:next(ls)
-	ls.lastline = ls.linenumber
-	if ls.lookahead.token ~= "TK_EOS" then -- is there a look-ahead token?
-		-- this must be copy-by-value
-		ls.t.seminfo = ls.lookahead.seminfo -- use this one
-		ls.t.token = ls.lookahead.token
-		ls.lookahead.token = "TK_EOS" -- and discharge it
-	else
-		ls.t.token = self:llex(ls, ls.t) -- read next token
-	end
-end
-
-------------------------------------------------------------------------
--- fill in the lookahead buffer
--- * utilized used in lparser.c:constructor
-------------------------------------------------------------------------
-function luaX:lookahead(ls)
-	-- lua_assert(ls.lookahead.token == "TK_EOS")
-	ls.lookahead.token = self:llex(ls, ls.lookahead)
-end
-
-------------------------------------------------------------------------
--- gets the next character and returns it
--- * this is the next() macro in llex.c; see notes at the beginning
-------------------------------------------------------------------------
-function luaX:nextc(ls)
-	local c = luaZ:zgetc(ls.z)
-	ls.current = c
-	return c
-end
-
-------------------------------------------------------------------------
--- saves the given character into the token buffer
--- * buffer handling code removed, not used in this implementation
--- * test for maximum token buffer length not used, makes things faster
-------------------------------------------------------------------------
-
-function luaX:save(ls, c)
-	local buff = ls.buff
-	-- if you want to use this, please uncomment luaX.MAX_SIZET further up
-	--if #buff > self.MAX_SIZET then
-	--  self:lexerror(ls, "lexical element too long")
-	--end
-	ls.buff = buff .. c
-end
-
-------------------------------------------------------------------------
--- save current character into token buffer, grabs next character
--- * like luaX:nextc, returns the character read for convenience
-------------------------------------------------------------------------
-function luaX:save_and_next(ls)
-	self:save(ls, ls.current)
-	return self:nextc(ls)
-end
-
-------------------------------------------------------------------------
--- LUA_NUMBER
--- * luaX:read_numeral is the main lexer function to read a number
--- * luaX:str2d, luaX:buffreplace, luaX:trydecpoint are support functions
-------------------------------------------------------------------------
-
-------------------------------------------------------------------------
--- string to number converter (was luaO_str2d from lobject.c)
--- * returns the number, nil if fails (originally returns a boolean)
--- * conversion function originally lua_str2number(s,p), a macro which
---   maps to the strtod() function by default (from luaconf.h)
-------------------------------------------------------------------------
-function luaX:str2d(s)
-	local result = tonumber(s)
-	if result then
-		return result
-	end
-	-- conversion failed
-	if string.lower(string.sub(s, 1, 2)) == "0x" then -- maybe an hexadecimal constant?
-		result = tonumber(s, 16)
-		if result then
-			return result
-		end -- most common case
-		-- Was: invalid trailing characters?
-		-- In C, this function then skips over trailing spaces.
-		-- true is returned if nothing else is found except for spaces.
-		-- If there is still something else, then it returns a false.
-		-- All this is not necessary using Lua's tonumber.
-	end
-	return nil
-end
-
-------------------------------------------------------------------------
--- single-character replacement, for locale-aware decimal points
-------------------------------------------------------------------------
-function luaX:buffreplace(ls, from, to)
-	local result, buff = "", ls.buff
-	for p = 1, #buff do
-		local c = string.sub(buff, p, p)
-		if c == from then
-			c = to
-		end
-		result = result .. c
-	end
-	ls.buff = result
-end
-
-------------------------------------------------------------------------
--- Attempt to convert a number by translating '.' decimal points to
--- the decimal point character used by the current locale. This is not
--- needed in Yueliang as Lua's tonumber() is already locale-aware.
--- Instead, the code is here in case the user implements localeconv().
-------------------------------------------------------------------------
-function luaX:trydecpoint(ls, Token)
-	-- format error: try to update decimal point separator
-	local old = ls.decpoint
-	-- translate the following to Lua if you implement localeconv():
-	-- struct lconv *cv = localeconv();
-	-- ls->decpoint = (cv ? cv->decimal_point[0] : '.');
-	self:buffreplace(ls, old, ls.decpoint) -- try updated decimal separator
-	local seminfo = self:str2d(ls.buff)
-	Token.seminfo = seminfo
-	if not seminfo then
-		-- format error with correct decimal point: no more options
-		self:buffreplace(ls, ls.decpoint, ".") -- undo change (for error message)
-		self:lexerror(ls, "malformed number", "TK_NUMBER")
-	end
-end
-
-------------------------------------------------------------------------
--- main number conversion function
--- * "^%w$" needed in the scan in order to detect "EOZ"
-------------------------------------------------------------------------
-function luaX:read_numeral(ls, Token)
-	-- lua_assert(string.find(ls.current, "%d"))
-	repeat
-		self:save_and_next(ls)
-	until string.find(ls.current, "%D") and ls.current ~= "."
-	if self:check_next(ls, "Ee") then -- 'E'?
-		self:check_next(ls, "+-") -- optional exponent sign
-	end
-	while string.find(ls.current, "^%w$") or ls.current == "_" do
-		self:save_and_next(ls)
-	end
-	self:buffreplace(ls, ".", ls.decpoint) -- follow locale for decimal point
-	local seminfo = self:str2d(ls.buff)
-	Token.seminfo = seminfo
-	if not seminfo then -- format error?
-		self:trydecpoint(ls, Token) -- try to update decimal point separator
-	end
-end
-
-------------------------------------------------------------------------
--- count separators ("=") in a long string delimiter
--- * used by luaX:read_long_string
-------------------------------------------------------------------------
-function luaX:skip_sep(ls)
-	local count = 0
-	local s = ls.current
-	-- lua_assert(s == "[" or s == "]")
-	self:save_and_next(ls)
-	while ls.current == "=" do
-		self:save_and_next(ls)
-		count = count + 1
-	end
-	return (ls.current == s) and count or -count - 1
-end
-
-------------------------------------------------------------------------
--- reads a long string or long comment
-------------------------------------------------------------------------
-function luaX:read_long_string(ls, Token, sep)
-	local cont = 0
-	self:save_and_next(ls) -- skip 2nd '['
-	if self:currIsNewline(ls) then -- string starts with a newline?
-		self:inclinenumber(ls) -- skip it
-	end
-	while true do
-		local c = ls.current
-		if c == "EOZ" then
-			self:lexerror(ls, Token and "unfinished long string" or "unfinished long comment", "TK_EOS")
-		elseif c == "[" then
-			--# compatibility code start
-			if self.LUA_COMPAT_LSTR then
-				if self:skip_sep(ls) == sep then
-					self:save_and_next(ls) -- skip 2nd '['
-					cont = cont + 1
-					--# compatibility code start
-					if self.LUA_COMPAT_LSTR == 1 then
-						if sep == 0 then
-							self:lexerror(ls, "nesting of [[...]] is deprecated", "[")
-						end
-					end
-					--# compatibility code end
-				end
-			end
-			--# compatibility code end
-		elseif c == "]" then
-			if self:skip_sep(ls) == sep then
-				self:save_and_next(ls) -- skip 2nd ']'
-				--# compatibility code start
-				if self.LUA_COMPAT_LSTR and self.LUA_COMPAT_LSTR == 2 then
-					cont = cont - 1
-					if sep == 0 and cont >= 0 then
-						break
-					end
-				end
-				--# compatibility code end
-				break
-			end
-		elseif self:currIsNewline(ls) then
-			self:save(ls, "\n")
-			self:inclinenumber(ls)
-			if not Token then
-				ls.buff = ""
-			end -- avoid wasting space
-		else -- default
-			if Token then
-				self:save_and_next(ls)
-			else
-				self:nextc(ls)
-			end
-		end --if c
-	end --while
-	if Token then
-		local p = 3 + sep
-		Token.seminfo = string.sub(ls.buff, p, -p)
-	end
-end
-
-------------------------------------------------------------------------
--- reads a string
--- * has been restructured significantly compared to the original C code
-------------------------------------------------------------------------
-
-function luaX:read_string(ls, del, Token)
-	self:save_and_next(ls)
-	while ls.current ~= del do
-		local c = ls.current
-		if c == "EOZ" then
-			self:lexerror(ls, "unfinished string", "TK_EOS")
-		elseif self:currIsNewline(ls) then
-			self:lexerror(ls, "unfinished string", "TK_STRING")
-		elseif c == "\\" then
-			c = self:nextc(ls) -- do not save the '\'
-			if self:currIsNewline(ls) then -- go through
-				self:save(ls, "\n")
-				self:inclinenumber(ls)
-			elseif c ~= "EOZ" then -- will raise an error next loop
-				-- escapes handling greatly simplified here:
-				local i = string.find("abfnrtv", c, 1, 1)
-				if i then
-					self:save(ls, string.sub("\a\b\f\n\r\t\v", i, i))
-					self:nextc(ls)
-				elseif not string.find(c, "%d") then
-					self:save_and_next(ls) -- handles \\, \", \', and \?
-				else -- \xxx
-					c, i = 0, 0
-					repeat
-						c = 10 * c + ls.current
-						self:nextc(ls)
-						i = i + 1
-					until i >= 3 or not string.find(ls.current, "%d")
-					if c > 255 then -- UCHAR_MAX
-						self:lexerror(ls, "escape sequence too large", "TK_STRING")
-					end
-					self:save(ls, string.char(c))
-				end
-			end
-		else
-			self:save_and_next(ls)
-		end --if c
-	end --while
-	self:save_and_next(ls) -- skip delimiter
-	Token.seminfo = string.sub(ls.buff, 2, -2)
-end
-
-------------------------------------------------------------------------
--- main lexer function
-------------------------------------------------------------------------
-function luaX:llex(ls, Token)
-	ls.buff = ""
-	while true do
-		local c = ls.current
-		----------------------------------------------------------------
-		if self:currIsNewline(ls) then
-			self:inclinenumber(ls)
-			----------------------------------------------------------------
-		elseif c == "-" then
-			c = self:nextc(ls)
-			if c ~= "-" then
-				return "-"
-			end
-			-- else is a comment
-			local sep = -1
-			if self:nextc(ls) == "[" then
-				sep = self:skip_sep(ls)
-				ls.buff = "" -- 'skip_sep' may dirty the buffer
-			end
-			if sep >= 0 then
-				self:read_long_string(ls, nil, sep) -- long comment
-				ls.buff = ""
-			else -- else short comment
-				while not self:currIsNewline(ls) and ls.current ~= "EOZ" do
-					self:nextc(ls)
-				end
-			end
-			----------------------------------------------------------------
-		elseif c == "[" then
-			local sep = self:skip_sep(ls)
-			if sep >= 0 then
-				self:read_long_string(ls, Token, sep)
-				return "TK_STRING"
-			elseif sep == -1 then
-				return "["
-			else
-				self:lexerror(ls, "invalid long string delimiter", "TK_STRING")
-			end
-			----------------------------------------------------------------
-		elseif c == "=" then
-			c = self:nextc(ls)
-			if c ~= "=" then
-				return "="
-			else
-				self:nextc(ls)
-				return "TK_EQ"
-			end
-			----------------------------------------------------------------
-		elseif c == "<" then
-			c = self:nextc(ls)
-			if c ~= "=" then
-				return "<"
-			else
-				self:nextc(ls)
-				return "TK_LE"
-			end
-			----------------------------------------------------------------
-		elseif c == ">" then
-			c = self:nextc(ls)
-			if c ~= "=" then
-				return ">"
-			else
-				self:nextc(ls)
-				return "TK_GE"
-			end
-			----------------------------------------------------------------
-		elseif c == "~" then
-			c = self:nextc(ls)
-			if c ~= "=" then
-				return "~"
-			else
-				self:nextc(ls)
-				return "TK_NE"
-			end
-			----------------------------------------------------------------
-		elseif c == '"' or c == "'" then
-			self:read_string(ls, c, Token)
-			return "TK_STRING"
-			----------------------------------------------------------------
-		elseif c == "." then
-			c = self:save_and_next(ls)
-			if self:check_next(ls, ".") then
-				if self:check_next(ls, ".") then
-					return "TK_DOTS" -- ...
-				else
-					return "TK_CONCAT" -- ..
-				end
-			elseif not string.find(c, "%d") then
-				return "."
-			else
-				self:read_numeral(ls, Token)
-				return "TK_NUMBER"
-			end
-			----------------------------------------------------------------
-		elseif c == "EOZ" then
-			return "TK_EOS"
-			----------------------------------------------------------------
-		else -- default
-			if string.find(c, "%s") then
-				-- lua_assert(self:currIsNewline(ls))
-				self:nextc(ls)
-			elseif string.find(c, "%d") then
-				self:read_numeral(ls, Token)
-				return "TK_NUMBER"
-			elseif string.find(c, "[_%a]") then
-				-- identifier or reserved word
-				repeat
-					c = self:save_and_next(ls)
-				until c == "EOZ" or not string.find(c, "[_%w]")
-				local ts = ls.buff
-				local tok = self.enums[ts]
-				if tok then
-					return tok
-				end -- reserved word?
-				Token.seminfo = ts
-				return "TK_NAME"
-			else
-				self:nextc(ls)
-				return c -- single-char tokens (+ - / ...)
-			end
-			----------------------------------------------------------------
-		end --if c
-	end --while
-end
-
---dofile("lopcodes.lua")
-
---[[
-===========================================================================
-	We assume that instructions are unsigned numbers.
-	All instructions have an opcode in the first 6 bits.
-	Instructions can have the following fields:
-				'A' : 8 bits
-				'B' : 9 bits
-				'C' : 9 bits
-				'Bx' : 18 bits ('B' and 'C' together)
-				'sBx' : signed Bx
-
-	A signed argument is represented in excess K; that is, the number
-	value is the unsigned value minus K. K is exactly the maximum value
-	for that argument (so that -max is represented by 0, and +max is
-	represented by 2*max), which is half the maximum for the corresponding
-	unsigned argument.
-===========================================================================
---]]
-
-luaP.OpMode = { iABC = 0, iABx = 1, iAsBx = 2 } -- basic instruction format
-
-------------------------------------------------------------------------
--- size and position of opcode arguments.
--- * WARNING size and position is hard-coded elsewhere in this script
-------------------------------------------------------------------------
-luaP.SIZE_C = 9
-luaP.SIZE_B = 9
-luaP.SIZE_Bx = luaP.SIZE_C + luaP.SIZE_B
-luaP.SIZE_A = 8
-
-luaP.SIZE_OP = 6
-
-luaP.POS_OP = 0
-luaP.POS_A = luaP.POS_OP + luaP.SIZE_OP
-luaP.POS_C = luaP.POS_A + luaP.SIZE_A
-luaP.POS_B = luaP.POS_C + luaP.SIZE_C
-luaP.POS_Bx = luaP.POS_C
-
-------------------------------------------------------------------------
--- limits for opcode arguments.
--- we use (signed) int to manipulate most arguments,
--- so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
-------------------------------------------------------------------------
--- removed "#if SIZE_Bx < BITS_INT-1" test, assume this script is
--- running on a Lua VM with double or int as LUA_NUMBER
-
-luaP.MAXARG_Bx = math.ldexp(1, luaP.SIZE_Bx) - 1
-luaP.MAXARG_sBx = math.floor(luaP.MAXARG_Bx / 2) -- 'sBx' is signed
-
-luaP.MAXARG_A = math.ldexp(1, luaP.SIZE_A) - 1
-luaP.MAXARG_B = math.ldexp(1, luaP.SIZE_B) - 1
-luaP.MAXARG_C = math.ldexp(1, luaP.SIZE_C) - 1
-
--- creates a mask with 'n' 1 bits at position 'p'
--- MASK1(n,p) deleted, not required
--- creates a mask with 'n' 0 bits at position 'p'
--- MASK0(n,p) deleted, not required
-
---[[--------------------------------------------------------------------
-	Visual representation for reference:
-
-	 31    |    |     |            0      bit position
-		+-----+-----+-----+----------+
-		|  B  |  C  |  A  |  Opcode  |      iABC format
-		+-----+-----+-----+----------+
-		-  9  -  9  -  8  -    6     -      field sizes
-		+-----+-----+-----+----------+
-		|   [s]Bx   |  A  |  Opcode  |      iABx | iAsBx format
-		+-----+-----+-----+----------+
-
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- the following macros help to manipulate instructions
--- * changed to a table object representation, very clean compared to
---   the [nightmare] alternatives of using a number or a string
--- * Bx is a separate element from B and C, since there is never a need
---   to split Bx in the parser or code generator
-------------------------------------------------------------------------
-
--- these accept or return opcodes in the form of string names
-function luaP:GET_OPCODE(i)
-	return self.ROpCode[i.OP]
-end
-function luaP:SET_OPCODE(i, o)
-	i.OP = self.OpCode[o]
-end
-
-function luaP:GETARG_A(i)
-	return i.A
-end
-function luaP:SETARG_A(i, u)
-	i.A = u
-end
-
-function luaP:GETARG_B(i)
-	return i.B
-end
-function luaP:SETARG_B(i, b)
-	i.B = b
-end
-
-function luaP:GETARG_C(i)
-	return i.C
-end
-function luaP:SETARG_C(i, b)
-	i.C = b
-end
-
-function luaP:GETARG_Bx(i)
-	return i.Bx
-end
-function luaP:SETARG_Bx(i, b)
-	i.Bx = b
-end
-
-function luaP:GETARG_sBx(i)
-	return i.Bx - self.MAXARG_sBx
-end
-function luaP:SETARG_sBx(i, b)
-	i.Bx = b + self.MAXARG_sBx
-end
-
-function luaP:CREATE_ABC(o, a, b, c)
-	return { OP = self.OpCode[o], A = a, B = b, C = c }
-end
-
-function luaP:CREATE_ABx(o, a, bc)
-	return { OP = self.OpCode[o], A = a, Bx = bc }
-end
-
-------------------------------------------------------------------------
--- create an instruction from a number (for OP_SETLIST)
-------------------------------------------------------------------------
-function luaP:CREATE_Inst(c)
-	local o = c % 64
-	c = (c - o) / 64
-	local a = c % 256
-	c = (c - a) / 256
-	return self:CREATE_ABx(o, a, c)
-end
-
-------------------------------------------------------------------------
--- returns a 4-char string little-endian encoded form of an instruction
-------------------------------------------------------------------------
-function luaP:Instruction(i)
-	if i.Bx then
-		-- change to OP/A/B/C format
-		i.C = i.Bx % 512
-		i.B = (i.Bx - i.C) / 512
-	end
-	local I = i.A * 64 + i.OP
-	local c0 = I % 256
-	I = i.C * 64 + (I - c0) / 256 -- 6 bits of A left
-	local c1 = I % 256
-	I = i.B * 128 + (I - c1) / 256 -- 7 bits of C left
-	local c2 = I % 256
-	local c3 = (I - c2) / 256
-	return string.char(c0, c1, c2, c3)
-end
-
-------------------------------------------------------------------------
--- decodes a 4-char little-endian string into an instruction struct
-------------------------------------------------------------------------
-function luaP:DecodeInst(x)
-	local byte = string.byte
-	local i = {}
-	local I = byte(x, 1)
-	local op = I % 64
-	i.OP = op
-	I = byte(x, 2) * 4 + (I - op) / 64 -- 2 bits of c0 left
-	local a = I % 256
-	i.A = a
-	I = byte(x, 3) * 4 + (I - a) / 256 -- 2 bits of c1 left
-	local c = I % 512
-	i.C = c
-	i.B = byte(x, 4) * 2 + (I - c) / 512 -- 1 bits of c2 left
-	local opmode = self.OpMode[tonumber(string.sub(self.opmodes[op + 1], 7, 7))]
-	if opmode ~= "iABC" then
-		i.Bx = i.B * 512 + i.C
-	end
-	return i
-end
-
-------------------------------------------------------------------------
--- Macros to operate RK indices
--- * these use arithmetic instead of bit ops
-------------------------------------------------------------------------
-
--- this bit 1 means constant (0 means register)
-luaP.BITRK = math.ldexp(1, luaP.SIZE_B - 1)
-
--- test whether value is a constant
-function luaP:ISK(x)
-	return x >= self.BITRK
-end
-
--- gets the index of the constant
-function luaP:INDEXK(r)
-	return x - self.BITRK
-end
-
-luaP.MAXINDEXRK = luaP.BITRK - 1
-
--- code a constant index as a RK value
-function luaP:RKASK(x)
-	return x + self.BITRK
-end
-
-------------------------------------------------------------------------
--- invalid register that fits in 8 bits
-------------------------------------------------------------------------
-luaP.NO_REG = luaP.MAXARG_A
-
-------------------------------------------------------------------------
--- R(x) - register
--- Kst(x) - constant (in constant table)
--- RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
-------------------------------------------------------------------------
-
-------------------------------------------------------------------------
--- grep "ORDER OP" if you change these enums
-------------------------------------------------------------------------
-
---[[--------------------------------------------------------------------
-Lua virtual machine opcodes (enum OpCode):
-------------------------------------------------------------------------
-name          args    description
-------------------------------------------------------------------------
-OP_MOVE       A B     R(A) := R(B)
-OP_LOADK      A Bx    R(A) := Kst(Bx)
-OP_LOADBOOL   A B C   R(A) := (Bool)B; if (C) pc++
-OP_LOADNIL    A B     R(A) := ... := R(B) := nil
-OP_GETUPVAL   A B     R(A) := UpValue[B]
-OP_GETGLOBAL  A Bx    R(A) := Gbl[Kst(Bx)]
-OP_GETTABLE   A B C   R(A) := R(B)[RK(C)]
-OP_SETGLOBAL  A Bx    Gbl[Kst(Bx)] := R(A)
-OP_SETUPVAL   A B     UpValue[B] := R(A)
-OP_SETTABLE   A B C   R(A)[RK(B)] := RK(C)
-OP_NEWTABLE   A B C   R(A) := {} (size = B,C)
-OP_SELF       A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]
-OP_ADD        A B C   R(A) := RK(B) + RK(C)
-OP_SUB        A B C   R(A) := RK(B) - RK(C)
-OP_MUL        A B C   R(A) := RK(B) * RK(C)
-OP_DIV        A B C   R(A) := RK(B) / RK(C)
-OP_MOD        A B C   R(A) := RK(B) % RK(C)
-OP_POW        A B C   R(A) := RK(B) ^ RK(C)
-OP_UNM        A B     R(A) := -R(B)
-OP_NOT        A B     R(A) := not R(B)
-OP_LEN        A B     R(A) := length of R(B)
-OP_CONCAT     A B C   R(A) := R(B).. ... ..R(C)
-OP_JMP        sBx     pc+=sBx
-OP_EQ         A B C   if ((RK(B) == RK(C)) ~= A) then pc++
-OP_LT         A B C   if ((RK(B) <  RK(C)) ~= A) then pc++
-OP_LE         A B C   if ((RK(B) <= RK(C)) ~= A) then pc++
-OP_TEST       A C     if not (R(A) <=> C) then pc++
-OP_TESTSET    A B C   if (R(B) <=> C) then R(A) := R(B) else pc++
-OP_CALL       A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1))
-OP_TAILCALL   A B C   return R(A)(R(A+1), ... ,R(A+B-1))
-OP_RETURN     A B     return R(A), ... ,R(A+B-2)  (see note)
-OP_FORLOOP    A sBx   R(A)+=R(A+2);
-											if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }
-OP_FORPREP    A sBx   R(A)-=R(A+2); pc+=sBx
-OP_TFORLOOP   A C     R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));
-											if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++
-OP_SETLIST    A B C   R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B
-OP_CLOSE      A       close all variables in the stack up to (>=) R(A)
-OP_CLOSURE    A Bx    R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))
-OP_VARARG     A B     R(A), R(A+1), ..., R(A+B-1) = vararg
-----------------------------------------------------------------------]]
-
-luaP.opnames = {} -- opcode names
-luaP.OpCode = {} -- lookup name -> number
-luaP.ROpCode = {} -- lookup number -> name
-
-------------------------------------------------------------------------
--- ORDER OP
-------------------------------------------------------------------------
-local i = 0
-for v in
-	string.gmatch(
-		[[
-MOVE LOADK LOADBOOL LOADNIL GETUPVAL
-GETGLOBAL GETTABLE SETGLOBAL SETUPVAL SETTABLE
-NEWTABLE SELF ADD SUB MUL
-DIV MOD POW UNM NOT
-LEN CONCAT JMP EQ LT
-LE TEST TESTSET CALL TAILCALL
-RETURN FORLOOP FORPREP TFORLOOP SETLIST
-CLOSE CLOSURE VARARG
-]],
-		"%S+"
-	)
-do
-	local n = "OP_" .. v
-	luaP.opnames[i] = v
-	luaP.OpCode[n] = i
-	luaP.ROpCode[i] = n
-	i = i + 1
-end
-luaP.NUM_OPCODES = i
-
---[[
-===========================================================================
-	Notes:
-	(*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
-			and can be 0: OP_CALL then sets 'top' to last_result+1, so
-			next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use 'top'.
-	(*) In OP_VARARG, if (B == 0) then use actual number of varargs and
-			set top (like in OP_CALL with C == 0).
-	(*) In OP_RETURN, if (B == 0) then return up to 'top'
-	(*) In OP_SETLIST, if (B == 0) then B = 'top';
-			if (C == 0) then next 'instruction' is real C
-	(*) For comparisons, A specifies what condition the test should accept
-			(true or false).
-	(*) All 'skips' (pc++) assume that next instruction is a jump
-===========================================================================
---]]
-
---[[--------------------------------------------------------------------
-	masks for instruction properties. The format is:
-	bits 0-1: op mode
-	bits 2-3: C arg mode
-	bits 4-5: B arg mode
-	bit 6: instruction set register A
-	bit 7: operator is a test
-
-	for OpArgMask:
-	OpArgN - argument is not used
-	OpArgU - argument is used
-	OpArgR - argument is a register or a jump offset
-	OpArgK - argument is a constant or register/constant
-----------------------------------------------------------------------]]
-
--- was enum OpArgMask
-luaP.OpArgMask = { OpArgN = 0, OpArgU = 1, OpArgR = 2, OpArgK = 3 }
-
-------------------------------------------------------------------------
--- e.g. to compare with symbols, luaP:getOpMode(...) == luaP.OpCode.iABC
--- * accepts opcode parameter as strings, e.g. "OP_MOVE"
-------------------------------------------------------------------------
-
-function luaP:getOpMode(m)
-	return self.opmodes[self.OpCode[m]] % 4
-end
-
-function luaP:getBMode(m)
-	return math.floor(self.opmodes[self.OpCode[m]] / 16) % 4
-end
-
-function luaP:getCMode(m)
-	return math.floor(self.opmodes[self.OpCode[m]] / 4) % 4
-end
-
-function luaP:testAMode(m)
-	return math.floor(self.opmodes[self.OpCode[m]] / 64) % 2
-end
-
-function luaP:testTMode(m)
-	return math.floor(self.opmodes[self.OpCode[m]] / 128)
-end
-
--- luaP_opnames[] is set above, as the luaP.opnames table
-
--- number of list items to accumulate before a SETLIST instruction
-luaP.LFIELDS_PER_FLUSH = 50
-
-------------------------------------------------------------------------
--- build instruction properties array
--- * deliberately coded to look like the C equivalent
-------------------------------------------------------------------------
-local function opmode(t, a, b, c, m)
-	local luaP = luaP
-	return t * 128 + a * 64 + luaP.OpArgMask[b] * 16 + luaP.OpArgMask[c] * 4 + luaP.OpMode[m]
-end
-
--- ORDER OP
-luaP.opmodes = {
-	-- T A B C mode opcode
-	opmode(0, 1, "OpArgK", "OpArgN", "iABx"), -- OP_LOADK
-	opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_LOADBOOL
-	opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_LOADNIL
-	opmode(0, 1, "OpArgU", "OpArgN", "iABC"), -- OP_GETUPVAL
-	opmode(0, 1, "OpArgK", "OpArgN", "iABx"), -- OP_GETGLOBAL
-	opmode(0, 1, "OpArgR", "OpArgK", "iABC"), -- OP_GETTABLE
-	opmode(0, 0, "OpArgK", "OpArgN", "iABx"), -- OP_SETGLOBAL
-	opmode(0, 0, "OpArgU", "OpArgN", "iABC"), -- OP_SETUPVAL
-	opmode(0, 0, "OpArgK", "OpArgK", "iABC"), -- OP_SETTABLE
-	opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_NEWTABLE
-	opmode(0, 1, "OpArgR", "OpArgK", "iABC"), -- OP_SELF
-	opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_ADD
-	opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_SUB
-	opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_MUL
-	opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_DIV
-	opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_MOD
-	opmode(0, 1, "OpArgK", "OpArgK", "iABC"), -- OP_POW
-	opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_UNM
-	opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_NOT
-	opmode(0, 1, "OpArgR", "OpArgN", "iABC"), -- OP_LEN
-	opmode(0, 1, "OpArgR", "OpArgR", "iABC"), -- OP_CONCAT
-	opmode(0, 0, "OpArgR", "OpArgN", "iAsBx"), -- OP_JMP
-	opmode(1, 0, "OpArgK", "OpArgK", "iABC"), -- OP_EQ
-	opmode(1, 0, "OpArgK", "OpArgK", "iABC"), -- OP_LT
-	opmode(1, 0, "OpArgK", "OpArgK", "iABC"), -- OP_LE
-	opmode(1, 1, "OpArgR", "OpArgU", "iABC"), -- OP_TEST
-	opmode(1, 1, "OpArgR", "OpArgU", "iABC"), -- OP_TESTSET
-	opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_CALL
-	opmode(0, 1, "OpArgU", "OpArgU", "iABC"), -- OP_TAILCALL
-	opmode(0, 0, "OpArgU", "OpArgN", "iABC"), -- OP_RETURN
-	opmode(0, 1, "OpArgR", "OpArgN", "iAsBx"), -- OP_FORLOOP
-	opmode(0, 1, "OpArgR", "OpArgN", "iAsBx"), -- OP_FORPREP
-	opmode(1, 0, "OpArgN", "OpArgU", "iABC"), -- OP_TFORLOOP
-	opmode(0, 0, "OpArgU", "OpArgU", "iABC"), -- OP_SETLIST
-	opmode(0, 0, "OpArgN", "OpArgN", "iABC"), -- OP_CLOSE
-	opmode(0, 1, "OpArgU", "OpArgN", "iABx"), -- OP_CLOSURE
-	opmode(0, 1, "OpArgU", "OpArgN", "iABC"), -- OP_VARARG
-}
--- an awkward way to set a zero-indexed table...
-luaP.opmodes[0] = opmode(0, 1, "OpArgR", "OpArgN", "iABC") -- OP_MOVE
-
---dofile("ldump.lua")
-
---requires luaP
-
--- mark for precompiled code ('<esc>Lua') (from lua.h)
-luaU.LUA_SIGNATURE = "\27Lua"
-
--- constants used by dumper (from lua.h)
-luaU.LUA_TNUMBER = 3
-luaU.LUA_TSTRING = 4
-luaU.LUA_TNIL = 0
-luaU.LUA_TBOOLEAN = 1
-luaU.LUA_TNONE = -1
-
--- constants for header of binary files (from lundump.h)
-luaU.LUAC_VERSION = 0x51 -- this is Lua 5.1
-luaU.LUAC_FORMAT = 0 -- this is the official format
-luaU.LUAC_HEADERSIZE = 12 -- size of header of binary files
-
---[[--------------------------------------------------------------------
--- Additional functions to handle chunk writing
--- * to use make_setS and make_setF, see test_ldump.lua elsewhere
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- create a chunk writer that writes to a string
--- * returns the writer function and a table containing the string
--- * to get the final result, look in buff.data
-------------------------------------------------------------------------
-function luaU:make_setS()
-	local buff = {}
-	buff.data = ""
-	local writer = function(s, buff) -- chunk writer
-		if not s then
-			return 0
-		end
-		buff.data = buff.data .. s
-		-- print (#buff.data, #s, string.byte(s,1,1), s)
-		return 0
-	end
-	return writer, buff
-end
-
-------------------------------------------------------------------------
--- create a chunk writer that writes to a file
--- * returns the writer function and a table containing the file handle
--- * if a nil is passed, then writer should close the open file
-------------------------------------------------------------------------
-function luaU:make_setF(filename)
-	local buff = {}
-	buff.h = io.open(filename, "wb")
-	if not buff.h then
-		return nil
-	end
-	local writer = function(s, buff) -- chunk writer
-		if not buff.h then
-			return 0
-		end
-		if not s then
-			if buff.h:close() then
-				return 0
-			end
-		else
-			if buff.h:write(s) then
-				return 0
-			end
-		end
-		return 1
-	end
-	return writer, buff
-end
-
-------------------------------------------------------------------------
--- works like the lobject.h version except that TObject used in these
--- scripts only has a 'value' field, no 'tt' field (native types used)
-------------------------------------------------------------------------
-function luaU:ttype(o)
-	local tt = type(o.value)
-	if tt == "number" then
-		return self.LUA_TNUMBER
-	elseif tt == "string" then
-		return self.LUA_TSTRING
-	elseif tt == "nil" then
-		return self.LUA_TNIL
-	elseif tt == "boolean" then
-		return self.LUA_TBOOLEAN
-	else
-		return self.LUA_TNONE -- the rest should not appear
-	end
-end
-
------------------------------------------------------------------------
--- converts a IEEE754 double number to an 8-byte little-endian string
--- * luaU:from_double() and luaU:from_int() are adapted from ChunkBake
--- * supports +/- Infinity, but not denormals or NaNs
------------------------------------------------------------------------
-function luaU:from_double(x)
-	local function grab_byte(v)
-		local c = v % 256
-		return (v - c) / 256, string.char(c)
-	end
-	local sign = 0
-	if x < 0 then
-		sign = 1
-		x = -x
-	end
-	local mantissa, exponent = math.frexp(x)
-	if x == 0 then -- zero
-		mantissa, exponent = 0, 0
-	elseif x == 1 / 0 then
-		mantissa, exponent = 0, 2047
-	else
-		mantissa = (mantissa * 2 - 1) * math.ldexp(0.5, 53)
-		exponent = exponent + 1022
-	end
-	local v, byte = "" -- convert to bytes
-	x = math.floor(mantissa)
-	for i = 1, 6 do
-		x, byte = grab_byte(x)
-		v = v .. byte -- 47:0
-	end
-	x, byte = grab_byte(exponent * 16 + x)
-	v = v .. byte -- 55:48
-	x, byte = grab_byte(sign * 128 + x)
-	v = v .. byte -- 63:56
-	return v
-end
-
------------------------------------------------------------------------
--- converts a number to a little-endian 32-bit integer string
--- * input value assumed to not overflow, can be signed/unsigned
------------------------------------------------------------------------
-function luaU:from_int(x)
-	local v = ""
-	x = math.floor(x)
-	if x < 0 then
-		x = 4294967296 + x
-	end -- ULONG_MAX+1
-	for i = 1, 4 do
-		local c = x % 256
-		v = v .. string.char(c)
-		x = math.floor(x / 256)
-	end
-	return v
-end
-
---[[--------------------------------------------------------------------
--- Functions to make a binary chunk
--- * many functions have the size parameter removed, since output is
---   in the form of a string and some sizes are implicit or hard-coded
-----------------------------------------------------------------------]]
-
---[[--------------------------------------------------------------------
--- struct DumpState:
---   L  -- lua_State (not used in this script)
---   writer  -- lua_Writer (chunk writer function)
---   data  -- void* (chunk writer context or data already written)
---   strip  -- if true, don't write any debug information
---   status  -- if non-zero, an error has occured
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- dumps a block of bytes
--- * lua_unlock(D.L), lua_lock(D.L) unused
-------------------------------------------------------------------------
-function luaU:DumpBlock(b, D)
-	if D.status == 0 then
-		-- lua_unlock(D->L);
-		D.status = D.write(b, D.data)
-		-- lua_lock(D->L);
-	end
-end
-
-------------------------------------------------------------------------
--- dumps a char
-------------------------------------------------------------------------
-function luaU:DumpChar(y, D)
-	self:DumpBlock(string.char(y), D)
-end
-
-------------------------------------------------------------------------
--- dumps a 32-bit signed or unsigned integer (for int) (hard-coded)
-------------------------------------------------------------------------
-function luaU:DumpInt(x, D)
-	self:DumpBlock(self:from_int(x), D)
-end
-
-------------------------------------------------------------------------
--- dumps a 32-bit signed or unsigned integer (for int) (hard-coded)
-------------------------------------------------------------------------
-function luaU:DumpSizeT(x, D)
-	self:DumpBlock(self:from_int(x), D)
-	if size_size_t == 8 then
-		self:DumpBlock(self:from_int(0), D)
-	end
-end
-
-------------------------------------------------------------------------
--- dumps a lua_Number (hard-coded as a double)
-------------------------------------------------------------------------
-function luaU:DumpNumber(x, D)
-	self:DumpBlock(self:from_double(x), D)
-end
-
-------------------------------------------------------------------------
--- dumps a Lua string (size type is hard-coded)
-------------------------------------------------------------------------
-function luaU:DumpString(s, D)
-	if s == nil then
-		self:DumpSizeT(0, D)
-	else
-		s = s .. "\0" -- include trailing '\0'
-		self:DumpSizeT(#s, D)
-		self:DumpBlock(s, D)
-	end
-end
-
-------------------------------------------------------------------------
--- dumps instruction block from function prototype
-------------------------------------------------------------------------
-function luaU:DumpCode(f, D)
-	local n = f.sizecode
-	--was DumpVector
-	self:DumpInt(n, D)
-	for i = 0, n - 1 do
-		self:DumpBlock(luaP:Instruction(f.code[i]), D)
-	end
-end
-
-------------------------------------------------------------------------
--- dump constant pool from function prototype
--- * bvalue(o), nvalue(o) and rawtsvalue(o) macros removed
-------------------------------------------------------------------------
-function luaU:DumpConstants(f, D)
-	local n = f.sizek
-	self:DumpInt(n, D)
-	for i = 0, n - 1 do
-		local o = f.k[i] -- TValue
-		local tt = self:ttype(o)
-		self:DumpChar(tt, D)
-		if tt == self.LUA_TNIL then
-		elseif tt == self.LUA_TBOOLEAN then
-			self:DumpChar(o.value and 1 or 0, D)
-		elseif tt == self.LUA_TNUMBER then
-			self:DumpNumber(o.value, D)
-		elseif tt == self.LUA_TSTRING then
-			self:DumpString(o.value, D)
-		else
-			--lua_assert(0)  -- cannot happen
-		end
-	end
-	n = f.sizep
-	self:DumpInt(n, D)
-	for i = 0, n - 1 do
-		self:DumpFunction(f.p[i], f.source, D)
-	end
-end
-
-------------------------------------------------------------------------
--- dump debug information
-------------------------------------------------------------------------
-function luaU:DumpDebug(f, D)
-	local n
-	n = D.strip and 0 or f.sizelineinfo -- dump line information
-	--was DumpVector
-	self:DumpInt(n, D)
-	for i = 0, n - 1 do
-		self:DumpInt(f.lineinfo[i], D)
-	end
-	n = D.strip and 0 or f.sizelocvars -- dump local information
-	self:DumpInt(n, D)
-	for i = 0, n - 1 do
-		self:DumpString(f.locvars[i].varname, D)
-		self:DumpInt(f.locvars[i].startpc, D)
-		self:DumpInt(f.locvars[i].endpc, D)
-	end
-	n = D.strip and 0 or f.sizeupvalues -- dump upvalue information
-	self:DumpInt(n, D)
-	for i = 0, n - 1 do
-		self:DumpString(f.upvalues[i], D)
-	end
-end
-
-------------------------------------------------------------------------
--- dump child function prototypes from function prototype
-------------------------------------------------------------------------
-function luaU:DumpFunction(f, p, D)
-	local source = f.source
-	if source == p or D.strip then
-		source = nil
-	end
-	self:DumpString(source, D)
-	self:DumpInt(f.lineDefined, D)
-	self:DumpInt(f.lastlinedefined, D)
-	self:DumpChar(f.nups, D)
-	self:DumpChar(f.numparams, D)
-	self:DumpChar(f.is_vararg, D)
-	self:DumpChar(f.maxstacksize, D)
-	self:DumpCode(f, D)
-	self:DumpConstants(f, D)
-	self:DumpDebug(f, D)
-end
-
-------------------------------------------------------------------------
--- dump Lua header section (some sizes hard-coded)
-------------------------------------------------------------------------
-function luaU:DumpHeader(D)
-	local h = self:header()
-	assert(#h == self.LUAC_HEADERSIZE) -- fixed buffer now an assert
-	self:DumpBlock(h, D)
-end
-
-------------------------------------------------------------------------
--- make header (from lundump.c)
--- returns the header string
-------------------------------------------------------------------------
-function luaU:header()
-	local x = 1
-	return self.LUA_SIGNATURE
-		.. string.char(
-			self.LUAC_VERSION,
-			self.LUAC_FORMAT,
-			x, -- endianness (1=little)
-			4, -- sizeof(int)
-			size_size_t, -- sizeof(size_t)
-			4, -- sizeof(Instruction)
-			8, -- sizeof(lua_Number)
-			0
-		) -- is lua_Number integral?
-end
-
-------------------------------------------------------------------------
--- dump Lua function as precompiled chunk
--- (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
--- * w, data are created from make_setS, make_setF
-------------------------------------------------------------------------
-function luaU:dump(L, f, w, data, strip)
-	local D = {} -- DumpState
-	D.L = L
-	D.write = w
-	D.data = data
-	D.strip = strip
-	D.status = 0
-	self:DumpHeader(D)
-	self:DumpFunction(f, nil, D)
-	-- added: for a chunk writer writing to a file, this final call with
-	-- nil data is to indicate to the writer to close the file
-	D.write(nil, D.data)
-	return D.status
-end
-
---dofile("lcode.lua")
-
-------------------------------------------------------------------------
--- constants used by code generator
-------------------------------------------------------------------------
--- maximum stack for a Lua function
-luaK.MAXSTACK = 250 -- (from llimits.h)
-
---[[--------------------------------------------------------------------
--- other functions
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- emulation of TValue macros (these are from lobject.h)
--- * TValue is a table since lcode passes references around
--- * tt member field removed, using Lua's type() instead
--- * for setsvalue, sethvalue, parameter L (deleted here) in lobject.h
---   is used in an assert for testing, see checkliveness(g,obj)
-------------------------------------------------------------------------
-function luaK:ttisnumber(o)
-	if o then
-		return type(o.value) == "number"
-	else
-		return false
-	end
-end
-function luaK:nvalue(o)
-	return o.value
-end
-function luaK:setnilvalue(o)
-	o.value = nil
-end
-function luaK:setsvalue(o, x)
-	o.value = x
-end
-luaK.setnvalue = luaK.setsvalue
-luaK.sethvalue = luaK.setsvalue
-luaK.setbvalue = luaK.setsvalue
-
-------------------------------------------------------------------------
--- The luai_num* macros define the primitive operations over numbers.
--- * this is not the entire set of primitive operations from luaconf.h
--- * used in luaK:constfolding()
-------------------------------------------------------------------------
-function luaK:numadd(a, b)
-	return a + b
-end
-function luaK:numsub(a, b)
-	return a - b
-end
-function luaK:nummul(a, b)
-	return a * b
-end
-function luaK:numdiv(a, b)
-	return a / b
-end
-function luaK:nummod(a, b)
-	return a % b
-end
--- ((a) - floor((a)/(b))*(b)) /* actual, for reference */
-function luaK:numpow(a, b)
-	return a ^ b
-end
-function luaK:numunm(a)
-	return -a
-end
-function luaK:numisnan(a)
-	return not a == a
-end
--- a NaN cannot equal another NaN
-
---[[--------------------------------------------------------------------
--- code generator functions
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- Marks the end of a patch list. It is an invalid value both as an absolute
--- address, and as a list link (would link an element to itself).
-------------------------------------------------------------------------
-luaK.NO_JUMP = -1
-
-------------------------------------------------------------------------
--- grep "ORDER OPR" if you change these enums
-------------------------------------------------------------------------
-luaK.BinOpr = {
-	OPR_ADD = 0,
-	OPR_SUB = 1,
-	OPR_MUL = 2,
-	OPR_DIV = 3,
-	OPR_MOD = 4,
-	OPR_POW = 5,
-	OPR_CONCAT = 6,
-	OPR_NE = 7,
-	OPR_EQ = 8,
-	OPR_LT = 9,
-	OPR_LE = 10,
-	OPR_GT = 11,
-	OPR_GE = 12,
-	OPR_AND = 13,
-	OPR_OR = 14,
-	OPR_NOBINOPR = 15,
-}
-
--- * UnOpr is used by luaK:prefix's op argument, but not directly used
---   because the function receives the symbols as strings, e.g. "OPR_NOT"
-luaK.UnOpr = {
-	OPR_MINUS = 0,
-	OPR_NOT = 1,
-	OPR_LEN = 2,
-	OPR_NOUNOPR = 3,
-}
-
-------------------------------------------------------------------------
--- returns the instruction object for given e (expdesc), was a macro
-------------------------------------------------------------------------
-function luaK:getcode(fs, e)
-	return fs.f.code[e.info]
-end
-
-------------------------------------------------------------------------
--- codes an instruction with a signed Bx (sBx) field, was a macro
--- * used in luaK:jump(), (lparser) luaY:forbody()
-------------------------------------------------------------------------
-function luaK:codeAsBx(fs, o, A, sBx)
-	return self:codeABx(fs, o, A, sBx + luaP.MAXARG_sBx)
-end
-
-------------------------------------------------------------------------
--- set the expdesc e instruction for multiple returns, was a macro
-------------------------------------------------------------------------
-function luaK:setmultret(fs, e)
-	self:setreturns(fs, e, luaY.LUA_MULTRET)
-end
-
-------------------------------------------------------------------------
--- there is a jump if patch lists are not identical, was a macro
--- * used in luaK:exp2reg(), luaK:exp2anyreg(), luaK:exp2val()
-------------------------------------------------------------------------
-function luaK:hasjumps(e)
-	return e.t ~= e.f
-end
-
-------------------------------------------------------------------------
--- true if the expression is a constant number (for constant folding)
--- * used in constfolding(), infix()
-------------------------------------------------------------------------
-function luaK:isnumeral(e)
-	return e.k == "VKNUM" and e.t == self.NO_JUMP and e.f == self.NO_JUMP
-end
-
-------------------------------------------------------------------------
--- codes loading of nil, optimization done if consecutive locations
--- * used in luaK:discharge2reg(), (lparser) luaY:adjust_assign()
-------------------------------------------------------------------------
-function luaK:_nil(fs, from, n)
-	if fs.pc > fs.lasttarget then -- no jumps to current position?
-		if fs.pc == 0 then -- function start?
-			if from >= fs.nactvar then
-				return -- positions are already clean
-			end
-		else
-			local previous = fs.f.code[fs.pc - 1]
-			if luaP:GET_OPCODE(previous) == "OP_LOADNIL" then
-				local pfrom = luaP:GETARG_A(previous)
-				local pto = luaP:GETARG_B(previous)
-				if pfrom <= from and from <= pto + 1 then -- can connect both?
-					if from + n - 1 > pto then
-						luaP:SETARG_B(previous, from + n - 1)
-					end
-					return
-				end
-			end
-		end
-	end
-	self:codeABC(fs, "OP_LOADNIL", from, from + n - 1, 0) -- else no optimization
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:jump(fs)
-	local jpc = fs.jpc -- save list of jumps to here
-	fs.jpc = self.NO_JUMP
-	local j = self:codeAsBx(fs, "OP_JMP", 0, self.NO_JUMP)
-	j = self:concat(fs, j, jpc) -- keep them on hold
-	return j
-end
-
-------------------------------------------------------------------------
--- codes a RETURN instruction
--- * used in luaY:close_func(), luaY:retstat()
-------------------------------------------------------------------------
-function luaK:ret(fs, first, nret)
-	self:codeABC(fs, "OP_RETURN", first, nret + 1, 0)
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:jumponcond(), luaK:codecomp()
-------------------------------------------------------------------------
-function luaK:condjump(fs, op, A, B, C)
-	self:codeABC(fs, op, A, B, C)
-	return self:jump(fs)
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:patchlistaux(), luaK:concat()
-------------------------------------------------------------------------
-function luaK:fixjump(fs, pc, dest)
-	local jmp = fs.f.code[pc]
-	local offset = dest - (pc + 1)
-	lua_assert(dest ~= self.NO_JUMP)
-	if math.abs(offset) > luaP.MAXARG_sBx then
-		luaX:syntaxerror(fs.ls, "control structure too long")
-	end
-	luaP:SETARG_sBx(jmp, offset)
-end
-
-------------------------------------------------------------------------
--- returns current 'pc' and marks it as a jump target (to avoid wrong
--- optimizations with consecutive instructions not in the same basic block).
--- * used in multiple locations
--- * fs.lasttarget tested only by luaK:_nil() when optimizing OP_LOADNIL
-------------------------------------------------------------------------
-function luaK:getlabel(fs)
-	fs.lasttarget = fs.pc
-	return fs.pc
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:need_value(), luaK:removevalues(), luaK:patchlistaux(),
---   luaK:concat()
-------------------------------------------------------------------------
-function luaK:getjump(fs, pc)
-	local offset = luaP:GETARG_sBx(fs.f.code[pc])
-	if offset == self.NO_JUMP then -- point to itself represents end of list
-		return self.NO_JUMP -- end of list
-	else
-		return (pc + 1) + offset -- turn offset into absolute position
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:need_value(), luaK:patchtestreg(), luaK:invertjump()
-------------------------------------------------------------------------
-function luaK:getjumpcontrol(fs, pc)
-	local pi = fs.f.code[pc]
-	local ppi = fs.f.code[pc - 1]
-	if pc >= 1 and luaP:testTMode(luaP:GET_OPCODE(ppi)) ~= 0 then
-		return ppi
-	else
-		return pi
-	end
-end
-
-------------------------------------------------------------------------
--- check whether list has any jump that do not produce a value
--- (or produce an inverted value)
--- * return value changed to boolean
--- * used only in luaK:exp2reg()
-------------------------------------------------------------------------
-function luaK:need_value(fs, list)
-	while list ~= self.NO_JUMP do
-		local i = self:getjumpcontrol(fs, list)
-		if luaP:GET_OPCODE(i) ~= "OP_TESTSET" then
-			return true
-		end
-		list = self:getjump(fs, list)
-	end
-	return false -- not found
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:removevalues(), luaK:patchlistaux()
-------------------------------------------------------------------------
-function luaK:patchtestreg(fs, node, reg)
-	local i = self:getjumpcontrol(fs, node)
-	if luaP:GET_OPCODE(i) ~= "OP_TESTSET" then
-		return false -- cannot patch other instructions
-	end
-	if reg ~= luaP.NO_REG and reg ~= luaP:GETARG_B(i) then
-		luaP:SETARG_A(i, reg)
-	else -- no register to put value or register already has the value
-		-- due to use of a table as i, i cannot be replaced by another table
-		-- so the following is required; there is no change to ARG_C
-		luaP:SET_OPCODE(i, "OP_TEST")
-		local b = luaP:GETARG_B(i)
-		luaP:SETARG_A(i, b)
-		luaP:SETARG_B(i, 0)
-		-- *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i)); /* C */
-	end
-	return true
-end
-
-------------------------------------------------------------------------
---
--- * used only in luaK:codenot()
-------------------------------------------------------------------------
-function luaK:removevalues(fs, list)
-	while list ~= self.NO_JUMP do
-		self:patchtestreg(fs, list, luaP.NO_REG)
-		list = self:getjump(fs, list)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:dischargejpc(), luaK:patchlist(), luaK:exp2reg()
-------------------------------------------------------------------------
-function luaK:patchlistaux(fs, list, vtarget, reg, dtarget)
-	while list ~= self.NO_JUMP do
-		local _next = self:getjump(fs, list)
-		if self:patchtestreg(fs, list, reg) then
-			self:fixjump(fs, list, vtarget)
-		else
-			self:fixjump(fs, list, dtarget) -- jump to default target
-		end
-		list = _next
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used only in luaK:code()
-------------------------------------------------------------------------
-function luaK:dischargejpc(fs)
-	self:patchlistaux(fs, fs.jpc, fs.pc, luaP.NO_REG, fs.pc)
-	fs.jpc = self.NO_JUMP
-end
-
-------------------------------------------------------------------------
---
--- * used in (lparser) luaY:whilestat(), luaY:repeatstat(), luaY:forbody()
-------------------------------------------------------------------------
-function luaK:patchlist(fs, list, target)
-	if target == fs.pc then
-		self:patchtohere(fs, list)
-	else
-		lua_assert(target < fs.pc)
-		self:patchlistaux(fs, list, target, luaP.NO_REG, target)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:patchtohere(fs, list)
-	self:getlabel(fs)
-	fs.jpc = self:concat(fs, fs.jpc, list)
-end
-
-------------------------------------------------------------------------
--- * l1 was a pointer, now l1 is returned and callee assigns the value
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:concat(fs, l1, l2)
-	if l2 == self.NO_JUMP then
-		return l1
-	elseif l1 == self.NO_JUMP then
-		return l2
-	else
-		local list = l1
-		local _next = self:getjump(fs, list)
-		while _next ~= self.NO_JUMP do -- find last element
-			list = _next
-			_next = self:getjump(fs, list)
-		end
-		self:fixjump(fs, list, l2)
-	end
-	return l1
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:reserveregs(), (lparser) luaY:forlist()
-------------------------------------------------------------------------
-function luaK:checkstack(fs, n)
-	local newstack = fs.freereg + n
-	if newstack > fs.f.maxstacksize then
-		if newstack >= self.MAXSTACK then
-			luaX:syntaxerror(fs.ls, "function or expression too complex")
-		end
-		fs.f.maxstacksize = newstack
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:reserveregs(fs, n)
-	self:checkstack(fs, n)
-	fs.freereg = fs.freereg + n
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:freeexp(), luaK:dischargevars()
-------------------------------------------------------------------------
-function luaK:freereg(fs, reg)
-	if not luaP:ISK(reg) and reg >= fs.nactvar then
-		fs.freereg = fs.freereg - 1
-		lua_assert(reg == fs.freereg)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:freeexp(fs, e)
-	if e.k == "VNONRELOC" then
-		self:freereg(fs, e.info)
-	end
-end
-
-------------------------------------------------------------------------
--- * TODO NOTE implementation is not 100% correct, since the assert fails
--- * luaH_set, setobj deleted; direct table access used instead
--- * used in luaK:stringK(), luaK:numberK(), luaK:boolK(), luaK:nilK()
-------------------------------------------------------------------------
-function luaK:addk(fs, k, v)
-	local L = fs.L
-	local idx = fs.h[k.value]
-	--TValue *idx = luaH_set(L, fs->h, k); /* C */
-	local f = fs.f
-	if self:ttisnumber(idx) then
-		--TODO this assert currently FAILS (last tested for 5.0.2)
-		--lua_assert(fs.f.k[self:nvalue(idx)] == v)
-		--lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v)); /* C */
-		return self:nvalue(idx)
-	else -- constant not found; create a new entry
-		idx = {}
-		self:setnvalue(idx, fs.nk)
-		fs.h[k.value] = idx
-		-- setnvalue(idx, cast_num(fs->nk)); /* C */
-		luaY:growvector(L, f.k, fs.nk, f.sizek, nil, luaP.MAXARG_Bx, "constant table overflow")
-		-- loop to initialize empty f.k positions not required
-		f.k[fs.nk] = v
-		-- setobj(L, &f->k[fs->nk], v); /* C */
-		-- luaC_barrier(L, f, v); /* GC */
-		local nk = fs.nk
-		fs.nk = fs.nk + 1
-		return nk
-	end
-end
-
-------------------------------------------------------------------------
--- creates and sets a string object
--- * used in (lparser) luaY:codestring(), luaY:singlevar()
-------------------------------------------------------------------------
-function luaK:stringK(fs, s)
-	local o = {} -- TValue
-	self:setsvalue(o, s)
-	return self:addk(fs, o, o)
-end
-
-------------------------------------------------------------------------
--- creates and sets a number object
--- * used in luaK:prefix() for negative (or negation of) numbers
--- * used in (lparser) luaY:simpleexp(), luaY:fornum()
-------------------------------------------------------------------------
-function luaK:numberK(fs, r)
-	local o = {} -- TValue
-	self:setnvalue(o, r)
-	return self:addk(fs, o, o)
-end
-
-------------------------------------------------------------------------
--- creates and sets a boolean object
--- * used only in luaK:exp2RK()
-------------------------------------------------------------------------
-function luaK:boolK(fs, b)
-	local o = {} -- TValue
-	self:setbvalue(o, b)
-	return self:addk(fs, o, o)
-end
-
-------------------------------------------------------------------------
--- creates and sets a nil object
--- * used only in luaK:exp2RK()
-------------------------------------------------------------------------
-function luaK:nilK(fs)
-	local k, v = {}, {} -- TValue
-	self:setnilvalue(v)
-	-- cannot use nil as key; instead use table itself to represent nil
-	self:sethvalue(k, fs.h)
-	return self:addk(fs, k, v)
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:setmultret(), (lparser) luaY:adjust_assign()
-------------------------------------------------------------------------
-function luaK:setreturns(fs, e, nresults)
-	if e.k == "VCALL" then -- expression is an open function call?
-		luaP:SETARG_C(self:getcode(fs, e), nresults + 1)
-	elseif e.k == "VVARARG" then
-		luaP:SETARG_B(self:getcode(fs, e), nresults + 1)
-		luaP:SETARG_A(self:getcode(fs, e), fs.freereg)
-		luaK:reserveregs(fs, 1)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:dischargevars(), (lparser) luaY:assignment()
-------------------------------------------------------------------------
-function luaK:setoneret(fs, e)
-	if e.k == "VCALL" then -- expression is an open function call?
-		e.k = "VNONRELOC"
-		e.info = luaP:GETARG_A(self:getcode(fs, e))
-	elseif e.k == "VVARARG" then
-		luaP:SETARG_B(self:getcode(fs, e), 2)
-		e.k = "VRELOCABLE" -- can relocate its simple result
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:dischargevars(fs, e)
-	local k = e.k
-	if k == "VLOCAL" then
-		e.k = "VNONRELOC"
-	elseif k == "VUPVAL" then
-		e.info = self:codeABC(fs, "OP_GETUPVAL", 0, e.info, 0)
-		e.k = "VRELOCABLE"
-	elseif k == "VGLOBAL" then
-		e.info = self:codeABx(fs, "OP_GETGLOBAL", 0, e.info)
-		e.k = "VRELOCABLE"
-	elseif k == "VINDEXED" then
-		self:freereg(fs, e.aux)
-		self:freereg(fs, e.info)
-		e.info = self:codeABC(fs, "OP_GETTABLE", 0, e.info, e.aux)
-		e.k = "VRELOCABLE"
-	elseif k == "VVARARG" or k == "VCALL" then
-		self:setoneret(fs, e)
-	else
-		-- there is one value available (somewhere)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used only in luaK:exp2reg()
-------------------------------------------------------------------------
-function luaK:code_label(fs, A, b, jump)
-	self:getlabel(fs) -- those instructions may be jump targets
-	return self:codeABC(fs, "OP_LOADBOOL", A, b, jump)
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:discharge2anyreg(), luaK:exp2reg()
-------------------------------------------------------------------------
-function luaK:discharge2reg(fs, e, reg)
-	self:dischargevars(fs, e)
-	local k = e.k
-	if k == "VNIL" then
-		self:_nil(fs, reg, 1)
-	elseif k == "VFALSE" or k == "VTRUE" then
-		self:codeABC(fs, "OP_LOADBOOL", reg, (e.k == "VTRUE") and 1 or 0, 0)
-	elseif k == "VK" then
-		self:codeABx(fs, "OP_LOADK", reg, e.info)
-	elseif k == "VKNUM" then
-		self:codeABx(fs, "OP_LOADK", reg, self:numberK(fs, e.nval))
-	elseif k == "VRELOCABLE" then
-		local pc = self:getcode(fs, e)
-		luaP:SETARG_A(pc, reg)
-	elseif k == "VNONRELOC" then
-		if reg ~= e.info then
-			self:codeABC(fs, "OP_MOVE", reg, e.info, 0)
-		end
-	else
-		lua_assert(e.k == "VVOID" or e.k == "VJMP")
-		return -- nothing to do...
-	end
-	e.info = reg
-	e.k = "VNONRELOC"
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:jumponcond(), luaK:codenot()
-------------------------------------------------------------------------
-function luaK:discharge2anyreg(fs, e)
-	if e.k ~= "VNONRELOC" then
-		self:reserveregs(fs, 1)
-		self:discharge2reg(fs, e, fs.freereg - 1)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:exp2nextreg(), luaK:exp2anyreg(), luaK:storevar()
-------------------------------------------------------------------------
-function luaK:exp2reg(fs, e, reg)
-	self:discharge2reg(fs, e, reg)
-	if e.k == "VJMP" then
-		e.t = self:concat(fs, e.t, e.info) -- put this jump in 't' list
-	end
-	if self:hasjumps(e) then
-		local final -- position after whole expression
-		local p_f = self.NO_JUMP -- position of an eventual LOAD false
-		local p_t = self.NO_JUMP -- position of an eventual LOAD true
-		if self:need_value(fs, e.t) or self:need_value(fs, e.f) then
-			local fj = (e.k == "VJMP") and self.NO_JUMP or self:jump(fs)
-			p_f = self:code_label(fs, reg, 0, 1)
-			p_t = self:code_label(fs, reg, 1, 0)
-			self:patchtohere(fs, fj)
-		end
-		final = self:getlabel(fs)
-		self:patchlistaux(fs, e.f, final, reg, p_f)
-		self:patchlistaux(fs, e.t, final, reg, p_t)
-	end
-	e.f, e.t = self.NO_JUMP, self.NO_JUMP
-	e.info = reg
-	e.k = "VNONRELOC"
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:exp2nextreg(fs, e)
-	self:dischargevars(fs, e)
-	self:freeexp(fs, e)
-	self:reserveregs(fs, 1)
-	self:exp2reg(fs, e, fs.freereg - 1)
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:exp2anyreg(fs, e)
-	self:dischargevars(fs, e)
-	if e.k == "VNONRELOC" then
-		if not self:hasjumps(e) then -- exp is already in a register
-			return e.info
-		end
-		if e.info >= fs.nactvar then -- reg. is not a local?
-			self:exp2reg(fs, e, e.info) -- put value on it
-			return e.info
-		end
-	end
-	self:exp2nextreg(fs, e) -- default
-	return e.info
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:exp2RK(), luaK:prefix(), luaK:posfix()
--- * used in (lparser) luaY:yindex()
-------------------------------------------------------------------------
-function luaK:exp2val(fs, e)
-	if self:hasjumps(e) then
-		self:exp2anyreg(fs, e)
-	else
-		self:dischargevars(fs, e)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaK:exp2RK(fs, e)
-	self:exp2val(fs, e)
-	local k = e.k
-	if k == "VKNUM" or k == "VTRUE" or k == "VFALSE" or k == "VNIL" then
-		if fs.nk <= luaP.MAXINDEXRK then -- constant fit in RK operand?
-			-- converted from a 2-deep ternary operator expression
-			if e.k == "VNIL" then
-				e.info = self:nilK(fs)
-			else
-				e.info = (e.k == "VKNUM") and self:numberK(fs, e.nval) or self:boolK(fs, e.k == "VTRUE")
-			end
-			e.k = "VK"
-			return luaP:RKASK(e.info)
-		end
-	elseif k == "VK" then
-		if e.info <= luaP.MAXINDEXRK then -- constant fit in argC?
-			return luaP:RKASK(e.info)
-		end
-	else
-		-- default
-	end
-	-- not a constant in the right range: put it in a register
-	return self:exp2anyreg(fs, e)
-end
-
-------------------------------------------------------------------------
---
--- * used in (lparser) luaY:assignment(), luaY:localfunc(), luaY:funcstat()
-------------------------------------------------------------------------
-function luaK:storevar(fs, var, ex)
-	local k = var.k
-	if k == "VLOCAL" then
-		self:freeexp(fs, ex)
-		self:exp2reg(fs, ex, var.info)
-		return
-	elseif k == "VUPVAL" then
-		local e = self:exp2anyreg(fs, ex)
-		self:codeABC(fs, "OP_SETUPVAL", e, var.info, 0)
-	elseif k == "VGLOBAL" then
-		local e = self:exp2anyreg(fs, ex)
-		self:codeABx(fs, "OP_SETGLOBAL", e, var.info)
-	elseif k == "VINDEXED" then
-		local e = self:exp2RK(fs, ex)
-		self:codeABC(fs, "OP_SETTABLE", var.info, var.aux, e)
-	else
-		lua_assert(0) -- invalid var kind to store
-	end
-	self:freeexp(fs, ex)
-end
-
-------------------------------------------------------------------------
---
--- * used only in (lparser) luaY:primaryexp()
-------------------------------------------------------------------------
-function luaK:_self(fs, e, key)
-	self:exp2anyreg(fs, e)
-	self:freeexp(fs, e)
-	local func = fs.freereg
-	self:reserveregs(fs, 2)
-	self:codeABC(fs, "OP_SELF", func, e.info, self:exp2RK(fs, key))
-	self:freeexp(fs, key)
-	e.info = func
-	e.k = "VNONRELOC"
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:goiftrue(), luaK:codenot()
-------------------------------------------------------------------------
-function luaK:invertjump(fs, e)
-	local pc = self:getjumpcontrol(fs, e.info)
-	lua_assert(
-		luaP:testTMode(luaP:GET_OPCODE(pc)) ~= 0
-			and luaP:GET_OPCODE(pc) ~= "OP_TESTSET"
-			and luaP:GET_OPCODE(pc) ~= "OP_TEST"
-	)
-	luaP:SETARG_A(pc, (luaP:GETARG_A(pc) == 0) and 1 or 0)
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:goiftrue(), luaK:goiffalse()
-------------------------------------------------------------------------
-function luaK:jumponcond(fs, e, cond)
-	if e.k == "VRELOCABLE" then
-		local ie = self:getcode(fs, e)
-		if luaP:GET_OPCODE(ie) == "OP_NOT" then
-			fs.pc = fs.pc - 1 -- remove previous OP_NOT
-			return self:condjump(fs, "OP_TEST", luaP:GETARG_B(ie), 0, cond and 0 or 1)
-		end
-		-- else go through
-	end
-	self:discharge2anyreg(fs, e)
-	self:freeexp(fs, e)
-	return self:condjump(fs, "OP_TESTSET", luaP.NO_REG, e.info, cond and 1 or 0)
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:infix(), (lparser) luaY:cond()
-------------------------------------------------------------------------
-function luaK:goiftrue(fs, e)
-	local pc -- pc of last jump
-	self:dischargevars(fs, e)
-	local k = e.k
-	if k == "VK" or k == "VKNUM" or k == "VTRUE" then
-		pc = self.NO_JUMP -- always true; do nothing
-	elseif k == "VFALSE" then
-		pc = self:jump(fs) -- always jump
-	elseif k == "VJMP" then
-		self:invertjump(fs, e)
-		pc = e.info
-	else
-		pc = self:jumponcond(fs, e, false)
-	end
-	e.f = self:concat(fs, e.f, pc) -- insert last jump in `f' list
-	self:patchtohere(fs, e.t)
-	e.t = self.NO_JUMP
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:infix()
-------------------------------------------------------------------------
-function luaK:goiffalse(fs, e)
-	local pc -- pc of last jump
-	self:dischargevars(fs, e)
-	local k = e.k
-	if k == "VNIL" or k == "VFALSE" then
-		pc = self.NO_JUMP -- always false; do nothing
-	elseif k == "VTRUE" then
-		pc = self:jump(fs) -- always jump
-	elseif k == "VJMP" then
-		pc = e.info
-	else
-		pc = self:jumponcond(fs, e, true)
-	end
-	e.t = self:concat(fs, e.t, pc) -- insert last jump in `t' list
-	self:patchtohere(fs, e.f)
-	e.f = self.NO_JUMP
-end
-
-------------------------------------------------------------------------
---
--- * used only in luaK:prefix()
-------------------------------------------------------------------------
-function luaK:codenot(fs, e)
-	self:dischargevars(fs, e)
-	local k = e.k
-	if k == "VNIL" or k == "VFALSE" then
-		e.k = "VTRUE"
-	elseif k == "VK" or k == "VKNUM" or k == "VTRUE" then
-		e.k = "VFALSE"
-	elseif k == "VJMP" then
-		self:invertjump(fs, e)
-	elseif k == "VRELOCABLE" or k == "VNONRELOC" then
-		self:discharge2anyreg(fs, e)
-		self:freeexp(fs, e)
-		e.info = self:codeABC(fs, "OP_NOT", 0, e.info, 0)
-		e.k = "VRELOCABLE"
-	else
-		lua_assert(0) -- cannot happen
-	end
-	-- interchange true and false lists
-	e.f, e.t = e.t, e.f
-	self:removevalues(fs, e.f)
-	self:removevalues(fs, e.t)
-end
-
-------------------------------------------------------------------------
---
--- * used in (lparser) luaY:field(), luaY:primaryexp()
-------------------------------------------------------------------------
-function luaK:indexed(fs, t, k)
-	t.aux = self:exp2RK(fs, k)
-	t.k = "VINDEXED"
-end
-
-------------------------------------------------------------------------
---
--- * used only in luaK:codearith()
-------------------------------------------------------------------------
-function luaK:constfolding(op, e1, e2)
-	local r
-	if not self:isnumeral(e1) or not self:isnumeral(e2) then
-		return false
-	end
-	local v1 = e1.nval
-	local v2 = e2.nval
-	if op == "OP_ADD" then
-		r = self:numadd(v1, v2)
-	elseif op == "OP_SUB" then
-		r = self:numsub(v1, v2)
-	elseif op == "OP_MUL" then
-		r = self:nummul(v1, v2)
-	elseif op == "OP_DIV" then
-		if v2 == 0 then
-			return false
-		end -- do not attempt to divide by 0
-		r = self:numdiv(v1, v2)
-	elseif op == "OP_MOD" then
-		if v2 == 0 then
-			return false
-		end -- do not attempt to divide by 0
-		r = self:nummod(v1, v2)
-	elseif op == "OP_POW" then
-		r = self:numpow(v1, v2)
-	elseif op == "OP_UNM" then
-		r = self:numunm(v1)
-	elseif op == "OP_LEN" then
-		return false -- no constant folding for 'len'
-	else
-		lua_assert(0)
-		r = 0
-	end
-	if self:numisnan(r) then
-		return false
-	end -- do not attempt to produce NaN
-	e1.nval = r
-	return true
-end
-
-------------------------------------------------------------------------
---
--- * used in luaK:prefix(), luaK:posfix()
-------------------------------------------------------------------------
-function luaK:codearith(fs, op, e1, e2)
-	if self:constfolding(op, e1, e2) then
-		return
-	else
-		local o2 = (op ~= "OP_UNM" and op ~= "OP_LEN") and self:exp2RK(fs, e2) or 0
-		local o1 = self:exp2RK(fs, e1)
-		if o1 > o2 then
-			self:freeexp(fs, e1)
-			self:freeexp(fs, e2)
-		else
-			self:freeexp(fs, e2)
-			self:freeexp(fs, e1)
-		end
-		e1.info = self:codeABC(fs, op, 0, o1, o2)
-		e1.k = "VRELOCABLE"
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used only in luaK:posfix()
-------------------------------------------------------------------------
-function luaK:codecomp(fs, op, cond, e1, e2)
-	local o1 = self:exp2RK(fs, e1)
-	local o2 = self:exp2RK(fs, e2)
-	self:freeexp(fs, e2)
-	self:freeexp(fs, e1)
-	if cond == 0 and op ~= "OP_EQ" then
-		-- exchange args to replace by `<' or `<='
-		o1, o2 = o2, o1 -- o1 <==> o2
-		cond = 1
-	end
-	e1.info = self:condjump(fs, op, cond, o1, o2)
-	e1.k = "VJMP"
-end
-
-------------------------------------------------------------------------
---
--- * used only in (lparser) luaY:subexpr()
-------------------------------------------------------------------------
-function luaK:prefix(fs, op, e)
-	local e2 = {} -- expdesc
-	e2.t, e2.f = self.NO_JUMP, self.NO_JUMP
-	e2.k = "VKNUM"
-	e2.nval = 0
-	if op == "OPR_MINUS" then
-		if not self:isnumeral(e) then
-			self:exp2anyreg(fs, e) -- cannot operate on non-numeric constants
-		end
-		self:codearith(fs, "OP_UNM", e, e2)
-	elseif op == "OPR_NOT" then
-		self:codenot(fs, e)
-	elseif op == "OPR_LEN" then
-		self:exp2anyreg(fs, e) -- cannot operate on constants
-		self:codearith(fs, "OP_LEN", e, e2)
-	else
-		lua_assert(0)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used only in (lparser) luaY:subexpr()
-------------------------------------------------------------------------
-function luaK:infix(fs, op, v)
-	if op == "OPR_AND" then
-		self:goiftrue(fs, v)
-	elseif op == "OPR_OR" then
-		self:goiffalse(fs, v)
-	elseif op == "OPR_CONCAT" then
-		self:exp2nextreg(fs, v) -- operand must be on the 'stack'
-	elseif
-		op == "OPR_ADD"
-		or op == "OPR_SUB"
-		or op == "OPR_MUL"
-		or op == "OPR_DIV"
-		or op == "OPR_MOD"
-		or op == "OPR_POW"
-	then
-		if not self:isnumeral(v) then
-			self:exp2RK(fs, v)
-		end
-	else
-		self:exp2RK(fs, v)
-	end
-end
-
-------------------------------------------------------------------------
---
--- * used only in (lparser) luaY:subexpr()
-------------------------------------------------------------------------
--- table lookups to simplify testing
-luaK.arith_op = {
-	OPR_ADD = "OP_ADD",
-	OPR_SUB = "OP_SUB",
-	OPR_MUL = "OP_MUL",
-	OPR_DIV = "OP_DIV",
-	OPR_MOD = "OP_MOD",
-	OPR_POW = "OP_POW",
-}
-luaK.comp_op = {
-	OPR_EQ = "OP_EQ",
-	OPR_NE = "OP_EQ",
-	OPR_LT = "OP_LT",
-	OPR_LE = "OP_LE",
-	OPR_GT = "OP_LT",
-	OPR_GE = "OP_LE",
-}
-luaK.comp_cond = {
-	OPR_EQ = 1,
-	OPR_NE = 0,
-	OPR_LT = 1,
-	OPR_LE = 1,
-	OPR_GT = 0,
-	OPR_GE = 0,
-}
-function luaK:posfix(fs, op, e1, e2)
-	-- needed because e1 = e2 doesn't copy values...
-	-- * in 5.0.x, only k/info/aux/t/f copied, t for AND, f for OR
-	--   but here, all elements are copied for completeness' sake
-	local function copyexp(e1, e2)
-		e1.k = e2.k
-		e1.info = e2.info
-		e1.aux = e2.aux
-		e1.nval = e2.nval
-		e1.t = e2.t
-		e1.f = e2.f
-	end
-	if op == "OPR_AND" then
-		lua_assert(e1.t == self.NO_JUMP) -- list must be closed
-		self:dischargevars(fs, e2)
-		e2.f = self:concat(fs, e2.f, e1.f)
-		copyexp(e1, e2)
-	elseif op == "OPR_OR" then
-		lua_assert(e1.f == self.NO_JUMP) -- list must be closed
-		self:dischargevars(fs, e2)
-		e2.t = self:concat(fs, e2.t, e1.t)
-		copyexp(e1, e2)
-	elseif op == "OPR_CONCAT" then
-		self:exp2val(fs, e2)
-		if e2.k == "VRELOCABLE" and luaP:GET_OPCODE(self:getcode(fs, e2)) == "OP_CONCAT" then
-			lua_assert(e1.info == luaP:GETARG_B(self:getcode(fs, e2)) - 1)
-			self:freeexp(fs, e1)
-			luaP:SETARG_B(self:getcode(fs, e2), e1.info)
-			e1.k = "VRELOCABLE"
-			e1.info = e2.info
-		else
-			self:exp2nextreg(fs, e2) -- operand must be on the 'stack'
-			self:codearith(fs, "OP_CONCAT", e1, e2)
-		end
-	else
-		-- the following uses a table lookup in place of conditionals
-		local arith = self.arith_op[op]
-		if arith then
-			self:codearith(fs, arith, e1, e2)
-		else
-			local comp = self.comp_op[op]
-			if comp then
-				self:codecomp(fs, comp, self.comp_cond[op], e1, e2)
-			else
-				lua_assert(0)
-			end
-		end --if arith
-	end --if op
-end
-
-------------------------------------------------------------------------
--- adjusts debug information for last instruction written, in order to
--- change the line where item comes into existence
--- * used in (lparser) luaY:funcargs(), luaY:forbody(), luaY:funcstat()
-------------------------------------------------------------------------
-function luaK:fixline(fs, line)
-	fs.f.lineinfo[fs.pc - 1] = line
-end
-
-------------------------------------------------------------------------
--- general function to write an instruction into the instruction buffer,
--- sets debug information too
--- * used in luaK:codeABC(), luaK:codeABx()
--- * called directly by (lparser) luaY:whilestat()
-------------------------------------------------------------------------
-function luaK:code(fs, i, line)
-	local f = fs.f
-	self:dischargejpc(fs) -- 'pc' will change
-	-- put new instruction in code array
-	luaY:growvector(fs.L, f.code, fs.pc, f.sizecode, nil, luaY.MAX_INT, "code size overflow")
-	f.code[fs.pc] = i
-	-- save corresponding line information
-	luaY:growvector(fs.L, f.lineinfo, fs.pc, f.sizelineinfo, nil, luaY.MAX_INT, "code size overflow")
-	f.lineinfo[fs.pc] = line
-	local pc = fs.pc
-	fs.pc = fs.pc + 1
-	return pc
-end
-
-------------------------------------------------------------------------
--- writes an instruction of type ABC
--- * calls luaK:code()
-------------------------------------------------------------------------
-function luaK:codeABC(fs, o, a, b, c)
-	lua_assert(luaP:getOpMode(o) == luaP.OpMode.iABC)
-	lua_assert(luaP:getBMode(o) ~= luaP.OpArgMask.OpArgN or b == 0)
-	lua_assert(luaP:getCMode(o) ~= luaP.OpArgMask.OpArgN or c == 0)
-	return self:code(fs, luaP:CREATE_ABC(o, a, b, c), fs.ls.lastline)
-end
-
-------------------------------------------------------------------------
--- writes an instruction of type ABx
--- * calls luaK:code(), called by luaK:codeAsBx()
-------------------------------------------------------------------------
-function luaK:codeABx(fs, o, a, bc)
-	lua_assert(luaP:getOpMode(o) == luaP.OpMode.iABx or luaP:getOpMode(o) == luaP.OpMode.iAsBx)
-	lua_assert(luaP:getCMode(o) == luaP.OpArgMask.OpArgN)
-	return self:code(fs, luaP:CREATE_ABx(o, a, bc), fs.ls.lastline)
-end
-
-------------------------------------------------------------------------
---
--- * used in (lparser) luaY:closelistfield(), luaY:lastlistfield()
-------------------------------------------------------------------------
-function luaK:setlist(fs, base, nelems, tostore)
-	local c = math.floor((nelems - 1) / luaP.LFIELDS_PER_FLUSH) + 1
-	local b = (tostore == luaY.LUA_MULTRET) and 0 or tostore
-	lua_assert(tostore ~= 0)
-	if c <= luaP.MAXARG_C then
-		self:codeABC(fs, "OP_SETLIST", base, b, c)
-	else
-		self:codeABC(fs, "OP_SETLIST", base, b, 0)
-		self:code(fs, luaP:CREATE_Inst(c), fs.ls.lastline)
-	end
-	fs.freereg = base + 1 -- free registers with list values
-end
-
---dofile("lparser.lua")
-
---[[--------------------------------------------------------------------
--- Expression descriptor
--- * expkind changed to string constants; luaY:assignment was the only
---   function to use a relational operator with this enumeration
--- VVOID       -- no value
--- VNIL        -- no value
--- VTRUE       -- no value
--- VFALSE      -- no value
--- VK          -- info = index of constant in 'k'
--- VKNUM       -- nval = numerical value
--- VLOCAL      -- info = local register
--- VUPVAL,     -- info = index of upvalue in 'upvalues'
--- VGLOBAL     -- info = index of table; aux = index of global name in 'k'
--- VINDEXED    -- info = table register; aux = index register (or 'k')
--- VJMP        -- info = instruction pc
--- VRELOCABLE  -- info = instruction pc
--- VNONRELOC   -- info = result register
--- VCALL       -- info = instruction pc
--- VVARARG     -- info = instruction pc
-} ----------------------------------------------------------------------]]
-
---[[--------------------------------------------------------------------
--- * expdesc in Lua 5.1.x has a union u and another struct s; this Lua
---   implementation ignores all instances of u and s usage
--- struct expdesc:
---   k  -- (enum: expkind)
---   info, aux -- (int, int)
---   nval -- (lua_Number)
---   t  -- patch list of 'exit when true'
---   f  -- patch list of 'exit when false'
-----------------------------------------------------------------------]]
-
---[[--------------------------------------------------------------------
--- struct upvaldesc:
---   k  -- (lu_byte)
---   info -- (lu_byte)
-----------------------------------------------------------------------]]
-
---[[--------------------------------------------------------------------
--- state needed to generate code for a given function
--- struct FuncState:
---   f  -- current function header (table: Proto)
---   h  -- table to find (and reuse) elements in 'k' (table: Table)
---   prev  -- enclosing function (table: FuncState)
---   ls  -- lexical state (table: LexState)
---   L  -- copy of the Lua state (table: lua_State)
---   bl  -- chain of current blocks (table: BlockCnt)
---   pc  -- next position to code (equivalent to 'ncode')
---   lasttarget   -- 'pc' of last 'jump target'
---   jpc  -- list of pending jumps to 'pc'
---   freereg  -- first free register
---   nk  -- number of elements in 'k'
---   np  -- number of elements in 'p'
---   nlocvars  -- number of elements in 'locvars'
---   nactvar  -- number of active local variables
---   upvalues[LUAI_MAXUPVALUES]  -- upvalues (table: upvaldesc)
---   actvar[LUAI_MAXVARS]  -- declared-variable stack
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- constants used by parser
--- * picks up duplicate values from luaX if required
-------------------------------------------------------------------------
-luaY.LUA_QS = luaX.LUA_QS or "'%s'" -- (from luaconf.h)
-
-luaY.SHRT_MAX = 32767 -- (from <limits.h>)
-luaY.LUAI_MAXVARS = 200 -- (luaconf.h)
-luaY.LUAI_MAXUPVALUES = 60 -- (luaconf.h)
-luaY.MAX_INT = luaX.MAX_INT or 2147483645 -- (from llimits.h)
--- * INT_MAX-2 for 32-bit systems
-luaY.LUAI_MAXCCALLS = 200 -- (from luaconf.h)
-
-luaY.VARARG_HASARG = 1 -- (from lobject.h)
--- NOTE: HASARG_MASK is value-specific
-luaY.HASARG_MASK = 2 -- this was added for a bitop in parlist()
-luaY.VARARG_ISVARARG = 2
--- NOTE: there is some value-specific code that involves VARARG_NEEDSARG
-luaY.VARARG_NEEDSARG = 4
-
-luaY.LUA_MULTRET = -1 -- (lua.h)
-
---[[--------------------------------------------------------------------
--- other functions
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- LUA_QL describes how error messages quote program elements.
--- CHANGE it if you want a different appearance. (from luaconf.h)
-------------------------------------------------------------------------
-function luaY:LUA_QL(x)
-	return "'" .. x .. "'"
-end
-
-------------------------------------------------------------------------
--- this is a stripped-down luaM_growvector (from lmem.h) which is a
--- macro based on luaM_growaux (in lmem.c); all the following does is
--- reproduce the size limit checking logic of the original function
--- so that error behaviour is identical; all arguments preserved for
--- convenience, even those which are unused
--- * set the t field to nil, since this originally does a sizeof(t)
--- * size (originally a pointer) is never updated, their final values
---   are set by luaY:close_func(), so overall things should still work
-------------------------------------------------------------------------
-function luaY:growvector(L, v, nelems, size, t, limit, e)
-	if nelems >= limit then
-		error(e) -- was luaG_runerror
-	end
-end
-
-------------------------------------------------------------------------
--- initialize a new function prototype structure (from lfunc.c)
--- * used only in open_func()
-------------------------------------------------------------------------
-function luaY:newproto(L)
-	local f = {} -- Proto
-	-- luaC_link(L, obj2gco(f), LUA_TPROTO); /* GC */
-	f.k = {}
-	f.sizek = 0
-	f.p = {}
-	f.sizep = 0
-	f.code = {}
-	f.sizecode = 0
-	f.sizelineinfo = 0
-	f.sizeupvalues = 0
-	f.nups = 0
-	f.upvalues = {}
-	f.numparams = 0
-	f.is_vararg = 0
-	f.maxstacksize = 0
-	f.lineinfo = {}
-	f.sizelocvars = 0
-	f.locvars = {}
-	f.lineDefined = 0
-	f.lastlinedefined = 0
-	f.source = nil
-	return f
-end
-
-------------------------------------------------------------------------
--- converts an integer to a "floating point byte", represented as
--- (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
--- eeeee != 0 and (xxx) otherwise.
-------------------------------------------------------------------------
-function luaY:int2fb(x)
-	local e = 0 -- exponent
-	while x >= 16 do
-		x = math.floor((x + 1) / 2)
-		e = e + 1
-	end
-	if x < 8 then
-		return x
-	else
-		return ((e + 1) * 8) + (x - 8)
-	end
-end
-
---[[--------------------------------------------------------------------
--- parser functions
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- true of the kind of expression produces multiple return values
-------------------------------------------------------------------------
-function luaY:hasmultret(k)
-	return k == "VCALL" or k == "VVARARG"
-end
-
-------------------------------------------------------------------------
--- convenience function to access active local i, returns entry
-------------------------------------------------------------------------
-function luaY:getlocvar(fs, i)
-	return fs.f.locvars[fs.actvar[i]]
-end
-
-------------------------------------------------------------------------
--- check a limit, string m provided as an error message
-------------------------------------------------------------------------
-function luaY:checklimit(fs, v, l, m)
-	if v > l then
-		self:errorlimit(fs, l, m)
-	end
-end
-
---[[--------------------------------------------------------------------
--- nodes for block list (list of active blocks)
--- struct BlockCnt:
---   previous  -- chain (table: BlockCnt)
---   breaklist  -- list of jumps out of this loop
---   nactvar  -- # active local variables outside the breakable structure
---   upval  -- true if some variable in the block is an upvalue (boolean)
---   isbreakable  -- true if 'block' is a loop (boolean)
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- prototypes for recursive non-terminal functions
-------------------------------------------------------------------------
--- prototypes deleted; not required in Lua
-
-------------------------------------------------------------------------
--- reanchor if last token is has a constant string, see close_func()
--- * used only in close_func()
-------------------------------------------------------------------------
-function luaY:anchor_token(ls)
-	if ls.t.token == "TK_NAME" or ls.t.token == "TK_STRING" then
-		-- not relevant to Lua implementation of parser
-		-- local ts = ls.t.seminfo
-		-- luaX_newstring(ls, getstr(ts), ts->tsv.len); /* C */
-	end
-end
-
-------------------------------------------------------------------------
--- throws a syntax error if token expected is not there
-------------------------------------------------------------------------
-function luaY:error_expected(ls, token)
-	luaX:syntaxerror(ls, string.format(self.LUA_QS .. " expected", luaX:token2str(ls, token)))
-end
-
-------------------------------------------------------------------------
--- prepares error message for display, for limits exceeded
--- * used only in checklimit()
-------------------------------------------------------------------------
-function luaY:errorlimit(fs, limit, what)
-	local msg = (fs.f.linedefined == 0) and string.format("main function has more than %d %s", limit, what)
-		or string.format("function at line %d has more than %d %s", fs.f.linedefined, limit, what)
-	luaX:lexerror(fs.ls, msg, 0)
-end
-
-------------------------------------------------------------------------
--- tests for a token, returns outcome
--- * return value changed to boolean
-------------------------------------------------------------------------
-function luaY:testnext(ls, c)
-	if ls.t.token == c then
-		luaX:next(ls)
-		return true
-	else
-		return false
-	end
-end
-
-------------------------------------------------------------------------
--- check for existence of a token, throws error if not found
-------------------------------------------------------------------------
-function luaY:check(ls, c)
-	if ls.t.token ~= c then
-		self:error_expected(ls, c)
-	end
-end
-
-------------------------------------------------------------------------
--- verify existence of a token, then skip it
-------------------------------------------------------------------------
-function luaY:checknext(ls, c)
-	self:check(ls, c)
-	luaX:next(ls)
-end
-
-------------------------------------------------------------------------
--- throws error if condition not matched
-------------------------------------------------------------------------
-function luaY:check_condition(ls, c, msg)
-	if not c then
-		luaX:syntaxerror(ls, msg)
-	end
-end
-
-------------------------------------------------------------------------
--- verifies token conditions are met or else throw error
-------------------------------------------------------------------------
-function luaY:check_match(ls, what, who, where)
-	if not self:testnext(ls, what) then
-		if where == ls.linenumber then
-			self:error_expected(ls, what)
-		else
-			luaX:syntaxerror(
-				ls,
-				string.format(
-					self.LUA_QS .. " expected (to close " .. self.LUA_QS .. " at line %d)",
-					luaX:token2str(ls, what),
-					luaX:token2str(ls, who),
-					where
-				)
-			)
-		end
-	end
-end
-
-------------------------------------------------------------------------
--- expect that token is a name, return the name
-------------------------------------------------------------------------
-function luaY:str_checkname(ls)
-	self:check(ls, "TK_NAME")
-	local ts = ls.t.seminfo
-	luaX:next(ls)
-	return ts
-end
-
-------------------------------------------------------------------------
--- initialize a struct expdesc, expression description data structure
-------------------------------------------------------------------------
-function luaY:init_exp(e, k, i)
-	e.f, e.t = luaK.NO_JUMP, luaK.NO_JUMP
-	e.k = k
-	e.info = i
-end
-
-------------------------------------------------------------------------
--- adds given string s in string pool, sets e as VK
-------------------------------------------------------------------------
-function luaY:codestring(ls, e, s)
-	self:init_exp(e, "VK", luaK:stringK(ls.fs, s))
-end
-
-------------------------------------------------------------------------
--- consume a name token, adds it to string pool, sets e as VK
-------------------------------------------------------------------------
-function luaY:checkname(ls, e)
-	self:codestring(ls, e, self:str_checkname(ls))
-end
-
-------------------------------------------------------------------------
--- creates struct entry for a local variable
--- * used only in new_localvar()
-------------------------------------------------------------------------
-function luaY:registerlocalvar(ls, varname)
-	local fs = ls.fs
-	local f = fs.f
-	self:growvector(ls.L, f.locvars, fs.nlocvars, f.sizelocvars, nil, self.SHRT_MAX, "too many local variables")
-	-- loop to initialize empty f.locvar positions not required
-	f.locvars[fs.nlocvars] = {} -- LocVar
-	f.locvars[fs.nlocvars].varname = varname
-	-- luaC_objbarrier(ls.L, f, varname) /* GC */
-	local nlocvars = fs.nlocvars
-	fs.nlocvars = fs.nlocvars + 1
-	return nlocvars
-end
-
-------------------------------------------------------------------------
--- creates a new local variable given a name and an offset from nactvar
--- * used in fornum(), forlist(), parlist(), body()
-------------------------------------------------------------------------
-function luaY:new_localvarliteral(ls, v, n)
-	self:new_localvar(ls, v, n)
-end
-
-------------------------------------------------------------------------
--- register a local variable, set in active variable list
-------------------------------------------------------------------------
-function luaY:new_localvar(ls, name, n)
-	local fs = ls.fs
-	self:checklimit(fs, fs.nactvar + n + 1, self.LUAI_MAXVARS, "local variables")
-	fs.actvar[fs.nactvar + n] = self:registerlocalvar(ls, name)
-end
-
-------------------------------------------------------------------------
--- adds nvars number of new local variables, set debug information
-------------------------------------------------------------------------
-function luaY:adjustlocalvars(ls, nvars)
-	local fs = ls.fs
-	fs.nactvar = fs.nactvar + nvars
-	for i = nvars, 1, -1 do
-		self:getlocvar(fs, fs.nactvar - i).startpc = fs.pc
-	end
-end
-
-------------------------------------------------------------------------
--- removes a number of locals, set debug information
-------------------------------------------------------------------------
-function luaY:removevars(ls, tolevel)
-	local fs = ls.fs
-	while fs.nactvar > tolevel do
-		fs.nactvar = fs.nactvar - 1
-		self:getlocvar(fs, fs.nactvar).endpc = fs.pc
-	end
-end
-
-------------------------------------------------------------------------
--- returns an existing upvalue index based on the given name, or
--- creates a new upvalue struct entry and returns the new index
--- * used only in singlevaraux()
-------------------------------------------------------------------------
-function luaY:indexupvalue(fs, name, v)
-	local f = fs.f
-	for i = 0, f.nups - 1 do
-		if fs.upvalues[i].k == v.k and fs.upvalues[i].info == v.info then
-			lua_assert(f.upvalues[i] == name)
-			return i
-		end
-	end
-	-- new one
-	self:checklimit(fs, f.nups + 1, self.LUAI_MAXUPVALUES, "upvalues")
-	self:growvector(fs.L, f.upvalues, f.nups, f.sizeupvalues, nil, self.MAX_INT, "")
-	-- loop to initialize empty f.upvalues positions not required
-	f.upvalues[f.nups] = name
-	-- luaC_objbarrier(fs->L, f, name); /* GC */
-	lua_assert(v.k == "VLOCAL" or v.k == "VUPVAL")
-	-- this is a partial copy; only k & info fields used
-	fs.upvalues[f.nups] = { k = v.k, info = v.info }
-	local nups = f.nups
-	f.nups = f.nups + 1
-	return nups
-end
-
-------------------------------------------------------------------------
--- search the local variable namespace of the given fs for a match
--- * used only in singlevaraux()
-------------------------------------------------------------------------
-function luaY:searchvar(fs, n)
-	for i = fs.nactvar - 1, 0, -1 do
-		if n == self:getlocvar(fs, i).varname then
-			return i
-		end
-	end
-	return -1 -- not found
-end
-
-------------------------------------------------------------------------
--- * mark upvalue flags in function states up to a given level
--- * used only in singlevaraux()
-------------------------------------------------------------------------
-function luaY:markupval(fs, level)
-	local bl = fs.bl
-	while bl and bl.nactvar > level do
-		bl = bl.previous
-	end
-	if bl then
-		bl.upval = true
-	end
-end
-
-------------------------------------------------------------------------
--- handle locals, globals and upvalues and related processing
--- * search mechanism is recursive, calls itself to search parents
--- * used only in singlevar()
-------------------------------------------------------------------------
-function luaY:singlevaraux(fs, n, var, base)
-	if fs == nil then -- no more levels?
-		self:init_exp(var, "VGLOBAL", luaP.NO_REG) -- default is global variable
-		return "VGLOBAL"
-	else
-		local v = self:searchvar(fs, n) -- look up at current level
-		if v >= 0 then
-			self:init_exp(var, "VLOCAL", v)
-			if base == 0 then
-				self:markupval(fs, v) -- local will be used as an upval
-			end
-			return "VLOCAL"
-		else -- not found at current level; try upper one
-			if self:singlevaraux(fs.prev, n, var, 0) == "VGLOBAL" then
-				return "VGLOBAL"
-			end
-			var.info = self:indexupvalue(fs, n, var) -- else was LOCAL or UPVAL
-			var.k = "VUPVAL" -- upvalue in this level
-			return "VUPVAL"
-		end --if v
-	end --if fs
-end
-
-------------------------------------------------------------------------
--- consume a name token, creates a variable (global|local|upvalue)
--- * used in prefixexp(), funcname()
-------------------------------------------------------------------------
-function luaY:singlevar(ls, var)
-	local varname = self:str_checkname(ls)
-	local fs = ls.fs
-	if self:singlevaraux(fs, varname, var, 1) == "VGLOBAL" then
-		var.info = luaK:stringK(fs, varname) -- info points to global name
-	end
-end
-
-------------------------------------------------------------------------
--- adjust RHS to match LHS in an assignment
--- * used in assignment(), forlist(), localstat()
-------------------------------------------------------------------------
-function luaY:adjust_assign(ls, nvars, nexps, e)
-	local fs = ls.fs
-	local extra = nvars - nexps
-	if self:hasmultret(e.k) then
-		extra = extra + 1 -- includes call itself
-		if extra <= 0 then
-			extra = 0
-		end
-		luaK:setreturns(fs, e, extra) -- last exp. provides the difference
-		if extra > 1 then
-			luaK:reserveregs(fs, extra - 1)
-		end
-	else
-		if e.k ~= "VVOID" then
-			luaK:exp2nextreg(fs, e)
-		end -- close last expression
-		if extra > 0 then
-			local reg = fs.freereg
-			luaK:reserveregs(fs, extra)
-			luaK:_nil(fs, reg, extra)
-		end
-	end
-end
-
-------------------------------------------------------------------------
--- tracks and limits parsing depth, assert check at end of parsing
-------------------------------------------------------------------------
-function luaY:enterlevel(ls)
-	ls.L.nCcalls = ls.L.nCcalls + 1
-	if ls.L.nCcalls > self.LUAI_MAXCCALLS then
-		luaX:lexerror(ls, "chunk has too many syntax levels", 0)
-	end
-end
-
-------------------------------------------------------------------------
--- tracks parsing depth, a pair with luaY:enterlevel()
-------------------------------------------------------------------------
-function luaY:leavelevel(ls)
-	ls.L.nCcalls = ls.L.nCcalls - 1
-end
-
-------------------------------------------------------------------------
--- enters a code unit, initializes elements
-------------------------------------------------------------------------
-function luaY:enterblock(fs, bl, isbreakable)
-	bl.breaklist = luaK.NO_JUMP
-	bl.isbreakable = isbreakable
-	bl.nactvar = fs.nactvar
-	bl.upval = false
-	bl.previous = fs.bl
-	fs.bl = bl
-	lua_assert(fs.freereg == fs.nactvar)
-end
-
-------------------------------------------------------------------------
--- leaves a code unit, close any upvalues
-------------------------------------------------------------------------
-function luaY:leaveblock(fs)
-	local bl = fs.bl
-	fs.bl = bl.previous
-	self:removevars(fs.ls, bl.nactvar)
-	if bl.upval then
-		luaK:codeABC(fs, "OP_CLOSE", bl.nactvar, 0, 0)
-	end
-	-- a block either controls scope or breaks (never both)
-	lua_assert(not bl.isbreakable or not bl.upval)
-	lua_assert(bl.nactvar == fs.nactvar)
-	fs.freereg = fs.nactvar -- free registers
-	luaK:patchtohere(fs, bl.breaklist)
-end
-
-------------------------------------------------------------------------
--- implement the instantiation of a function prototype, append list of
--- upvalues after the instantiation instruction
--- * used only in body()
-------------------------------------------------------------------------
-function luaY:pushclosure(ls, func, v)
-	local fs = ls.fs
-	local f = fs.f
-	self:growvector(ls.L, f.p, fs.np, f.sizep, nil, luaP.MAXARG_Bx, "constant table overflow")
-	-- loop to initialize empty f.p positions not required
-	f.p[fs.np] = func.f
-	fs.np = fs.np + 1
-	-- luaC_objbarrier(ls->L, f, func->f); /* C */
-	self:init_exp(v, "VRELOCABLE", luaK:codeABx(fs, "OP_CLOSURE", 0, fs.np - 1))
-	for i = 0, func.f.nups - 1 do
-		local o = (func.upvalues[i].k == "VLOCAL") and "OP_MOVE" or "OP_GETUPVAL"
-		luaK:codeABC(fs, o, 0, func.upvalues[i].info, 0)
-	end
-end
-
-------------------------------------------------------------------------
--- opening of a function
-------------------------------------------------------------------------
-function luaY:open_func(ls, fs)
-	local L = ls.L
-	local f = self:newproto(ls.L)
-	fs.f = f
-	fs.prev = ls.fs -- linked list of funcstates
-	fs.ls = ls
-	fs.L = L
-	ls.fs = fs
-	fs.pc = 0
-	fs.lasttarget = -1
-	fs.jpc = luaK.NO_JUMP
-	fs.freereg = 0
-	fs.nk = 0
-	fs.np = 0
-	fs.nlocvars = 0
-	fs.nactvar = 0
-	fs.bl = nil
-	f.source = ls.source
-	f.maxstacksize = 2 -- registers 0/1 are always valid
-	fs.h = {} -- constant table; was luaH_new call
-	-- anchor table of constants and prototype (to avoid being collected)
-	-- sethvalue2s(L, L->top, fs->h); incr_top(L); /* C */
-	-- setptvalue2s(L, L->top, f); incr_top(L);
-end
-
-------------------------------------------------------------------------
--- closing of a function
-------------------------------------------------------------------------
-function luaY:close_func(ls)
-	local L = ls.L
-	local fs = ls.fs
-	local f = fs.f
-	self:removevars(ls, 0)
-	luaK:ret(fs, 0, 0) -- final return
-	-- luaM_reallocvector deleted for f->code, f->lineinfo, f->k, f->p,
-	-- f->locvars, f->upvalues; not required for Lua table arrays
-	f.sizecode = fs.pc
-	f.sizelineinfo = fs.pc
-	f.sizek = fs.nk
-	f.sizep = fs.np
-	f.sizelocvars = fs.nlocvars
-	f.sizeupvalues = f.nups
-	--lua_assert(luaG_checkcode(f))  -- currently not implemented
-	lua_assert(fs.bl == nil)
-	ls.fs = fs.prev
-	-- the following is not required for this implementation; kept here
-	-- for completeness
-	-- L->top -= 2;  /* remove table and prototype from the stack */
-	-- last token read was anchored in defunct function; must reanchor it
-	if fs then
-		self:anchor_token(ls)
-	end
-end
-
-------------------------------------------------------------------------
--- parser initialization function
--- * note additional sub-tables needed for LexState, FuncState
-------------------------------------------------------------------------
-function luaY:parser(L, z, buff, name)
-	local lexstate = {} -- LexState
-	lexstate.t = {}
-	lexstate.lookahead = {}
-	local funcstate = {} -- FuncState
-	funcstate.upvalues = {}
-	funcstate.actvar = {}
-	-- the following nCcalls initialization added for convenience
-	L.nCcalls = 0
-	lexstate.buff = buff
-	luaX:setinput(L, lexstate, z, name)
-	self:open_func(lexstate, funcstate)
-	funcstate.f.is_vararg = self.VARARG_ISVARARG -- main func. is always vararg
-	luaX:next(lexstate) -- read first token
-	self:chunk(lexstate)
-	self:check(lexstate, "TK_EOS")
-	self:close_func(lexstate)
-	lua_assert(funcstate.prev == nil)
-	lua_assert(funcstate.f.nups == 0)
-	lua_assert(lexstate.fs == nil)
-	return funcstate.f
-end
-
---[[--------------------------------------------------------------------
--- GRAMMAR RULES
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- parse a function name suffix, for function call specifications
--- * used in primaryexp(), funcname()
-------------------------------------------------------------------------
-function luaY:field(ls, v)
-	-- field -> ['.' | ':'] NAME
-	local fs = ls.fs
-	local key = {} -- expdesc
-	luaK:exp2anyreg(fs, v)
-	luaX:next(ls) -- skip the dot or colon
-	self:checkname(ls, key)
-	luaK:indexed(fs, v, key)
-end
-
-------------------------------------------------------------------------
--- parse a table indexing suffix, for constructors, expressions
--- * used in recfield(), primaryexp()
-------------------------------------------------------------------------
-function luaY:yindex(ls, v)
-	-- index -> '[' expr ']'
-	luaX:next(ls) -- skip the '['
-	self:expr(ls, v)
-	luaK:exp2val(ls.fs, v)
-	self:checknext(ls, "]")
-end
-
---[[--------------------------------------------------------------------
--- Rules for Constructors
-----------------------------------------------------------------------]]
-
---[[--------------------------------------------------------------------
--- struct ConsControl:
---   v  -- last list item read (table: struct expdesc)
---   t  -- table descriptor (table: struct expdesc)
---   nh  -- total number of 'record' elements
---   na  -- total number of array elements
---   tostore  -- number of array elements pending to be stored
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- parse a table record (hash) field
--- * used in constructor()
-------------------------------------------------------------------------
-function luaY:recfield(ls, cc)
-	-- recfield -> (NAME | '['exp1']') = exp1
-	local fs = ls.fs
-	local reg = ls.fs.freereg
-	local key, val = {}, {} -- expdesc
-	if ls.t.token == "TK_NAME" then
-		self:checklimit(fs, cc.nh, self.MAX_INT, "items in a constructor")
-		self:checkname(ls, key)
-	else -- ls->t.token == '['
-		self:yindex(ls, key)
-	end
-	cc.nh = cc.nh + 1
-	self:checknext(ls, "=")
-	local rkkey = luaK:exp2RK(fs, key)
-	self:expr(ls, val)
-	luaK:codeABC(fs, "OP_SETTABLE", cc.t.info, rkkey, luaK:exp2RK(fs, val))
-	fs.freereg = reg -- free registers
-end
-
-------------------------------------------------------------------------
--- emit a set list instruction if enough elements (LFIELDS_PER_FLUSH)
--- * used in constructor()
-------------------------------------------------------------------------
-function luaY:closelistfield(fs, cc)
-	if cc.v.k == "VVOID" then
-		return
-	end -- there is no list item
-	luaK:exp2nextreg(fs, cc.v)
-	cc.v.k = "VVOID"
-	if cc.tostore == luaP.LFIELDS_PER_FLUSH then
-		luaK:setlist(fs, cc.t.info, cc.na, cc.tostore) -- flush
-		cc.tostore = 0 -- no more items pending
-	end
-end
-
-------------------------------------------------------------------------
--- emit a set list instruction at the end of parsing list constructor
--- * used in constructor()
-------------------------------------------------------------------------
-function luaY:lastlistfield(fs, cc)
-	if cc.tostore == 0 then
-		return
-	end
-	if self:hasmultret(cc.v.k) then
-		luaK:setmultret(fs, cc.v)
-		luaK:setlist(fs, cc.t.info, cc.na, self.LUA_MULTRET)
-		cc.na = cc.na - 1 -- do not count last expression (unknown number of elements)
-	else
-		if cc.v.k ~= "VVOID" then
-			luaK:exp2nextreg(fs, cc.v)
-		end
-		luaK:setlist(fs, cc.t.info, cc.na, cc.tostore)
-	end
-end
-
-------------------------------------------------------------------------
--- parse a table list (array) field
--- * used in constructor()
-------------------------------------------------------------------------
-function luaY:listfield(ls, cc)
-	self:expr(ls, cc.v)
-	self:checklimit(ls.fs, cc.na, self.MAX_INT, "items in a constructor")
-	cc.na = cc.na + 1
-	cc.tostore = cc.tostore + 1
-end
-
-------------------------------------------------------------------------
--- parse a table constructor
--- * used in funcargs(), simpleexp()
-------------------------------------------------------------------------
-function luaY:constructor(ls, t)
-	-- constructor -> '{' [ field { fieldsep field } [ fieldsep ] ] '}'
-	-- field -> recfield | listfield
-	-- fieldsep -> ',' | ';'
-	local fs = ls.fs
-	local line = ls.linenumber
-	local pc = luaK:codeABC(fs, "OP_NEWTABLE", 0, 0, 0)
-	local cc = {} -- ConsControl
-	cc.v = {}
-	cc.na, cc.nh, cc.tostore = 0, 0, 0
-	cc.t = t
-	self:init_exp(t, "VRELOCABLE", pc)
-	self:init_exp(cc.v, "VVOID", 0) -- no value (yet)
-	luaK:exp2nextreg(ls.fs, t) -- fix it at stack top (for gc)
-	self:checknext(ls, "{")
-	repeat
-		lua_assert(cc.v.k == "VVOID" or cc.tostore > 0)
-		if ls.t.token == "}" then
-			break
-		end
-		self:closelistfield(fs, cc)
-		local c = ls.t.token
-
-		if c == "TK_NAME" then -- may be listfields or recfields
-			luaX:lookahead(ls)
-			if ls.lookahead.token ~= "=" then -- expression?
-				self:listfield(ls, cc)
-			else
-				self:recfield(ls, cc)
-			end
-		elseif c == "[" then -- constructor_item -> recfield
-			self:recfield(ls, cc)
-		else -- constructor_part -> listfield
-			self:listfield(ls, cc)
-		end
-	until not self:testnext(ls, ",") and not self:testnext(ls, ";")
-	self:check_match(ls, "}", "{", line)
-	self:lastlistfield(fs, cc)
-	luaP:SETARG_B(fs.f.code[pc], self:int2fb(cc.na)) -- set initial array size
-	luaP:SETARG_C(fs.f.code[pc], self:int2fb(cc.nh)) -- set initial table size
-end
-
--- }======================================================================
-
-------------------------------------------------------------------------
--- parse the arguments (parameters) of a function declaration
--- * used in body()
-------------------------------------------------------------------------
-function luaY:parlist(ls)
-	-- parlist -> [ param { ',' param } ]
-	local fs = ls.fs
-	local f = fs.f
-	local nparams = 0
-	f.is_vararg = 0
-	if ls.t.token ~= ")" then -- is 'parlist' not empty?
-		repeat
-			local c = ls.t.token
-			if c == "TK_NAME" then -- param -> NAME
-				self:new_localvar(ls, self:str_checkname(ls), nparams)
-				nparams = nparams + 1
-			elseif c == "TK_DOTS" then -- param -> `...'
-				luaX:next(ls)
-				-- [[
-				-- #if defined(LUA_COMPAT_VARARG)
-				-- use `arg' as default name
-				self:new_localvarliteral(ls, "arg", nparams)
-				nparams = nparams + 1
-				f.is_vararg = self.VARARG_HASARG + self.VARARG_NEEDSARG
-				-- #endif
-				--]]
-				f.is_vararg = f.is_vararg + self.VARARG_ISVARARG
-			else
-				luaX:syntaxerror(ls, "<name> or " .. self:LUA_QL("...") .. " expected")
-			end
-		until f.is_vararg ~= 0 or not self:testnext(ls, ",")
-	end --if
-	self:adjustlocalvars(ls, nparams)
-	-- NOTE: the following works only when HASARG_MASK is 2!
-	f.numparams = fs.nactvar - (f.is_vararg % self.HASARG_MASK)
-	luaK:reserveregs(fs, fs.nactvar) -- reserve register for parameters
-end
-
-------------------------------------------------------------------------
--- parse function declaration body
--- * used in simpleexp(), localfunc(), funcstat()
-------------------------------------------------------------------------
-function luaY:body(ls, e, needself, line)
-	-- body ->  '(' parlist ')' chunk END
-	local new_fs = {} -- FuncState
-	new_fs.upvalues = {}
-	new_fs.actvar = {}
-	self:open_func(ls, new_fs)
-	new_fs.f.lineDefined = line
-	self:checknext(ls, "(")
-	if needself then
-		self:new_localvarliteral(ls, "self", 0)
-		self:adjustlocalvars(ls, 1)
-	end
-	self:parlist(ls)
-	self:checknext(ls, ")")
-	self:chunk(ls)
-	new_fs.f.lastlinedefined = ls.linenumber
-	self:check_match(ls, "TK_END", "TK_FUNCTION", line)
-	self:close_func(ls)
-	self:pushclosure(ls, new_fs, e)
-end
-
-------------------------------------------------------------------------
--- parse a list of comma-separated expressions
--- * used is multiple locations
-------------------------------------------------------------------------
-function luaY:explist1(ls, v)
-	-- explist1 -> expr { ',' expr }
-	local n = 1 -- at least one expression
-	self:expr(ls, v)
-	while self:testnext(ls, ",") do
-		luaK:exp2nextreg(ls.fs, v)
-		self:expr(ls, v)
-		n = n + 1
-	end
-	return n
-end
-
-------------------------------------------------------------------------
--- parse the parameters of a function call
--- * contrast with parlist(), used in function declarations
--- * used in primaryexp()
-------------------------------------------------------------------------
-function luaY:funcargs(ls, f)
-	local fs = ls.fs
-	local args = {} -- expdesc
-	local nparams
-	local line = ls.linenumber
-	local c = ls.t.token
-	if c == "(" then -- funcargs -> '(' [ explist1 ] ')'
-		if line ~= ls.lastline then
-			luaX:syntaxerror(ls, "ambiguous syntax (function call x new statement)")
-		end
-		luaX:next(ls)
-		if ls.t.token == ")" then -- arg list is empty?
-			args.k = "VVOID"
-		else
-			self:explist1(ls, args)
-			luaK:setmultret(fs, args)
-		end
-		self:check_match(ls, ")", "(", line)
-	elseif c == "{" then -- funcargs -> constructor
-		self:constructor(ls, args)
-	elseif c == "TK_STRING" then -- funcargs -> STRING
-		self:codestring(ls, args, ls.t.seminfo)
-		luaX:next(ls) -- must use 'seminfo' before 'next'
-	else
-		luaX:syntaxerror(ls, "function arguments expected")
-		return
-	end
-	lua_assert(f.k == "VNONRELOC")
-	local base = f.info -- base register for call
-	if self:hasmultret(args.k) then
-		nparams = self.LUA_MULTRET -- open call
-	else
-		if args.k ~= "VVOID" then
-			luaK:exp2nextreg(fs, args) -- close last argument
-		end
-		nparams = fs.freereg - (base + 1)
-	end
-	self: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
-
---[[--------------------------------------------------------------------
--- Expression parsing
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- parses an expression in parentheses or a single variable
--- * used in primaryexp()
-------------------------------------------------------------------------
-function luaY:prefixexp(ls, v)
-	-- prefixexp -> NAME | '(' expr ')'
-	local c = ls.t.token
-	if c == "(" then
-		local line = ls.linenumber
-		luaX:next(ls)
-		self:expr(ls, v)
-		self:check_match(ls, ")", "(", line)
-		luaK:dischargevars(ls.fs, v)
-	elseif c == "TK_NAME" then
-		self:singlevar(ls, v)
-	else
-		luaX:syntaxerror(ls, "unexpected symbol")
-	end --if c
-	return
-end
-
-------------------------------------------------------------------------
--- parses a prefixexp (an expression in parentheses or a single variable)
--- or a function call specification
--- * used in simpleexp(), assignment(), exprstat()
-------------------------------------------------------------------------
-function luaY:primaryexp(ls, v)
-	-- primaryexp ->
-	--    prefixexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs }
-	local fs = ls.fs
-	self:prefixexp(ls, v)
-	while true do
-		local c = ls.t.token
-		if c == "." then -- field
-			self:field(ls, v)
-		elseif c == "[" then -- '[' exp1 ']'
-			local key = {} -- expdesc
-			luaK:exp2anyreg(fs, v)
-			self:yindex(ls, key)
-			luaK:indexed(fs, v, key)
-		elseif c == ":" then -- ':' NAME funcargs
-			local key = {} -- expdesc
-			luaX:next(ls)
-			self:checkname(ls, key)
-			luaK:_self(fs, v, key)
-			self:funcargs(ls, v)
-		elseif c == "(" or c == "TK_STRING" or c == "{" then -- funcargs
-			luaK:exp2nextreg(fs, v)
-			self:funcargs(ls, v)
-		else
-			return
-		end --if c
-	end --while
-end
-
-------------------------------------------------------------------------
--- parses general expression types, constants handled here
--- * used in subexpr()
-------------------------------------------------------------------------
-function luaY:simpleexp(ls, v)
-	-- simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | ... |
-	--              constructor | FUNCTION body | primaryexp
-	local c = ls.t.token
-	if c == "TK_NUMBER" then
-		self:init_exp(v, "VKNUM", 0)
-		v.nval = ls.t.seminfo
-	elseif c == "TK_STRING" then
-		self:codestring(ls, v, ls.t.seminfo)
-	elseif c == "TK_NIL" then
-		self:init_exp(v, "VNIL", 0)
-	elseif c == "TK_TRUE" then
-		self:init_exp(v, "VTRUE", 0)
-	elseif c == "TK_FALSE" then
-		self:init_exp(v, "VFALSE", 0)
-	elseif c == "TK_DOTS" then -- vararg
-		local fs = ls.fs
-		self:check_condition(
-			ls,
-			fs.f.is_vararg ~= 0,
-			"cannot use " .. self:LUA_QL("...") .. " outside a vararg function"
-		)
-		-- NOTE: the following substitutes for a bitop, but is value-specific
-		local is_vararg = fs.f.is_vararg
-		if is_vararg >= self.VARARG_NEEDSARG then
-			fs.f.is_vararg = is_vararg - self.VARARG_NEEDSARG -- don't need 'arg'
-		end
-		self:init_exp(v, "VVARARG", luaK:codeABC(fs, "OP_VARARG", 0, 1, 0))
-	elseif c == "{" then -- constructor
-		self:constructor(ls, v)
-		return
-	elseif c == "TK_FUNCTION" then
-		luaX:next(ls)
-		self:body(ls, v, false, ls.linenumber)
-		return
-	else
-		self:primaryexp(ls, v)
-		return
-	end --if c
-	luaX:next(ls)
-end
-
-------------------------------------------------------------------------
--- Translates unary operators tokens if found, otherwise returns
--- OPR_NOUNOPR. getunopr() and getbinopr() are used in subexpr().
--- * used in subexpr()
-------------------------------------------------------------------------
-function luaY:getunopr(op)
-	if op == "TK_NOT" then
-		return "OPR_NOT"
-	elseif op == "-" then
-		return "OPR_MINUS"
-	elseif op == "#" then
-		return "OPR_LEN"
-	else
-		return "OPR_NOUNOPR"
-	end
-end
-
-------------------------------------------------------------------------
--- Translates binary operator tokens if found, otherwise returns
--- OPR_NOBINOPR. Code generation uses OPR_* style tokens.
--- * used in subexpr()
-------------------------------------------------------------------------
-luaY.getbinopr_table = {
-	["+"] = "OPR_ADD",
-	["-"] = "OPR_SUB",
-	["*"] = "OPR_MUL",
-	["/"] = "OPR_DIV",
-	["%"] = "OPR_MOD",
-	["^"] = "OPR_POW",
-	["TK_CONCAT"] = "OPR_CONCAT",
-	["TK_NE"] = "OPR_NE",
-	["TK_EQ"] = "OPR_EQ",
-	["<"] = "OPR_LT",
-	["TK_LE"] = "OPR_LE",
-	[">"] = "OPR_GT",
-	["TK_GE"] = "OPR_GE",
-	["TK_AND"] = "OPR_AND",
-	["TK_OR"] = "OPR_OR",
-}
-function luaY:getbinopr(op)
-	local opr = self.getbinopr_table[op]
-	if opr then
-		return opr
-	else
-		return "OPR_NOBINOPR"
-	end
-end
-
-------------------------------------------------------------------------
--- the following priority table consists of pairs of left/right values
--- for binary operators (was a static const struct); grep for ORDER OPR
--- * the following struct is replaced:
---   static const struct {
---     lu_byte left;  /* left priority for each binary operator */
---     lu_byte right; /* right priority */
---   } priority[] = {  /* ORDER OPR */
-------------------------------------------------------------------------
-luaY.priority = {
-	{ 6, 6 },
-	{ 6, 6 },
-	{ 7, 7 },
-	{ 7, 7 },
-	{ 7, 7 }, -- `+' `-' `/' `%'
-	{ 10, 9 },
-	{ 5, 4 }, -- power and concat (right associative)
-	{ 3, 3 },
-	{ 3, 3 }, -- equality
-	{ 3, 3 },
-	{ 3, 3 },
-	{ 3, 3 },
-	{ 3, 3 }, -- order
-	{ 2, 2 },
-	{ 1, 1 }, -- logical (and/or)
-}
-
-luaY.UNARY_PRIORITY = 8 -- priority for unary operators
-
-------------------------------------------------------------------------
--- Parse subexpressions. Includes handling of unary operators and binary
--- operators. A subexpr is given the rhs priority level of the operator
--- immediately left of it, if any (limit is -1 if none,) and if a binop
--- is found, limit is compared with the lhs priority level of the binop
--- in order to determine which executes first.
-------------------------------------------------------------------------
-
-------------------------------------------------------------------------
--- subexpr -> (simpleexp | unop subexpr) { binop subexpr }
--- where 'binop' is any binary operator with a priority higher than 'limit'
--- * for priority lookups with self.priority[], 1=left and 2=right
--- * recursively called
--- * used in expr()
-------------------------------------------------------------------------
-function luaY:subexpr(ls, v, limit)
-	self:enterlevel(ls)
-	local uop = self:getunopr(ls.t.token)
-	if uop ~= "OPR_NOUNOPR" then
-		luaX:next(ls)
-		self:subexpr(ls, v, self.UNARY_PRIORITY)
-		luaK:prefix(ls.fs, uop, v)
-	else
-		self:simpleexp(ls, v)
-	end
-	-- expand while operators have priorities higher than 'limit'
-	local op = self:getbinopr(ls.t.token)
-	while op ~= "OPR_NOBINOPR" and self.priority[luaK.BinOpr[op] + 1][1] > limit do
-		local v2 = {} -- expdesc
-		luaX:next(ls)
-		luaK:infix(ls.fs, op, v)
-		-- read sub-expression with higher priority
-		local nextop = self:subexpr(ls, v2, self.priority[luaK.BinOpr[op] + 1][2])
-		luaK:posfix(ls.fs, op, v, v2)
-		op = nextop
-	end
-	self:leavelevel(ls)
-	return op -- return first untreated operator
-end
-
-------------------------------------------------------------------------
--- Expression parsing starts here. Function subexpr is entered with the
--- left operator (which is non-existent) priority of -1, which is lower
--- than all actual operators. Expr information is returned in parm v.
--- * used in multiple locations
-------------------------------------------------------------------------
-function luaY:expr(ls, v)
-	self:subexpr(ls, v, 0)
-end
-
--- }====================================================================
-
---[[--------------------------------------------------------------------
--- Rules for Statements
-----------------------------------------------------------------------]]
-
-------------------------------------------------------------------------
--- checks next token, used as a look-ahead
--- * returns boolean instead of 0|1
--- * used in retstat(), chunk()
-------------------------------------------------------------------------
-function luaY:block_follow(token)
-	if token == "TK_ELSE" or token == "TK_ELSEIF" or token == "TK_END" or token == "TK_UNTIL" or token == "TK_EOS" then
-		return true
-	else
-		return false
-	end
-end
-
-------------------------------------------------------------------------
--- parse a code block or unit
--- * used in multiple functions
-------------------------------------------------------------------------
-function luaY:block(ls)
-	-- block -> chunk
-	local fs = ls.fs
-	local bl = {} -- BlockCnt
-	self:enterblock(fs, bl, false)
-	self:chunk(ls)
-	lua_assert(bl.breaklist == luaK.NO_JUMP)
-	self:leaveblock(fs)
-end
-
-------------------------------------------------------------------------
--- structure to chain all variables in the left-hand side of an
--- assignment
--- struct LHS_assign:
---   prev  -- (table: struct LHS_assign)
---   v  -- variable (global, local, upvalue, or indexed) (table: expdesc)
-------------------------------------------------------------------------
-
-------------------------------------------------------------------------
--- check whether, in an assignment to a local variable, the local variable
--- is needed in a previous assignment (to a table). If so, save original
--- local value in a safe place and use this safe copy in the previous
--- assignment.
--- * used in assignment()
-------------------------------------------------------------------------
-function luaY:check_conflict(ls, lh, v)
-	local fs = ls.fs
-	local extra = fs.freereg -- eventual position to save local variable
-	local conflict = false
-	while lh do
-		if lh.v.k == "VINDEXED" then
-			if lh.v.info == v.info then -- conflict?
-				conflict = true
-				lh.v.info = extra -- previous assignment will use safe copy
-			end
-			if lh.v.aux == v.info then -- conflict?
-				conflict = true
-				lh.v.aux = extra -- previous assignment will use safe copy
-			end
-		end
-		lh = lh.prev
-	end
-	if conflict then
-		luaK:codeABC(fs, "OP_MOVE", fs.freereg, v.info, 0) -- make copy
-		luaK:reserveregs(fs, 1)
-	end
-end
-
-------------------------------------------------------------------------
--- parse a variable assignment sequence
--- * recursively called
--- * used in exprstat()
-------------------------------------------------------------------------
-function luaY:assignment(ls, lh, nvars)
-	local e = {} -- expdesc
-	-- test was: VLOCAL <= lh->v.k && lh->v.k <= VINDEXED
-	local c = lh.v.k
-	self:check_condition(ls, c == "VLOCAL" or c == "VUPVAL" or c == "VGLOBAL" or c == "VINDEXED", "syntax error")
-	if self:testnext(ls, ",") then -- assignment -> ',' primaryexp assignment
-		local nv = {} -- LHS_assign
-		nv.v = {}
-		nv.prev = lh
-		self:primaryexp(ls, nv.v)
-		if nv.v.k == "VLOCAL" then
-			self:check_conflict(ls, lh, nv.v)
-		end
-		self:checklimit(ls.fs, nvars, self.LUAI_MAXCCALLS - ls.L.nCcalls, "variables in assignment")
-		self:assignment(ls, nv, nvars + 1)
-	else -- assignment -> '=' explist1
-		self:checknext(ls, "=")
-		local nexps = self:explist1(ls, e)
-		if nexps ~= nvars then
-			self:adjust_assign(ls, nvars, nexps, e)
-			if nexps > nvars then
-				ls.fs.freereg = ls.fs.freereg - (nexps - nvars) -- remove extra values
-			end
-		else
-			luaK:setoneret(ls.fs, e) -- close last expression
-			luaK:storevar(ls.fs, lh.v, e)
-			return -- avoid default
-		end
-	end
-	self:init_exp(e, "VNONRELOC", ls.fs.freereg - 1) -- default assignment
-	luaK:storevar(ls.fs, lh.v, e)
-end
-
-------------------------------------------------------------------------
--- parse condition in a repeat statement or an if control structure
--- * used in repeatstat(), test_then_block()
-------------------------------------------------------------------------
-function luaY:cond(ls)
-	-- cond -> exp
-	local v = {} -- expdesc
-	self:expr(ls, v) -- read condition
-	if v.k == "VNIL" then
-		v.k = "VFALSE"
-	end -- 'falses' are all equal here
-	luaK:goiftrue(ls.fs, v)
-	return v.f
-end
-
-------------------------------------------------------------------------
--- parse a break statement
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:breakstat(ls)
-	-- stat -> BREAK
-	local fs = ls.fs
-	local bl = fs.bl
-	local upval = false
-	while bl and not bl.isbreakable do
-		if bl.upval then
-			upval = true
-		end
-		bl = bl.previous
-	end
-	if not bl then
-		luaX:syntaxerror(ls, "no loop to break")
-	end
-	if upval then
-		luaK:codeABC(fs, "OP_CLOSE", bl.nactvar, 0, 0)
-	end
-	bl.breaklist = luaK:concat(fs, bl.breaklist, luaK:jump(fs))
-end
-
-------------------------------------------------------------------------
--- parse a while-do control structure, body processed by block()
--- * with dynamic array sizes, MAXEXPWHILE + EXTRAEXP limits imposed by
---   the function's implementation can be removed
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:whilestat(ls, line)
-	-- whilestat -> WHILE cond DO block END
-	local fs = ls.fs
-	local bl = {} -- BlockCnt
-	luaX:next(ls) -- skip WHILE
-	local whileinit = luaK:getlabel(fs)
-	local condexit = self:cond(ls)
-	self:enterblock(fs, bl, true)
-	self:checknext(ls, "TK_DO")
-	self:block(ls)
-	luaK:patchlist(fs, luaK:jump(fs), whileinit)
-	self:check_match(ls, "TK_END", "TK_WHILE", line)
-	self:leaveblock(fs)
-	luaK:patchtohere(fs, condexit) -- false conditions finish the loop
-end
-
-------------------------------------------------------------------------
--- parse a repeat-until control structure, body parsed by chunk()
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:repeatstat(ls, line)
-	-- repeatstat -> REPEAT block UNTIL cond
-	local fs = ls.fs
-	local repeat_init = luaK:getlabel(fs)
-	local bl1, bl2 = {}, {} -- BlockCnt
-	self:enterblock(fs, bl1, true) -- loop block
-	self:enterblock(fs, bl2, false) -- scope block
-	luaX:next(ls) -- skip REPEAT
-	self:chunk(ls)
-	self:check_match(ls, "TK_UNTIL", "TK_REPEAT", line)
-	local condexit = self:cond(ls) -- read condition (inside scope block)
-	if not bl2.upval then -- no upvalues?
-		self:leaveblock(fs) -- finish scope
-		luaK:patchlist(ls.fs, condexit, repeat_init) -- close the loop
-	else -- complete semantics when there are upvalues
-		self:breakstat(ls) -- if condition then break
-		luaK:patchtohere(ls.fs, condexit) -- else...
-		self:leaveblock(fs) -- finish scope...
-		luaK:patchlist(ls.fs, luaK:jump(fs), repeat_init) -- and repeat
-	end
-	self:leaveblock(fs) -- finish loop
-end
-
-------------------------------------------------------------------------
--- parse the single expressions needed in numerical for loops
--- * used in fornum()
-------------------------------------------------------------------------
-function luaY:exp1(ls)
-	local e = {} -- expdesc
-	self:expr(ls, e)
-	local k = e.k
-	luaK:exp2nextreg(ls.fs, e)
-	return k
-end
-
-------------------------------------------------------------------------
--- parse a for loop body for both versions of the for loop
--- * used in fornum(), forlist()
-------------------------------------------------------------------------
-function luaY:forbody(ls, base, line, nvars, isnum)
-	-- forbody -> DO block
-	local bl = {} -- BlockCnt
-	local fs = ls.fs
-	self:adjustlocalvars(ls, 3) -- control variables
-	self:checknext(ls, "TK_DO")
-	local prep = isnum and luaK:codeAsBx(fs, "OP_FORPREP", base, luaK.NO_JUMP) or luaK:jump(fs)
-	self:enterblock(fs, bl, false) -- scope for declared variables
-	self:adjustlocalvars(ls, nvars)
-	luaK:reserveregs(fs, nvars)
-	self:block(ls)
-	self:leaveblock(fs) -- end of scope for declared variables
-	luaK:patchtohere(fs, prep)
-	local endfor = isnum and luaK:codeAsBx(fs, "OP_FORLOOP", base, luaK.NO_JUMP)
-		or luaK:codeABC(fs, "OP_TFORLOOP", base, 0, nvars)
-	luaK:fixline(fs, line) -- pretend that `OP_FOR' starts the loop
-	luaK:patchlist(fs, isnum and endfor or luaK:jump(fs), prep + 1)
-end
-
-------------------------------------------------------------------------
--- parse a numerical for loop, calls forbody()
--- * used in forstat()
-------------------------------------------------------------------------
-function luaY:fornum(ls, varname, line)
-	-- fornum -> NAME = exp1,exp1[,exp1] forbody
-	local fs = ls.fs
-	local base = fs.freereg
-	self:new_localvarliteral(ls, "(for index)", 0)
-	self:new_localvarliteral(ls, "(for limit)", 1)
-	self:new_localvarliteral(ls, "(for step)", 2)
-	self:new_localvar(ls, varname, 3)
-	self:checknext(ls, "=")
-	self:exp1(ls) -- initial value
-	self:checknext(ls, ",")
-	self:exp1(ls) -- limit
-	if self:testnext(ls, ",") then
-		self:exp1(ls) -- optional step
-	else -- default step = 1
-		luaK:codeABx(fs, "OP_LOADK", fs.freereg, luaK:numberK(fs, 1))
-		luaK:reserveregs(fs, 1)
-	end
-	self:forbody(ls, base, line, 1, true)
-end
-
-------------------------------------------------------------------------
--- parse a generic for loop, calls forbody()
--- * used in forstat()
-------------------------------------------------------------------------
-function luaY:forlist(ls, indexname)
-	-- forlist -> NAME {,NAME} IN explist1 forbody
-	local fs = ls.fs
-	local e = {} -- expdesc
-	local nvars = 0
-	local base = fs.freereg
-	-- create control variables
-	self:new_localvarliteral(ls, "(for generator)", nvars)
-	nvars = nvars + 1
-	self:new_localvarliteral(ls, "(for state)", nvars)
-	nvars = nvars + 1
-	self:new_localvarliteral(ls, "(for control)", nvars)
-	nvars = nvars + 1
-	-- create declared variables
-	self:new_localvar(ls, indexname, nvars)
-	nvars = nvars + 1
-	while self:testnext(ls, ",") do
-		self:new_localvar(ls, self:str_checkname(ls), nvars)
-		nvars = nvars + 1
-	end
-	self:checknext(ls, "TK_IN")
-	local line = ls.linenumber
-	self:adjust_assign(ls, 3, self:explist1(ls, e), e)
-	luaK:checkstack(fs, 3) -- extra space to call generator
-	self:forbody(ls, base, line, nvars - 3, false)
-end
-
-------------------------------------------------------------------------
--- initial parsing for a for loop, calls fornum() or forlist()
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:forstat(ls, line)
-	-- forstat -> FOR (fornum | forlist) END
-	local fs = ls.fs
-	local bl = {} -- BlockCnt
-	self:enterblock(fs, bl, true) -- scope for loop and control variables
-	luaX:next(ls) -- skip `for'
-	local varname = self:str_checkname(ls) -- first variable name
-	local c = ls.t.token
-	if c == "=" then
-		self:fornum(ls, varname, line)
-	elseif c == "," or c == "TK_IN" then
-		self:forlist(ls, varname)
-	else
-		luaX:syntaxerror(ls, self:LUA_QL("=") .. " or " .. self:LUA_QL("in") .. " expected")
-	end
-	self:check_match(ls, "TK_END", "TK_FOR", line)
-	self:leaveblock(fs) -- loop scope (`break' jumps to this point)
-end
-
-------------------------------------------------------------------------
--- parse part of an if control structure, including the condition
--- * used in ifstat()
-------------------------------------------------------------------------
-function luaY:test_then_block(ls)
-	-- test_then_block -> [IF | ELSEIF] cond THEN block
-	luaX:next(ls) -- skip IF or ELSEIF
-	local condexit = self:cond(ls)
-	self:checknext(ls, "TK_THEN")
-	self:block(ls) -- `then' part
-	return condexit
-end
-
-------------------------------------------------------------------------
--- parse an if control structure
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:ifstat(ls, line)
-	-- ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END
-	local fs = ls.fs
-	local escapelist = luaK.NO_JUMP
-	local flist = self:test_then_block(ls) -- IF cond THEN block
-	while ls.t.token == "TK_ELSEIF" do
-		escapelist = luaK:concat(fs, escapelist, luaK:jump(fs))
-		luaK:patchtohere(fs, flist)
-		flist = self:test_then_block(ls) -- ELSEIF cond THEN block
-	end
-	if ls.t.token == "TK_ELSE" then
-		escapelist = luaK:concat(fs, escapelist, luaK:jump(fs))
-		luaK:patchtohere(fs, flist)
-		luaX:next(ls) -- skip ELSE (after patch, for correct line info)
-		self:block(ls) -- 'else' part
-	else
-		escapelist = luaK:concat(fs, escapelist, flist)
-	end
-	luaK:patchtohere(fs, escapelist)
-	self:check_match(ls, "TK_END", "TK_IF", line)
-end
-
-------------------------------------------------------------------------
--- parse a local function statement
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:localfunc(ls)
-	local v, b = {}, {} -- expdesc
-	local fs = ls.fs
-	self:new_localvar(ls, self:str_checkname(ls), 0)
-	self:init_exp(v, "VLOCAL", fs.freereg)
-	luaK:reserveregs(fs, 1)
-	self:adjustlocalvars(ls, 1)
-	self:body(ls, b, false, ls.linenumber)
-	luaK:storevar(fs, v, b)
-	-- debug information will only see the variable after this point!
-	self:getlocvar(fs, fs.nactvar - 1).startpc = fs.pc
-end
-
-------------------------------------------------------------------------
--- parse a local variable declaration statement
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:localstat(ls)
-	-- stat -> LOCAL NAME {',' NAME} ['=' explist1]
-	local nvars = 0
-	local nexps
-	local e = {} -- expdesc
-	repeat
-		self:new_localvar(ls, self:str_checkname(ls), nvars)
-		nvars = nvars + 1
-	until not self:testnext(ls, ",")
-	if self:testnext(ls, "=") then
-		nexps = self:explist1(ls, e)
-	else
-		e.k = "VVOID"
-		nexps = 0
-	end
-	self:adjust_assign(ls, nvars, nexps, e)
-	self:adjustlocalvars(ls, nvars)
-end
-
-------------------------------------------------------------------------
--- parse a function name specification
--- * used in funcstat()
-------------------------------------------------------------------------
-function luaY:funcname(ls, v)
-	-- funcname -> NAME {field} [':' NAME]
-	local needself = false
-	self:singlevar(ls, v)
-	while ls.t.token == "." do
-		self:field(ls, v)
-	end
-	if ls.t.token == ":" then
-		needself = true
-		self:field(ls, v)
-	end
-	return needself
-end
-
-------------------------------------------------------------------------
--- parse a function statement
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:funcstat(ls, line)
-	-- funcstat -> FUNCTION funcname body
-	local v, b = {}, {} -- expdesc
-	luaX:next(ls) -- skip FUNCTION
-	local needself = self:funcname(ls, v)
-	self:body(ls, b, needself, line)
-	luaK:storevar(ls.fs, v, b)
-	luaK:fixline(ls.fs, line) -- definition 'happens' in the first line
-end
-
-------------------------------------------------------------------------
--- parse a function call with no returns or an assignment statement
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:exprstat(ls)
-	-- stat -> func | assignment
-	local fs = ls.fs
-	local v = {} -- LHS_assign
-	v.v = {}
-	self:primaryexp(ls, v.v)
-	if v.v.k == "VCALL" then -- stat -> func
-		luaP:SETARG_C(luaK:getcode(fs, v.v), 1) -- call statement uses no results
-	else -- stat -> assignment
-		v.prev = nil
-		self:assignment(ls, v, 1)
-	end
-end
-
-------------------------------------------------------------------------
--- parse a return statement
--- * used in statements()
-------------------------------------------------------------------------
-function luaY:retstat(ls)
-	-- stat -> RETURN explist
-	local fs = ls.fs
-	local e = {} -- expdesc
-	local first, nret -- registers with returned values
-	luaX:next(ls) -- skip RETURN
-	if self:block_follow(ls.t.token) or ls.t.token == ";" then
-		first, nret = 0, 0 -- return no values
-	else
-		nret = self:explist1(ls, e) -- optional return values
-		if self:hasmultret(e.k) then
-			luaK:setmultret(fs, e)
-			if e.k == "VCALL" and nret == 1 then -- tail call?
-				luaP:SET_OPCODE(luaK:getcode(fs, e), "OP_TAILCALL")
-				lua_assert(luaP:GETARG_A(luaK:getcode(fs, e)) == fs.nactvar)
-			end
-			first = fs.nactvar
-			nret = self.LUA_MULTRET -- return all values
-		else
-			if nret == 1 then -- only one single value?
-				first = luaK:exp2anyreg(fs, e)
-			else
-				luaK:exp2nextreg(fs, e) -- values must go to the 'stack'
-				first = fs.nactvar -- return all 'active' values
-				lua_assert(nret == fs.freereg - first)
-			end
-		end --if
-	end --if
-	luaK:ret(fs, first, nret)
-end
-
-------------------------------------------------------------------------
--- initial parsing for statements, calls a lot of functions
--- * returns boolean instead of 0|1
--- * used in chunk()
-------------------------------------------------------------------------
-function luaY:statement(ls)
-	local line = ls.linenumber -- may be needed for error messages
-	local c = ls.t.token
-	if c == "TK_IF" then -- stat -> ifstat
-		self:ifstat(ls, line)
-		return false
-	elseif c == "TK_WHILE" then -- stat -> whilestat
-		self:whilestat(ls, line)
-		return false
-	elseif c == "TK_DO" then -- stat -> DO block END
-		luaX:next(ls) -- skip DO
-		self:block(ls)
-		self:check_match(ls, "TK_END", "TK_DO", line)
-		return false
-	elseif c == "TK_FOR" then -- stat -> forstat
-		self:forstat(ls, line)
-		return false
-	elseif c == "TK_REPEAT" then -- stat -> repeatstat
-		self:repeatstat(ls, line)
-		return false
-	elseif c == "TK_FUNCTION" then -- stat -> funcstat
-		self:funcstat(ls, line)
-		return false
-	elseif c == "TK_LOCAL" then -- stat -> localstat
-		luaX:next(ls) -- skip LOCAL
-		if self:testnext(ls, "TK_FUNCTION") then -- local function?
-			self:localfunc(ls)
-		else
-			self:localstat(ls)
-		end
-		return false
-	elseif c == "TK_RETURN" then -- stat -> retstat
-		self:retstat(ls)
-		return true -- must be last statement
-	elseif c == "TK_BREAK" then -- stat -> breakstat
-		luaX:next(ls) -- skip BREAK
-		self:breakstat(ls)
-		return true -- must be last statement
-	else
-		self:exprstat(ls)
-		return false -- to avoid warnings
-	end --if c
-end
-
-------------------------------------------------------------------------
--- parse a chunk, which consists of a bunch of statements
--- * used in parser(), body(), block(), repeatstat()
-------------------------------------------------------------------------
-function luaY:chunk(ls)
-	-- chunk -> { stat [';'] }
-	local islast = false
-	self:enterlevel(ls)
-	while not islast and not self:block_follow(ls.t.token) do
-		islast = self:statement(ls)
-		self:testnext(ls, ";")
-		lua_assert(ls.fs.f.maxstacksize >= ls.fs.freereg and ls.fs.freereg >= ls.fs.nactvar)
-		ls.fs.freereg = ls.fs.nactvar -- free registers
-	end
-	self:leavelevel(ls)
-end
-
--- }======================================================================
-
-luaX:init() -- required by llex
-local LuaState = {} -- dummy, not actually used, but retained since
--- the intention is to complete a straight port
-
-------------------------------------------------------------------------
--- interfacing to yueliang
-------------------------------------------------------------------------
-
-return function(source, name)
-	name = name or "compiled-lua"
-	-- luaZ:make_getF returns a file chunk reader
-	-- luaZ:init returns a zio input stream
-	local zio = luaZ:init(luaZ:make_getF(source), nil)
-	if not zio then
-		return
-	end
-	-- luaY:parser parses the input stream
-	-- func is the function prototype in tabular form; in C, func can
-	-- now be used directly by the VM, this can't be done in Lua
-
-	local func = luaY:parser(LuaState, zio, nil, "@" .. name)
-	-- luaU:make_setS returns a string chunk writer
-	local writer, buff = luaU:make_setS()
-	-- luaU:dump builds a binary chunk
-	luaU:dump(LuaState, func, writer, buff)
-	-- a string.dump equivalent in returned
-
-	return buff.data
-end