mirror of
https://github.com/walterschell/Lua.git
synced 2024-11-22 05:04:35 +00:00
Removed 5.4.5
This commit is contained in:
Walter Schell
parent
4af1093b20
commit
51f82cb767
@ -1,312 +0,0 @@
|
|||||||
#!../lua
|
|
||||||
-- $Id: testes/all.lua $
|
|
||||||
-- See Copyright Notice at the end of this file
|
|
||||||
|
|
||||||
|
|
||||||
local version = "Lua 5.4"
|
|
||||||
if _VERSION ~= version then
|
|
||||||
io.stderr:write("This test suite is for ", version,
|
|
||||||
", not for ", _VERSION, "\nExiting tests")
|
|
||||||
return
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
_G.ARG = arg -- save arg for other tests
|
|
||||||
|
|
||||||
|
|
||||||
-- next variables control the execution of some tests
|
|
||||||
-- true means no test (so an undefined variable does not skip a test)
|
|
||||||
-- defaults are for Linux; test everything.
|
|
||||||
-- Make true to avoid long or memory consuming tests
|
|
||||||
_soft = rawget(_G, "_soft") or false
|
|
||||||
-- Make true to avoid non-portable tests
|
|
||||||
_port = rawget(_G, "_port") or false
|
|
||||||
-- Make true to avoid messages about tests not performed
|
|
||||||
_nomsg = rawget(_G, "_nomsg") or false
|
|
||||||
|
|
||||||
|
|
||||||
local usertests = rawget(_G, "_U")
|
|
||||||
|
|
||||||
if usertests then
|
|
||||||
-- tests for sissies ;) Avoid problems
|
|
||||||
_soft = true
|
|
||||||
_port = true
|
|
||||||
_nomsg = true
|
|
||||||
end
|
|
||||||
|
|
||||||
-- tests should require debug when needed
|
|
||||||
debug = nil
|
|
||||||
|
|
||||||
|
|
||||||
if usertests then
|
|
||||||
T = nil -- no "internal" tests for user tests
|
|
||||||
else
|
|
||||||
T = rawget(_G, "T") -- avoid problems with 'strict' module
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--[=[
|
|
||||||
example of a long [comment],
|
|
||||||
[[spanning several [lines]]]
|
|
||||||
|
|
||||||
]=]
|
|
||||||
|
|
||||||
print("\n\tStarting Tests")
|
|
||||||
|
|
||||||
do
|
|
||||||
-- set random seed
|
|
||||||
local random_x, random_y = math.randomseed()
|
|
||||||
print(string.format("random seeds: %d, %d", random_x, random_y))
|
|
||||||
end
|
|
||||||
|
|
||||||
print("current path:\n****" .. package.path .. "****\n")
|
|
||||||
|
|
||||||
|
|
||||||
local initclock = os.clock()
|
|
||||||
local lastclock = initclock
|
|
||||||
local walltime = os.time()
|
|
||||||
|
|
||||||
local collectgarbage = collectgarbage
|
|
||||||
|
|
||||||
do -- (
|
|
||||||
|
|
||||||
-- track messages for tests not performed
|
|
||||||
local msgs = {}
|
|
||||||
function Message (m)
|
|
||||||
if not _nomsg then
|
|
||||||
print(m)
|
|
||||||
msgs[#msgs+1] = string.sub(m, 3, -3)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(os.setlocale"C")
|
|
||||||
|
|
||||||
local T,print,format,write,assert,type,unpack,floor =
|
|
||||||
T,print,string.format,io.write,assert,type,table.unpack,math.floor
|
|
||||||
|
|
||||||
-- use K for 1000 and M for 1000000 (not 2^10 -- 2^20)
|
|
||||||
local function F (m)
|
|
||||||
local function round (m)
|
|
||||||
m = m + 0.04999
|
|
||||||
return format("%.1f", m) -- keep one decimal digit
|
|
||||||
end
|
|
||||||
if m < 1000 then return m
|
|
||||||
else
|
|
||||||
m = m / 1000
|
|
||||||
if m < 1000 then return round(m).."K"
|
|
||||||
else
|
|
||||||
return round(m/1000).."M"
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local Cstacklevel
|
|
||||||
|
|
||||||
local showmem
|
|
||||||
if not T then
|
|
||||||
local max = 0
|
|
||||||
showmem = function ()
|
|
||||||
local m = collectgarbage("count") * 1024
|
|
||||||
max = (m > max) and m or max
|
|
||||||
print(format(" ---- total memory: %s, max memory: %s ----\n",
|
|
||||||
F(m), F(max)))
|
|
||||||
end
|
|
||||||
Cstacklevel = function () return 0 end -- no info about stack level
|
|
||||||
else
|
|
||||||
showmem = function ()
|
|
||||||
T.checkmemory()
|
|
||||||
local total, numblocks, maxmem = T.totalmem()
|
|
||||||
local count = collectgarbage("count")
|
|
||||||
print(format(
|
|
||||||
"\n ---- total memory: %s (%.0fK), max use: %s, blocks: %d\n",
|
|
||||||
F(total), count, F(maxmem), numblocks))
|
|
||||||
print(format("\t(strings: %d, tables: %d, functions: %d, "..
|
|
||||||
"\n\tudata: %d, threads: %d)",
|
|
||||||
T.totalmem"string", T.totalmem"table", T.totalmem"function",
|
|
||||||
T.totalmem"userdata", T.totalmem"thread"))
|
|
||||||
end
|
|
||||||
|
|
||||||
Cstacklevel = function ()
|
|
||||||
local _, _, ncalls = T.stacklevel()
|
|
||||||
return ncalls -- number of C calls
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local Cstack = Cstacklevel()
|
|
||||||
|
|
||||||
--
|
|
||||||
-- redefine dofile to run files through dump/undump
|
|
||||||
--
|
|
||||||
local function report (n) print("\n***** FILE '"..n.."'*****") end
|
|
||||||
local olddofile = dofile
|
|
||||||
local dofile = function (n, strip)
|
|
||||||
showmem()
|
|
||||||
local c = os.clock()
|
|
||||||
print(string.format("time: %g (+%g)", c - initclock, c - lastclock))
|
|
||||||
lastclock = c
|
|
||||||
report(n)
|
|
||||||
local f = assert(loadfile(n))
|
|
||||||
local b = string.dump(f, strip)
|
|
||||||
f = assert(load(b))
|
|
||||||
return f()
|
|
||||||
end
|
|
||||||
|
|
||||||
dofile('main.lua')
|
|
||||||
|
|
||||||
-- trace GC cycles
|
|
||||||
require"tracegc".start()
|
|
||||||
|
|
||||||
report"gc.lua"
|
|
||||||
local f = assert(loadfile('gc.lua'))
|
|
||||||
f()
|
|
||||||
|
|
||||||
dofile('db.lua')
|
|
||||||
assert(dofile('calls.lua') == deep and deep)
|
|
||||||
_G.deep = nil
|
|
||||||
olddofile('strings.lua')
|
|
||||||
olddofile('literals.lua')
|
|
||||||
dofile('tpack.lua')
|
|
||||||
assert(dofile('attrib.lua') == 27)
|
|
||||||
dofile('gengc.lua')
|
|
||||||
assert(dofile('locals.lua') == 5)
|
|
||||||
dofile('constructs.lua')
|
|
||||||
dofile('code.lua', true)
|
|
||||||
if not _G._soft then
|
|
||||||
report('big.lua')
|
|
||||||
local f = coroutine.wrap(assert(loadfile('big.lua')))
|
|
||||||
assert(f() == 'b')
|
|
||||||
assert(f() == 'a')
|
|
||||||
end
|
|
||||||
dofile('cstack.lua')
|
|
||||||
dofile('nextvar.lua')
|
|
||||||
dofile('pm.lua')
|
|
||||||
dofile('utf8.lua')
|
|
||||||
dofile('api.lua')
|
|
||||||
assert(dofile('events.lua') == 12)
|
|
||||||
dofile('vararg.lua')
|
|
||||||
dofile('closure.lua')
|
|
||||||
dofile('coroutine.lua')
|
|
||||||
dofile('goto.lua', true)
|
|
||||||
dofile('errors.lua')
|
|
||||||
dofile('math.lua')
|
|
||||||
dofile('sort.lua', true)
|
|
||||||
dofile('bitwise.lua')
|
|
||||||
assert(dofile('verybig.lua', true) == 10); collectgarbage()
|
|
||||||
dofile('files.lua')
|
|
||||||
|
|
||||||
if #msgs > 0 then
|
|
||||||
local m = table.concat(msgs, "\n ")
|
|
||||||
warn("#tests not performed:\n ", m, "\n")
|
|
||||||
end
|
|
||||||
|
|
||||||
print("(there should be two warnings now)")
|
|
||||||
warn("@on")
|
|
||||||
warn("#This is ", "an expected", " warning")
|
|
||||||
warn("@off")
|
|
||||||
warn("******** THIS WARNING SHOULD NOT APPEAR **********")
|
|
||||||
warn("******** THIS WARNING ALSO SHOULD NOT APPEAR **********")
|
|
||||||
warn("@on")
|
|
||||||
warn("#This is", " another one")
|
|
||||||
|
|
||||||
-- no test module should define 'debug'
|
|
||||||
assert(debug == nil)
|
|
||||||
|
|
||||||
local debug = require "debug"
|
|
||||||
|
|
||||||
print(string.format("%d-bit integers, %d-bit floats",
|
|
||||||
string.packsize("j") * 8, string.packsize("n") * 8))
|
|
||||||
|
|
||||||
debug.sethook(function (a) assert(type(a) == 'string') end, "cr")
|
|
||||||
|
|
||||||
-- to survive outside block
|
|
||||||
_G.showmem = showmem
|
|
||||||
|
|
||||||
|
|
||||||
assert(Cstack == Cstacklevel(),
|
|
||||||
"should be at the same C-stack level it was when started the tests")
|
|
||||||
|
|
||||||
end --)
|
|
||||||
|
|
||||||
local _G, showmem, print, format, clock, time, difftime,
|
|
||||||
assert, open, warn =
|
|
||||||
_G, showmem, print, string.format, os.clock, os.time, os.difftime,
|
|
||||||
assert, io.open, warn
|
|
||||||
|
|
||||||
-- file with time of last performed test
|
|
||||||
local fname = T and "time-debug.txt" or "time.txt"
|
|
||||||
local lasttime
|
|
||||||
|
|
||||||
if not usertests then
|
|
||||||
-- open file with time of last performed test
|
|
||||||
local f = io.open(fname)
|
|
||||||
if f then
|
|
||||||
lasttime = assert(tonumber(f:read'a'))
|
|
||||||
f:close();
|
|
||||||
else -- no such file; assume it is recording time for first time
|
|
||||||
lasttime = nil
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- erase (almost) all globals
|
|
||||||
print('cleaning all!!!!')
|
|
||||||
for n in pairs(_G) do
|
|
||||||
if not ({___Glob = 1, tostring = 1})[n] then
|
|
||||||
_G[n] = undef
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage();showmem()
|
|
||||||
|
|
||||||
local clocktime = clock() - initclock
|
|
||||||
walltime = difftime(time(), walltime)
|
|
||||||
|
|
||||||
print(format("\n\ntotal time: %.2fs (wall time: %gs)\n", clocktime, walltime))
|
|
||||||
|
|
||||||
if not usertests then
|
|
||||||
lasttime = lasttime or clocktime -- if no last time, ignore difference
|
|
||||||
-- check whether current test time differs more than 5% from last time
|
|
||||||
local diff = (clocktime - lasttime) / lasttime
|
|
||||||
local tolerance = 0.05 -- 5%
|
|
||||||
if (diff >= tolerance or diff <= -tolerance) then
|
|
||||||
warn(format("#time difference from previous test: %+.1f%%",
|
|
||||||
diff * 100))
|
|
||||||
end
|
|
||||||
assert(open(fname, "w")):write(clocktime):close()
|
|
||||||
end
|
|
||||||
|
|
||||||
print("final OK !!!")
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
--[[
|
|
||||||
*****************************************************************************
|
|
||||||
* Copyright (C) 1994-2016 Lua.org, PUC-Rio.
|
|
||||||
*
|
|
||||||
* Permission is hereby granted, free of charge, to any person obtaining
|
|
||||||
* a copy of this software and associated documentation files (the
|
|
||||||
* "Software"), to deal in the Software without restriction, including
|
|
||||||
* without limitation the rights to use, copy, modify, merge, publish,
|
|
||||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
||||||
* permit persons to whom the Software is furnished to do so, subject to
|
|
||||||
* the following conditions:
|
|
||||||
*
|
|
||||||
* The above copyright notice and this permission notice shall be
|
|
||||||
* included in all copies or substantial portions of the Software.
|
|
||||||
*
|
|
||||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
||||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
||||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
||||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
||||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
||||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
*****************************************************************************
|
|
||||||
]]
|
|
||||||
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,527 +0,0 @@
|
|||||||
-- $Id: testes/attrib.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print "testing require"
|
|
||||||
|
|
||||||
assert(require"string" == string)
|
|
||||||
assert(require"math" == math)
|
|
||||||
assert(require"table" == table)
|
|
||||||
assert(require"io" == io)
|
|
||||||
assert(require"os" == os)
|
|
||||||
assert(require"coroutine" == coroutine)
|
|
||||||
|
|
||||||
assert(type(package.path) == "string")
|
|
||||||
assert(type(package.cpath) == "string")
|
|
||||||
assert(type(package.loaded) == "table")
|
|
||||||
assert(type(package.preload) == "table")
|
|
||||||
|
|
||||||
assert(type(package.config) == "string")
|
|
||||||
print("package config: "..string.gsub(package.config, "\n", "|"))
|
|
||||||
|
|
||||||
do
|
|
||||||
-- create a path with 'max' templates,
|
|
||||||
-- each with 1-10 repetitions of '?'
|
|
||||||
local max = _soft and 100 or 2000
|
|
||||||
local t = {}
|
|
||||||
for i = 1,max do t[i] = string.rep("?", i%10 + 1) end
|
|
||||||
t[#t + 1] = ";" -- empty template
|
|
||||||
local path = table.concat(t, ";")
|
|
||||||
-- use that path in a search
|
|
||||||
local s, err = package.searchpath("xuxu", path)
|
|
||||||
-- search fails; check that message has an occurrence of
|
|
||||||
-- '??????????' with ? replaced by xuxu and at least 'max' lines
|
|
||||||
assert(not s and
|
|
||||||
string.find(err, string.rep("xuxu", 10)) and
|
|
||||||
#string.gsub(err, "[^\n]", "") >= max)
|
|
||||||
-- path with one very long template
|
|
||||||
local path = string.rep("?", max)
|
|
||||||
local s, err = package.searchpath("xuxu", path)
|
|
||||||
assert(not s and string.find(err, string.rep('xuxu', max)))
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local oldpath = package.path
|
|
||||||
package.path = {}
|
|
||||||
local s, err = pcall(require, "no-such-file")
|
|
||||||
assert(not s and string.find(err, "package.path"))
|
|
||||||
package.path = oldpath
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do print"testing 'require' message"
|
|
||||||
local oldpath = package.path
|
|
||||||
local oldcpath = package.cpath
|
|
||||||
|
|
||||||
package.path = "?.lua;?/?"
|
|
||||||
package.cpath = "?.so;?/init"
|
|
||||||
|
|
||||||
local st, msg = pcall(require, 'XXX')
|
|
||||||
|
|
||||||
local expected = [[module 'XXX' not found:
|
|
||||||
no field package.preload['XXX']
|
|
||||||
no file 'XXX.lua'
|
|
||||||
no file 'XXX/XXX'
|
|
||||||
no file 'XXX.so'
|
|
||||||
no file 'XXX/init']]
|
|
||||||
|
|
||||||
assert(msg == expected)
|
|
||||||
|
|
||||||
package.path = oldpath
|
|
||||||
package.cpath = oldcpath
|
|
||||||
end
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
|
|
||||||
-- The next tests for 'require' assume some specific directories and
|
|
||||||
-- libraries.
|
|
||||||
|
|
||||||
if not _port then --[
|
|
||||||
|
|
||||||
local dirsep = string.match(package.config, "^([^\n]+)\n")
|
|
||||||
|
|
||||||
-- auxiliary directory with C modules and temporary files
|
|
||||||
local DIR = "libs" .. dirsep
|
|
||||||
|
|
||||||
-- prepend DIR to a name and correct directory separators
|
|
||||||
local function D (x)
|
|
||||||
local x = string.gsub(x, "/", dirsep)
|
|
||||||
return DIR .. x
|
|
||||||
end
|
|
||||||
|
|
||||||
-- prepend DIR and pospend proper C lib. extension to a name
|
|
||||||
local function DC (x)
|
|
||||||
local ext = (dirsep == '\\') and ".dll" or ".so"
|
|
||||||
return D(x .. ext)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function createfiles (files, preextras, posextras)
|
|
||||||
for n,c in pairs(files) do
|
|
||||||
io.output(D(n))
|
|
||||||
io.write(string.format(preextras, n))
|
|
||||||
io.write(c)
|
|
||||||
io.write(string.format(posextras, n))
|
|
||||||
io.close(io.output())
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function removefiles (files)
|
|
||||||
for n in pairs(files) do
|
|
||||||
os.remove(D(n))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local files = {
|
|
||||||
["names.lua"] = "do return {...} end\n",
|
|
||||||
["err.lua"] = "B = 15; a = a + 1;",
|
|
||||||
["synerr.lua"] = "B =",
|
|
||||||
["A.lua"] = "",
|
|
||||||
["B.lua"] = "assert(...=='B');require 'A'",
|
|
||||||
["A.lc"] = "",
|
|
||||||
["A"] = "",
|
|
||||||
["L"] = "",
|
|
||||||
["XXxX"] = "",
|
|
||||||
["C.lua"] = "package.loaded[...] = 25; require'C'",
|
|
||||||
}
|
|
||||||
|
|
||||||
AA = nil
|
|
||||||
local extras = [[
|
|
||||||
NAME = '%s'
|
|
||||||
REQUIRED = ...
|
|
||||||
return AA]]
|
|
||||||
|
|
||||||
createfiles(files, "", extras)
|
|
||||||
|
|
||||||
-- testing explicit "dir" separator in 'searchpath'
|
|
||||||
assert(package.searchpath("C.lua", D"?", "", "") == D"C.lua")
|
|
||||||
assert(package.searchpath("C.lua", D"?", ".", ".") == D"C.lua")
|
|
||||||
assert(package.searchpath("--x-", D"?", "-", "X") == D"XXxX")
|
|
||||||
assert(package.searchpath("---xX", D"?", "---", "XX") == D"XXxX")
|
|
||||||
assert(package.searchpath(D"C.lua", "?", dirsep) == D"C.lua")
|
|
||||||
assert(package.searchpath(".\\C.lua", D"?", "\\") == D"./C.lua")
|
|
||||||
|
|
||||||
local oldpath = package.path
|
|
||||||
|
|
||||||
package.path = string.gsub("D/?.lua;D/?.lc;D/?;D/??x?;D/L", "D/", DIR)
|
|
||||||
|
|
||||||
local try = function (p, n, r, ext)
|
|
||||||
NAME = nil
|
|
||||||
local rr, x = require(p)
|
|
||||||
assert(NAME == n)
|
|
||||||
assert(REQUIRED == p)
|
|
||||||
assert(rr == r)
|
|
||||||
assert(ext == x)
|
|
||||||
end
|
|
||||||
|
|
||||||
local a = require"names"
|
|
||||||
assert(a[1] == "names" and a[2] == D"names.lua")
|
|
||||||
|
|
||||||
local st, msg = pcall(require, "err")
|
|
||||||
assert(not st and string.find(msg, "arithmetic") and B == 15)
|
|
||||||
st, msg = pcall(require, "synerr")
|
|
||||||
assert(not st and string.find(msg, "error loading module"))
|
|
||||||
|
|
||||||
assert(package.searchpath("C", package.path) == D"C.lua")
|
|
||||||
assert(require"C" == 25)
|
|
||||||
assert(require"C" == 25)
|
|
||||||
AA = nil
|
|
||||||
try('B', 'B.lua', true, "libs/B.lua")
|
|
||||||
assert(package.loaded.B)
|
|
||||||
assert(require"B" == true)
|
|
||||||
assert(package.loaded.A)
|
|
||||||
assert(require"C" == 25)
|
|
||||||
package.loaded.A = nil
|
|
||||||
try('B', nil, true, nil) -- should not reload package
|
|
||||||
try('A', 'A.lua', true, "libs/A.lua")
|
|
||||||
package.loaded.A = nil
|
|
||||||
os.remove(D'A.lua')
|
|
||||||
AA = {}
|
|
||||||
try('A', 'A.lc', AA, "libs/A.lc") -- now must find second option
|
|
||||||
assert(package.searchpath("A", package.path) == D"A.lc")
|
|
||||||
assert(require("A") == AA)
|
|
||||||
AA = false
|
|
||||||
try('K', 'L', false, "libs/L") -- default option
|
|
||||||
try('K', 'L', false, "libs/L") -- default option (should reload it)
|
|
||||||
assert(rawget(_G, "_REQUIREDNAME") == nil)
|
|
||||||
|
|
||||||
AA = "x"
|
|
||||||
try("X", "XXxX", AA, "libs/XXxX")
|
|
||||||
|
|
||||||
|
|
||||||
removefiles(files)
|
|
||||||
NAME, REQUIRED, AA, B = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- testing require of sub-packages
|
|
||||||
|
|
||||||
local _G = _G
|
|
||||||
|
|
||||||
package.path = string.gsub("D/?.lua;D/?/init.lua", "D/", DIR)
|
|
||||||
|
|
||||||
files = {
|
|
||||||
["P1/init.lua"] = "AA = 10",
|
|
||||||
["P1/xuxu.lua"] = "AA = 20",
|
|
||||||
}
|
|
||||||
|
|
||||||
createfiles(files, "_ENV = {}\n", "\nreturn _ENV\n")
|
|
||||||
AA = 0
|
|
||||||
|
|
||||||
local m, ext = assert(require"P1")
|
|
||||||
assert(ext == "libs/P1/init.lua")
|
|
||||||
assert(AA == 0 and m.AA == 10)
|
|
||||||
assert(require"P1" == m)
|
|
||||||
assert(require"P1" == m)
|
|
||||||
|
|
||||||
assert(package.searchpath("P1.xuxu", package.path) == D"P1/xuxu.lua")
|
|
||||||
m.xuxu, ext = assert(require"P1.xuxu")
|
|
||||||
assert(AA == 0 and m.xuxu.AA == 20)
|
|
||||||
assert(ext == "libs/P1/xuxu.lua")
|
|
||||||
assert(require"P1.xuxu" == m.xuxu)
|
|
||||||
assert(require"P1.xuxu" == m.xuxu)
|
|
||||||
assert(require"P1" == m and m.AA == 10)
|
|
||||||
|
|
||||||
|
|
||||||
removefiles(files)
|
|
||||||
AA = nil
|
|
||||||
|
|
||||||
package.path = ""
|
|
||||||
assert(not pcall(require, "file_does_not_exist"))
|
|
||||||
package.path = "??\0?"
|
|
||||||
assert(not pcall(require, "file_does_not_exist1"))
|
|
||||||
|
|
||||||
package.path = oldpath
|
|
||||||
|
|
||||||
-- check 'require' error message
|
|
||||||
local fname = "file_does_not_exist2"
|
|
||||||
local m, err = pcall(require, fname)
|
|
||||||
for t in string.gmatch(package.path..";"..package.cpath, "[^;]+") do
|
|
||||||
t = string.gsub(t, "?", fname)
|
|
||||||
assert(string.find(err, t, 1, true))
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- testing 'package.searchers' not being a table
|
|
||||||
local searchers = package.searchers
|
|
||||||
package.searchers = 3
|
|
||||||
local st, msg = pcall(require, 'a')
|
|
||||||
assert(not st and string.find(msg, "must be a table"))
|
|
||||||
package.searchers = searchers
|
|
||||||
end
|
|
||||||
|
|
||||||
local function import(...)
|
|
||||||
local f = {...}
|
|
||||||
return function (m)
|
|
||||||
for i=1, #f do m[f[i]] = _G[f[i]] end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- cannot change environment of a C function
|
|
||||||
assert(not pcall(module, 'XUXU'))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
-- testing require of C libraries
|
|
||||||
|
|
||||||
|
|
||||||
local p = "" -- On Mac OS X, redefine this to "_"
|
|
||||||
|
|
||||||
-- check whether loadlib works in this system
|
|
||||||
local st, err, when = package.loadlib(DC"lib1", "*")
|
|
||||||
if not st then
|
|
||||||
local f, err, when = package.loadlib("donotexist", p.."xuxu")
|
|
||||||
assert(not f and type(err) == "string" and when == "absent")
|
|
||||||
;(Message or print)('\n >>> cannot load dynamic library <<<\n')
|
|
||||||
print(err, when)
|
|
||||||
else
|
|
||||||
-- tests for loadlib
|
|
||||||
local f = assert(package.loadlib(DC"lib1", p.."onefunction"))
|
|
||||||
local a, b = f(15, 25)
|
|
||||||
assert(a == 25 and b == 15)
|
|
||||||
|
|
||||||
f = assert(package.loadlib(DC"lib1", p.."anotherfunc"))
|
|
||||||
assert(f(10, 20) == "10%20\n")
|
|
||||||
|
|
||||||
-- check error messages
|
|
||||||
local f, err, when = package.loadlib(DC"lib1", p.."xuxu")
|
|
||||||
assert(not f and type(err) == "string" and when == "init")
|
|
||||||
f, err, when = package.loadlib("donotexist", p.."xuxu")
|
|
||||||
assert(not f and type(err) == "string" and when == "open")
|
|
||||||
|
|
||||||
-- symbols from 'lib1' must be visible to other libraries
|
|
||||||
f = assert(package.loadlib(DC"lib11", p.."luaopen_lib11"))
|
|
||||||
assert(f() == "exported")
|
|
||||||
|
|
||||||
-- test C modules with prefixes in names
|
|
||||||
package.cpath = DC"?"
|
|
||||||
local lib2, ext = require"lib2-v2"
|
|
||||||
assert(string.find(ext, "libs/lib2-v2", 1, true))
|
|
||||||
-- check correct access to global environment and correct
|
|
||||||
-- parameters
|
|
||||||
assert(_ENV.x == "lib2-v2" and _ENV.y == DC"lib2-v2")
|
|
||||||
assert(lib2.id("x") == true) -- a different "id" implementation
|
|
||||||
|
|
||||||
-- test C submodules
|
|
||||||
local fs, ext = require"lib1.sub"
|
|
||||||
assert(_ENV.x == "lib1.sub" and _ENV.y == DC"lib1")
|
|
||||||
assert(string.find(ext, "libs/lib1", 1, true))
|
|
||||||
assert(fs.id(45) == 45)
|
|
||||||
_ENV.x, _ENV.y = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
_ENV = _G
|
|
||||||
|
|
||||||
|
|
||||||
-- testing preload
|
|
||||||
|
|
||||||
do
|
|
||||||
local p = package
|
|
||||||
package = {}
|
|
||||||
p.preload.pl = function (...)
|
|
||||||
local _ENV = {...}
|
|
||||||
function xuxu (x) return x+20 end
|
|
||||||
return _ENV
|
|
||||||
end
|
|
||||||
|
|
||||||
local pl, ext = require"pl"
|
|
||||||
assert(require"pl" == pl)
|
|
||||||
assert(pl.xuxu(10) == 30)
|
|
||||||
assert(pl[1] == "pl" and pl[2] == ":preload:" and ext == ":preload:")
|
|
||||||
|
|
||||||
package = p
|
|
||||||
assert(type(package.path) == "string")
|
|
||||||
end
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
end --]
|
|
||||||
|
|
||||||
print("testing assignments, logical operators, and constructors")
|
|
||||||
|
|
||||||
local res, res2 = 27
|
|
||||||
|
|
||||||
local a, b = 1, 2+3
|
|
||||||
assert(a==1 and b==5)
|
|
||||||
a={}
|
|
||||||
local function f() return 10, 11, 12 end
|
|
||||||
a.x, b, a[1] = 1, 2, f()
|
|
||||||
assert(a.x==1 and b==2 and a[1]==10)
|
|
||||||
a[f()], b, a[f()+3] = f(), a, 'x'
|
|
||||||
assert(a[10] == 10 and b == a and a[13] == 'x')
|
|
||||||
|
|
||||||
do
|
|
||||||
local f = function (n) local x = {}; for i=1,n do x[i]=i end;
|
|
||||||
return table.unpack(x) end;
|
|
||||||
local a,b,c
|
|
||||||
a,b = 0, f(1)
|
|
||||||
assert(a == 0 and b == 1)
|
|
||||||
a,b = 0, f(1)
|
|
||||||
assert(a == 0 and b == 1)
|
|
||||||
a,b,c = 0,5,f(4)
|
|
||||||
assert(a==0 and b==5 and c==1)
|
|
||||||
a,b,c = 0,5,f(0)
|
|
||||||
assert(a==0 and b==5 and c==nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
local a, b, c, d = 1 and nil, 1 or nil, (1 and (nil or 1)), 6
|
|
||||||
assert(not a and b and c and d==6)
|
|
||||||
|
|
||||||
d = 20
|
|
||||||
a, b, c, d = f()
|
|
||||||
assert(a==10 and b==11 and c==12 and d==nil)
|
|
||||||
a,b = f(), 1, 2, 3, f()
|
|
||||||
assert(a==10 and b==1)
|
|
||||||
|
|
||||||
assert(a<b == false and a>b == true)
|
|
||||||
assert((10 and 2) == 2)
|
|
||||||
assert((10 or 2) == 10)
|
|
||||||
assert((10 or assert(nil)) == 10)
|
|
||||||
assert(not (nil and assert(nil)))
|
|
||||||
assert((nil or "alo") == "alo")
|
|
||||||
assert((nil and 10) == nil)
|
|
||||||
assert((false and 10) == false)
|
|
||||||
assert((true or 10) == true)
|
|
||||||
assert((false or 10) == 10)
|
|
||||||
assert(false ~= nil)
|
|
||||||
assert(nil ~= false)
|
|
||||||
assert(not nil == true)
|
|
||||||
assert(not not nil == false)
|
|
||||||
assert(not not 1 == true)
|
|
||||||
assert(not not a == true)
|
|
||||||
assert(not not (6 or nil) == true)
|
|
||||||
assert(not not (nil and 56) == false)
|
|
||||||
assert(not not (nil and true) == false)
|
|
||||||
assert(not 10 == false)
|
|
||||||
assert(not {} == false)
|
|
||||||
assert(not 0.5 == false)
|
|
||||||
assert(not "x" == false)
|
|
||||||
|
|
||||||
assert({} ~= {})
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
a[true] = 20
|
|
||||||
a[false] = 10
|
|
||||||
assert(a[1<2] == 20 and a[1>2] == 10)
|
|
||||||
|
|
||||||
function f(a) return a end
|
|
||||||
|
|
||||||
local a = {}
|
|
||||||
for i=3000,-3000,-1 do a[i + 0.0] = i; end
|
|
||||||
a[10e30] = "alo"; a[true] = 10; a[false] = 20
|
|
||||||
assert(a[10e30] == 'alo' and a[not 1] == 20 and a[10<20] == 10)
|
|
||||||
for i=3000,-3000,-1 do assert(a[i] == i); end
|
|
||||||
a[print] = assert
|
|
||||||
a[f] = print
|
|
||||||
a[a] = a
|
|
||||||
assert(a[a][a][a][a][print] == assert)
|
|
||||||
a[print](a[a[f]] == a[print])
|
|
||||||
assert(not pcall(function () local a = {}; a[nil] = 10 end))
|
|
||||||
assert(not pcall(function () local a = {[nil] = 10} end))
|
|
||||||
assert(a[nil] == undef)
|
|
||||||
a = nil
|
|
||||||
|
|
||||||
local a, b, c
|
|
||||||
a = {10,9,8,7,6,5,4,3,2; [-3]='a', [f]=print, a='a', b='ab'}
|
|
||||||
a, a.x, a.y = a, a[-3]
|
|
||||||
assert(a[1]==10 and a[-3]==a.a and a[f]==print and a.x=='a' and not a.y)
|
|
||||||
a[1], f(a)[2], b, c = {['alo']=assert}, 10, a[1], a[f], 6, 10, 23, f(a), 2
|
|
||||||
a[1].alo(a[2]==10 and b==10 and c==print)
|
|
||||||
|
|
||||||
a.aVeryLongName012345678901234567890123456789012345678901234567890123456789 = 10
|
|
||||||
local function foo ()
|
|
||||||
return a.aVeryLongName012345678901234567890123456789012345678901234567890123456789
|
|
||||||
end
|
|
||||||
assert(foo() == 10 and
|
|
||||||
a.aVeryLongName012345678901234567890123456789012345678901234567890123456789 ==
|
|
||||||
10)
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
-- _ENV constant
|
|
||||||
local function foo ()
|
|
||||||
local _ENV <const> = 11
|
|
||||||
X = "hi"
|
|
||||||
end
|
|
||||||
local st, msg = pcall(foo)
|
|
||||||
assert(not st and string.find(msg, "number"))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- test of large float/integer indices
|
|
||||||
|
|
||||||
-- compute maximum integer where all bits fit in a float
|
|
||||||
local maxint = math.maxinteger
|
|
||||||
|
|
||||||
-- trim (if needed) to fit in a float
|
|
||||||
while maxint ~= (maxint + 0.0) or (maxint - 1) ~= (maxint - 1.0) do
|
|
||||||
maxint = maxint // 2
|
|
||||||
end
|
|
||||||
|
|
||||||
local maxintF = maxint + 0.0 -- float version
|
|
||||||
|
|
||||||
assert(maxintF == maxint and math.type(maxintF) == "float" and
|
|
||||||
maxintF >= 2.0^14)
|
|
||||||
|
|
||||||
-- floats and integers must index the same places
|
|
||||||
a[maxintF] = 10; a[maxintF - 1.0] = 11;
|
|
||||||
a[-maxintF] = 12; a[-maxintF + 1.0] = 13;
|
|
||||||
|
|
||||||
assert(a[maxint] == 10 and a[maxint - 1] == 11 and
|
|
||||||
a[-maxint] == 12 and a[-maxint + 1] == 13)
|
|
||||||
|
|
||||||
a[maxint] = 20
|
|
||||||
a[-maxint] = 22
|
|
||||||
|
|
||||||
assert(a[maxintF] == 20 and a[maxintF - 1.0] == 11 and
|
|
||||||
a[-maxintF] == 22 and a[-maxintF + 1.0] == 13)
|
|
||||||
|
|
||||||
a = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- test conflicts in multiple assignment
|
|
||||||
do
|
|
||||||
local a,i,j,b
|
|
||||||
a = {'a', 'b'}; i=1; j=2; b=a
|
|
||||||
i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i
|
|
||||||
assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and
|
|
||||||
b[3] == 1)
|
|
||||||
a = {}
|
|
||||||
local function foo () -- assigining to upvalues
|
|
||||||
b, a.x, a = a, 10, 20
|
|
||||||
end
|
|
||||||
foo()
|
|
||||||
assert(a == 20 and b.x == 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- repeat test with upvalues
|
|
||||||
do
|
|
||||||
local a,i,j,b
|
|
||||||
a = {'a', 'b'}; i=1; j=2; b=a
|
|
||||||
local function foo ()
|
|
||||||
i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i
|
|
||||||
end
|
|
||||||
foo()
|
|
||||||
assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and
|
|
||||||
b[3] == 1)
|
|
||||||
local t = {}
|
|
||||||
(function (a) t[a], a = 10, 20 end)(1);
|
|
||||||
assert(t[1] == 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- bug in 5.2 beta
|
|
||||||
local function foo ()
|
|
||||||
local a
|
|
||||||
return function ()
|
|
||||||
local b
|
|
||||||
a, b = 3, 14 -- local and upvalue have same index
|
|
||||||
return a, b
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local a, b = foo()()
|
|
||||||
assert(a == 3 and b == 14)
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
|
|
||||||
return res
|
|
||||||
|
|
||||||
@ -1,82 +0,0 @@
|
|||||||
-- $Id: testes/big.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
if _soft then
|
|
||||||
return 'a'
|
|
||||||
end
|
|
||||||
|
|
||||||
print "testing large tables"
|
|
||||||
|
|
||||||
local debug = require"debug"
|
|
||||||
|
|
||||||
local lim = 2^18 + 1000
|
|
||||||
local prog = { "local y = {0" }
|
|
||||||
for i = 1, lim do prog[#prog + 1] = i end
|
|
||||||
prog[#prog + 1] = "}\n"
|
|
||||||
prog[#prog + 1] = "X = y\n"
|
|
||||||
prog[#prog + 1] = ("assert(X[%d] == %d)"):format(lim - 1, lim - 2)
|
|
||||||
prog[#prog + 1] = "return 0"
|
|
||||||
prog = table.concat(prog, ";")
|
|
||||||
|
|
||||||
local env = {string = string, assert = assert}
|
|
||||||
local f = assert(load(prog, nil, nil, env))
|
|
||||||
|
|
||||||
f()
|
|
||||||
assert(env.X[lim] == lim - 1 and env.X[lim + 1] == lim)
|
|
||||||
for k in pairs(env) do env[k] = undef end
|
|
||||||
|
|
||||||
-- yields during accesses larger than K (in RK)
|
|
||||||
setmetatable(env, {
|
|
||||||
__index = function (t, n) coroutine.yield('g'); return _G[n] end,
|
|
||||||
__newindex = function (t, n, v) coroutine.yield('s'); _G[n] = v end,
|
|
||||||
})
|
|
||||||
|
|
||||||
X = nil
|
|
||||||
local co = coroutine.wrap(f)
|
|
||||||
assert(co() == 's')
|
|
||||||
assert(co() == 'g')
|
|
||||||
assert(co() == 'g')
|
|
||||||
assert(co() == 0)
|
|
||||||
|
|
||||||
assert(X[lim] == lim - 1 and X[lim + 1] == lim)
|
|
||||||
|
|
||||||
-- errors in accesses larger than K (in RK)
|
|
||||||
getmetatable(env).__index = function () end
|
|
||||||
getmetatable(env).__newindex = function () end
|
|
||||||
local e, m = pcall(f)
|
|
||||||
assert(not e and m:find("global 'X'"))
|
|
||||||
|
|
||||||
-- errors in metamethods
|
|
||||||
getmetatable(env).__newindex = function () error("hi") end
|
|
||||||
local e, m = xpcall(f, debug.traceback)
|
|
||||||
assert(not e and m:find("'newindex'"))
|
|
||||||
|
|
||||||
f, X = nil
|
|
||||||
|
|
||||||
coroutine.yield'b'
|
|
||||||
|
|
||||||
if 2^32 == 0 then -- (small integers) {
|
|
||||||
|
|
||||||
print "testing string length overflow"
|
|
||||||
|
|
||||||
local repstrings = 192 -- number of strings to be concatenated
|
|
||||||
local ssize = math.ceil(2.0^32 / repstrings) + 1 -- size of each string
|
|
||||||
|
|
||||||
assert(repstrings * ssize > 2.0^32) -- it should be larger than maximum size
|
|
||||||
|
|
||||||
local longs = string.rep("\0", ssize) -- create one long string
|
|
||||||
|
|
||||||
-- create function to concatenate 'repstrings' copies of its argument
|
|
||||||
local rep = assert(load(
|
|
||||||
"local a = ...; return " .. string.rep("a", repstrings, "..")))
|
|
||||||
|
|
||||||
local a, b = pcall(rep, longs) -- call that function
|
|
||||||
|
|
||||||
-- it should fail without creating string (result would be too large)
|
|
||||||
assert(not a and string.find(b, "overflow"))
|
|
||||||
|
|
||||||
end -- }
|
|
||||||
|
|
||||||
print'OK'
|
|
||||||
|
|
||||||
return 'a'
|
|
||||||
@ -1,363 +0,0 @@
|
|||||||
-- $Id: testes/bitwise.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print("testing bitwise operations")
|
|
||||||
|
|
||||||
require "bwcoercion"
|
|
||||||
|
|
||||||
local numbits = string.packsize('j') * 8
|
|
||||||
|
|
||||||
assert(~0 == -1)
|
|
||||||
|
|
||||||
assert((1 << (numbits - 1)) == math.mininteger)
|
|
||||||
|
|
||||||
-- basic tests for bitwise operators;
|
|
||||||
-- use variables to avoid constant folding
|
|
||||||
local a, b, c, d
|
|
||||||
a = 0xFFFFFFFFFFFFFFFF
|
|
||||||
assert(a == -1 and a & -1 == a and a & 35 == 35)
|
|
||||||
a = 0xF0F0F0F0F0F0F0F0
|
|
||||||
assert(a | -1 == -1)
|
|
||||||
assert(a ~ a == 0 and a ~ 0 == a and a ~ ~a == -1)
|
|
||||||
assert(a >> 4 == ~a)
|
|
||||||
a = 0xF0; b = 0xCC; c = 0xAA; d = 0xFD
|
|
||||||
assert(a | b ~ c & d == 0xF4)
|
|
||||||
|
|
||||||
a = 0xF0.0; b = 0xCC.0; c = "0xAA.0"; d = "0xFD.0"
|
|
||||||
assert(a | b ~ c & d == 0xF4)
|
|
||||||
|
|
||||||
a = 0xF0000000; b = 0xCC000000;
|
|
||||||
c = 0xAA000000; d = 0xFD000000
|
|
||||||
assert(a | b ~ c & d == 0xF4000000)
|
|
||||||
assert(~~a == a and ~a == -1 ~ a and -d == ~d + 1)
|
|
||||||
|
|
||||||
a = a << 32
|
|
||||||
b = b << 32
|
|
||||||
c = c << 32
|
|
||||||
d = d << 32
|
|
||||||
assert(a | b ~ c & d == 0xF4000000 << 32)
|
|
||||||
assert(~~a == a and ~a == -1 ~ a and -d == ~d + 1)
|
|
||||||
|
|
||||||
|
|
||||||
do -- constant folding
|
|
||||||
local code = string.format("return -1 >> %d", math.maxinteger)
|
|
||||||
assert(load(code)() == 0)
|
|
||||||
local code = string.format("return -1 >> %d", math.mininteger)
|
|
||||||
assert(load(code)() == 0)
|
|
||||||
local code = string.format("return -1 << %d", math.maxinteger)
|
|
||||||
assert(load(code)() == 0)
|
|
||||||
local code = string.format("return -1 << %d", math.mininteger)
|
|
||||||
assert(load(code)() == 0)
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(-1 >> 1 == (1 << (numbits - 1)) - 1 and 1 << 31 == 0x80000000)
|
|
||||||
assert(-1 >> (numbits - 1) == 1)
|
|
||||||
assert(-1 >> numbits == 0 and
|
|
||||||
-1 >> -numbits == 0 and
|
|
||||||
-1 << numbits == 0 and
|
|
||||||
-1 << -numbits == 0)
|
|
||||||
|
|
||||||
assert(1 >> math.mininteger == 0)
|
|
||||||
assert(1 >> math.maxinteger == 0)
|
|
||||||
assert(1 << math.mininteger == 0)
|
|
||||||
assert(1 << math.maxinteger == 0)
|
|
||||||
|
|
||||||
assert((2^30 - 1) << 2^30 == 0)
|
|
||||||
assert((2^30 - 1) >> 2^30 == 0)
|
|
||||||
|
|
||||||
assert(1 >> -3 == 1 << 3 and 1000 >> 5 == 1000 << -5)
|
|
||||||
|
|
||||||
|
|
||||||
-- coercion from strings to integers
|
|
||||||
assert("0xffffffffffffffff" | 0 == -1)
|
|
||||||
assert("0xfffffffffffffffe" & "-1" == -2)
|
|
||||||
assert(" \t-0xfffffffffffffffe\n\t" & "-1" == 2)
|
|
||||||
assert(" \n -45 \t " >> " -2 " == -45 * 4)
|
|
||||||
assert("1234.0" << "5.0" == 1234 * 32)
|
|
||||||
assert("0xffff.0" ~ "0xAAAA" == 0x5555)
|
|
||||||
assert(~"0x0.000p4" == -1)
|
|
||||||
|
|
||||||
assert(("7" .. 3) << 1 == 146)
|
|
||||||
assert(0xffffffff >> (1 .. "9") == 0x1fff)
|
|
||||||
assert(10 | (1 .. "9") == 27)
|
|
||||||
|
|
||||||
do
|
|
||||||
local st, msg = pcall(function () return 4 & "a" end)
|
|
||||||
assert(string.find(msg, "'band'"))
|
|
||||||
|
|
||||||
local st, msg = pcall(function () return ~"a" end)
|
|
||||||
assert(string.find(msg, "'bnot'"))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- out of range number
|
|
||||||
assert(not pcall(function () return "0xffffffffffffffff.0" | 0 end))
|
|
||||||
|
|
||||||
-- embedded zeros
|
|
||||||
assert(not pcall(function () return "0xffffffffffffffff\0" | 0 end))
|
|
||||||
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
|
|
||||||
package.preload.bit32 = function () --{
|
|
||||||
|
|
||||||
-- no built-in 'bit32' library: implement it using bitwise operators
|
|
||||||
|
|
||||||
local bit = {}
|
|
||||||
|
|
||||||
function bit.bnot (a)
|
|
||||||
return ~a & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--
|
|
||||||
-- in all vararg functions, avoid creating 'arg' table when there are
|
|
||||||
-- only 2 (or less) parameters, as 2 parameters is the common case
|
|
||||||
--
|
|
||||||
|
|
||||||
function bit.band (x, y, z, ...)
|
|
||||||
if not z then
|
|
||||||
return ((x or -1) & (y or -1)) & 0xFFFFFFFF
|
|
||||||
else
|
|
||||||
local arg = {...}
|
|
||||||
local res = x & y & z
|
|
||||||
for i = 1, #arg do res = res & arg[i] end
|
|
||||||
return res & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.bor (x, y, z, ...)
|
|
||||||
if not z then
|
|
||||||
return ((x or 0) | (y or 0)) & 0xFFFFFFFF
|
|
||||||
else
|
|
||||||
local arg = {...}
|
|
||||||
local res = x | y | z
|
|
||||||
for i = 1, #arg do res = res | arg[i] end
|
|
||||||
return res & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.bxor (x, y, z, ...)
|
|
||||||
if not z then
|
|
||||||
return ((x or 0) ~ (y or 0)) & 0xFFFFFFFF
|
|
||||||
else
|
|
||||||
local arg = {...}
|
|
||||||
local res = x ~ y ~ z
|
|
||||||
for i = 1, #arg do res = res ~ arg[i] end
|
|
||||||
return res & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.btest (...)
|
|
||||||
return bit.band(...) ~= 0
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.lshift (a, b)
|
|
||||||
return ((a & 0xFFFFFFFF) << b) & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.rshift (a, b)
|
|
||||||
return ((a & 0xFFFFFFFF) >> b) & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.arshift (a, b)
|
|
||||||
a = a & 0xFFFFFFFF
|
|
||||||
if b <= 0 or (a & 0x80000000) == 0 then
|
|
||||||
return (a >> b) & 0xFFFFFFFF
|
|
||||||
else
|
|
||||||
return ((a >> b) | ~(0xFFFFFFFF >> b)) & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.lrotate (a ,b)
|
|
||||||
b = b & 31
|
|
||||||
a = a & 0xFFFFFFFF
|
|
||||||
a = (a << b) | (a >> (32 - b))
|
|
||||||
return a & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.rrotate (a, b)
|
|
||||||
return bit.lrotate(a, -b)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checkfield (f, w)
|
|
||||||
w = w or 1
|
|
||||||
assert(f >= 0, "field cannot be negative")
|
|
||||||
assert(w > 0, "width must be positive")
|
|
||||||
assert(f + w <= 32, "trying to access non-existent bits")
|
|
||||||
return f, ~(-1 << w)
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.extract (a, f, w)
|
|
||||||
local f, mask = checkfield(f, w)
|
|
||||||
return (a >> f) & mask
|
|
||||||
end
|
|
||||||
|
|
||||||
function bit.replace (a, v, f, w)
|
|
||||||
local f, mask = checkfield(f, w)
|
|
||||||
v = v & mask
|
|
||||||
a = (a & ~(mask << f)) | (v << f)
|
|
||||||
return a & 0xFFFFFFFF
|
|
||||||
end
|
|
||||||
|
|
||||||
return bit
|
|
||||||
|
|
||||||
end --}
|
|
||||||
|
|
||||||
|
|
||||||
print("testing bitwise library")
|
|
||||||
|
|
||||||
local bit32 = require'bit32'
|
|
||||||
|
|
||||||
assert(bit32.band() == bit32.bnot(0))
|
|
||||||
assert(bit32.btest() == true)
|
|
||||||
assert(bit32.bor() == 0)
|
|
||||||
assert(bit32.bxor() == 0)
|
|
||||||
|
|
||||||
assert(bit32.band() == bit32.band(0xffffffff))
|
|
||||||
assert(bit32.band(1,2) == 0)
|
|
||||||
|
|
||||||
|
|
||||||
-- out-of-range numbers
|
|
||||||
assert(bit32.band(-1) == 0xffffffff)
|
|
||||||
assert(bit32.band((1 << 33) - 1) == 0xffffffff)
|
|
||||||
assert(bit32.band(-(1 << 33) - 1) == 0xffffffff)
|
|
||||||
assert(bit32.band((1 << 33) + 1) == 1)
|
|
||||||
assert(bit32.band(-(1 << 33) + 1) == 1)
|
|
||||||
assert(bit32.band(-(1 << 40)) == 0)
|
|
||||||
assert(bit32.band(1 << 40) == 0)
|
|
||||||
assert(bit32.band(-(1 << 40) - 2) == 0xfffffffe)
|
|
||||||
assert(bit32.band((1 << 40) - 4) == 0xfffffffc)
|
|
||||||
|
|
||||||
assert(bit32.lrotate(0, -1) == 0)
|
|
||||||
assert(bit32.lrotate(0, 7) == 0)
|
|
||||||
assert(bit32.lrotate(0x12345678, 0) == 0x12345678)
|
|
||||||
assert(bit32.lrotate(0x12345678, 32) == 0x12345678)
|
|
||||||
assert(bit32.lrotate(0x12345678, 4) == 0x23456781)
|
|
||||||
assert(bit32.rrotate(0x12345678, -4) == 0x23456781)
|
|
||||||
assert(bit32.lrotate(0x12345678, -8) == 0x78123456)
|
|
||||||
assert(bit32.rrotate(0x12345678, 8) == 0x78123456)
|
|
||||||
assert(bit32.lrotate(0xaaaaaaaa, 2) == 0xaaaaaaaa)
|
|
||||||
assert(bit32.lrotate(0xaaaaaaaa, -2) == 0xaaaaaaaa)
|
|
||||||
for i = -50, 50 do
|
|
||||||
assert(bit32.lrotate(0x89abcdef, i) == bit32.lrotate(0x89abcdef, i%32))
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(bit32.lshift(0x12345678, 4) == 0x23456780)
|
|
||||||
assert(bit32.lshift(0x12345678, 8) == 0x34567800)
|
|
||||||
assert(bit32.lshift(0x12345678, -4) == 0x01234567)
|
|
||||||
assert(bit32.lshift(0x12345678, -8) == 0x00123456)
|
|
||||||
assert(bit32.lshift(0x12345678, 32) == 0)
|
|
||||||
assert(bit32.lshift(0x12345678, -32) == 0)
|
|
||||||
assert(bit32.rshift(0x12345678, 4) == 0x01234567)
|
|
||||||
assert(bit32.rshift(0x12345678, 8) == 0x00123456)
|
|
||||||
assert(bit32.rshift(0x12345678, 32) == 0)
|
|
||||||
assert(bit32.rshift(0x12345678, -32) == 0)
|
|
||||||
assert(bit32.arshift(0x12345678, 0) == 0x12345678)
|
|
||||||
assert(bit32.arshift(0x12345678, 1) == 0x12345678 // 2)
|
|
||||||
assert(bit32.arshift(0x12345678, -1) == 0x12345678 * 2)
|
|
||||||
assert(bit32.arshift(-1, 1) == 0xffffffff)
|
|
||||||
assert(bit32.arshift(-1, 24) == 0xffffffff)
|
|
||||||
assert(bit32.arshift(-1, 32) == 0xffffffff)
|
|
||||||
assert(bit32.arshift(-1, -1) == bit32.band(-1 * 2, 0xffffffff))
|
|
||||||
|
|
||||||
assert(0x12345678 << 4 == 0x123456780)
|
|
||||||
assert(0x12345678 << 8 == 0x1234567800)
|
|
||||||
assert(0x12345678 << -4 == 0x01234567)
|
|
||||||
assert(0x12345678 << -8 == 0x00123456)
|
|
||||||
assert(0x12345678 << 32 == 0x1234567800000000)
|
|
||||||
assert(0x12345678 << -32 == 0)
|
|
||||||
assert(0x12345678 >> 4 == 0x01234567)
|
|
||||||
assert(0x12345678 >> 8 == 0x00123456)
|
|
||||||
assert(0x12345678 >> 32 == 0)
|
|
||||||
assert(0x12345678 >> -32 == 0x1234567800000000)
|
|
||||||
|
|
||||||
print("+")
|
|
||||||
-- some special cases
|
|
||||||
local c = {0, 1, 2, 3, 10, 0x80000000, 0xaaaaaaaa, 0x55555555,
|
|
||||||
0xffffffff, 0x7fffffff}
|
|
||||||
|
|
||||||
for _, b in pairs(c) do
|
|
||||||
assert(bit32.band(b) == b)
|
|
||||||
assert(bit32.band(b, b) == b)
|
|
||||||
assert(bit32.band(b, b, b, b) == b)
|
|
||||||
assert(bit32.btest(b, b) == (b ~= 0))
|
|
||||||
assert(bit32.band(b, b, b) == b)
|
|
||||||
assert(bit32.band(b, b, b, ~b) == 0)
|
|
||||||
assert(bit32.btest(b, b, b) == (b ~= 0))
|
|
||||||
assert(bit32.band(b, bit32.bnot(b)) == 0)
|
|
||||||
assert(bit32.bor(b, bit32.bnot(b)) == bit32.bnot(0))
|
|
||||||
assert(bit32.bor(b) == b)
|
|
||||||
assert(bit32.bor(b, b) == b)
|
|
||||||
assert(bit32.bor(b, b, b) == b)
|
|
||||||
assert(bit32.bor(b, b, 0, ~b) == 0xffffffff)
|
|
||||||
assert(bit32.bxor(b) == b)
|
|
||||||
assert(bit32.bxor(b, b) == 0)
|
|
||||||
assert(bit32.bxor(b, b, b) == b)
|
|
||||||
assert(bit32.bxor(b, b, b, b) == 0)
|
|
||||||
assert(bit32.bxor(b, 0) == b)
|
|
||||||
assert(bit32.bnot(b) ~= b)
|
|
||||||
assert(bit32.bnot(bit32.bnot(b)) == b)
|
|
||||||
assert(bit32.bnot(b) == (1 << 32) - 1 - b)
|
|
||||||
assert(bit32.lrotate(b, 32) == b)
|
|
||||||
assert(bit32.rrotate(b, 32) == b)
|
|
||||||
assert(bit32.lshift(bit32.lshift(b, -4), 4) == bit32.band(b, bit32.bnot(0xf)))
|
|
||||||
assert(bit32.rshift(bit32.rshift(b, 4), -4) == bit32.band(b, bit32.bnot(0xf)))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- for this test, use at most 24 bits (mantissa of a single float)
|
|
||||||
c = {0, 1, 2, 3, 10, 0x800000, 0xaaaaaa, 0x555555, 0xffffff, 0x7fffff}
|
|
||||||
for _, b in pairs(c) do
|
|
||||||
for i = -40, 40 do
|
|
||||||
local x = bit32.lshift(b, i)
|
|
||||||
local y = math.floor(math.fmod(b * 2.0^i, 2.0^32))
|
|
||||||
assert(math.fmod(x - y, 2.0^32) == 0)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(not pcall(bit32.band, {}))
|
|
||||||
assert(not pcall(bit32.bnot, "a"))
|
|
||||||
assert(not pcall(bit32.lshift, 45))
|
|
||||||
assert(not pcall(bit32.lshift, 45, print))
|
|
||||||
assert(not pcall(bit32.rshift, 45, print))
|
|
||||||
|
|
||||||
print("+")
|
|
||||||
|
|
||||||
|
|
||||||
-- testing extract/replace
|
|
||||||
|
|
||||||
assert(bit32.extract(0x12345678, 0, 4) == 8)
|
|
||||||
assert(bit32.extract(0x12345678, 4, 4) == 7)
|
|
||||||
assert(bit32.extract(0xa0001111, 28, 4) == 0xa)
|
|
||||||
assert(bit32.extract(0xa0001111, 31, 1) == 1)
|
|
||||||
assert(bit32.extract(0x50000111, 31, 1) == 0)
|
|
||||||
assert(bit32.extract(0xf2345679, 0, 32) == 0xf2345679)
|
|
||||||
|
|
||||||
assert(not pcall(bit32.extract, 0, -1))
|
|
||||||
assert(not pcall(bit32.extract, 0, 32))
|
|
||||||
assert(not pcall(bit32.extract, 0, 0, 33))
|
|
||||||
assert(not pcall(bit32.extract, 0, 31, 2))
|
|
||||||
|
|
||||||
assert(bit32.replace(0x12345678, 5, 28, 4) == 0x52345678)
|
|
||||||
assert(bit32.replace(0x12345678, 0x87654321, 0, 32) == 0x87654321)
|
|
||||||
assert(bit32.replace(0, 1, 2) == 2^2)
|
|
||||||
assert(bit32.replace(0, -1, 4) == 2^4)
|
|
||||||
assert(bit32.replace(-1, 0, 31) == (1 << 31) - 1)
|
|
||||||
assert(bit32.replace(-1, 0, 1, 2) == (1 << 32) - 7)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing conversion of floats
|
|
||||||
|
|
||||||
assert(bit32.bor(3.0) == 3)
|
|
||||||
assert(bit32.bor(-4.0) == 0xfffffffc)
|
|
||||||
|
|
||||||
-- large floats and large-enough integers?
|
|
||||||
if 2.0^50 < 2.0^50 + 1.0 and 2.0^50 < (-1 >> 1) then
|
|
||||||
assert(bit32.bor(2.0^32 - 5.0) == 0xfffffffb)
|
|
||||||
assert(bit32.bor(-2.0^32 - 6.0) == 0xfffffffa)
|
|
||||||
assert(bit32.bor(2.0^48 - 5.0) == 0xfffffffb)
|
|
||||||
assert(bit32.bor(-2.0^48 - 6.0) == 0xfffffffa)
|
|
||||||
end
|
|
||||||
|
|
||||||
print'OK'
|
|
||||||
|
|
||||||
@ -1,78 +0,0 @@
|
|||||||
local tonumber, tointeger = tonumber, math.tointeger
|
|
||||||
local type, getmetatable, rawget, error = type, getmetatable, rawget, error
|
|
||||||
local strsub = string.sub
|
|
||||||
|
|
||||||
local print = print
|
|
||||||
|
|
||||||
_ENV = nil
|
|
||||||
|
|
||||||
-- Try to convert a value to an integer, without assuming any coercion.
|
|
||||||
local function toint (x)
|
|
||||||
x = tonumber(x) -- handle numerical strings
|
|
||||||
if not x then
|
|
||||||
return false -- not coercible to a number
|
|
||||||
end
|
|
||||||
return tointeger(x)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- If operation fails, maybe second operand has a metamethod that should
|
|
||||||
-- have been called if not for this string metamethod, so try to
|
|
||||||
-- call it.
|
|
||||||
local function trymt (x, y, mtname)
|
|
||||||
if type(y) ~= "string" then -- avoid recalling original metamethod
|
|
||||||
local mt = getmetatable(y)
|
|
||||||
local mm = mt and rawget(mt, mtname)
|
|
||||||
if mm then
|
|
||||||
return mm(x, y)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
-- if any test fails, there is no other metamethod to be called
|
|
||||||
error("attempt to '" .. strsub(mtname, 3) ..
|
|
||||||
"' a " .. type(x) .. " with a " .. type(y), 4)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function checkargs (x, y, mtname)
|
|
||||||
local xi = toint(x)
|
|
||||||
local yi = toint(y)
|
|
||||||
if xi and yi then
|
|
||||||
return xi, yi
|
|
||||||
else
|
|
||||||
return trymt(x, y, mtname), nil
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local smt = getmetatable("")
|
|
||||||
|
|
||||||
smt.__band = function (x, y)
|
|
||||||
local x, y = checkargs(x, y, "__band")
|
|
||||||
return y and x & y or x
|
|
||||||
end
|
|
||||||
|
|
||||||
smt.__bor = function (x, y)
|
|
||||||
local x, y = checkargs(x, y, "__bor")
|
|
||||||
return y and x | y or x
|
|
||||||
end
|
|
||||||
|
|
||||||
smt.__bxor = function (x, y)
|
|
||||||
local x, y = checkargs(x, y, "__bxor")
|
|
||||||
return y and x ~ y or x
|
|
||||||
end
|
|
||||||
|
|
||||||
smt.__shl = function (x, y)
|
|
||||||
local x, y = checkargs(x, y, "__shl")
|
|
||||||
return y and x << y or x
|
|
||||||
end
|
|
||||||
|
|
||||||
smt.__shr = function (x, y)
|
|
||||||
local x, y = checkargs(x, y, "__shr")
|
|
||||||
return y and x >> y or x
|
|
||||||
end
|
|
||||||
|
|
||||||
smt.__bnot = function (x)
|
|
||||||
local x, y = checkargs(x, x, "__bnot")
|
|
||||||
return y and ~x or x
|
|
||||||
end
|
|
||||||
|
|
||||||
@ -1,511 +0,0 @@
|
|||||||
-- $Id: testes/calls.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print("testing functions and calls")
|
|
||||||
|
|
||||||
local debug = require "debug"
|
|
||||||
|
|
||||||
-- get the opportunity to test 'type' too ;)
|
|
||||||
|
|
||||||
assert(type(1<2) == 'boolean')
|
|
||||||
assert(type(true) == 'boolean' and type(false) == 'boolean')
|
|
||||||
assert(type(nil) == 'nil'
|
|
||||||
and type(-3) == 'number'
|
|
||||||
and type'x' == 'string'
|
|
||||||
and type{} == 'table'
|
|
||||||
and type(type) == 'function')
|
|
||||||
|
|
||||||
assert(type(assert) == type(print))
|
|
||||||
local function f (x) return a:x (x) end
|
|
||||||
assert(type(f) == 'function')
|
|
||||||
assert(not pcall(type))
|
|
||||||
|
|
||||||
|
|
||||||
-- testing local-function recursion
|
|
||||||
fact = false
|
|
||||||
do
|
|
||||||
local res = 1
|
|
||||||
local function fact (n)
|
|
||||||
if n==0 then return res
|
|
||||||
else return n*fact(n-1)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
assert(fact(5) == 120)
|
|
||||||
end
|
|
||||||
assert(fact == false)
|
|
||||||
fact = nil
|
|
||||||
|
|
||||||
-- testing declarations
|
|
||||||
local a = {i = 10}
|
|
||||||
local self = 20
|
|
||||||
function a:x (x) return x+self.i end
|
|
||||||
function a.y (x) return x+self end
|
|
||||||
|
|
||||||
assert(a:x(1)+10 == a.y(1))
|
|
||||||
|
|
||||||
a.t = {i=-100}
|
|
||||||
a["t"].x = function (self, a,b) return self.i+a+b end
|
|
||||||
|
|
||||||
assert(a.t:x(2,3) == -95)
|
|
||||||
|
|
||||||
do
|
|
||||||
local a = {x=0}
|
|
||||||
function a:add (x) self.x, a.y = self.x+x, 20; return self end
|
|
||||||
assert(a:add(10):add(20):add(30).x == 60 and a.y == 20)
|
|
||||||
end
|
|
||||||
|
|
||||||
local a = {b={c={}}}
|
|
||||||
|
|
||||||
function a.b.c.f1 (x) return x+1 end
|
|
||||||
function a.b.c:f2 (x,y) self[x] = y end
|
|
||||||
assert(a.b.c.f1(4) == 5)
|
|
||||||
a.b.c:f2('k', 12); assert(a.b.c.k == 12)
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
t = nil -- 'declare' t
|
|
||||||
function f(a,b,c) local d = 'a'; t={a,b,c,d} end
|
|
||||||
|
|
||||||
f( -- this line change must be valid
|
|
||||||
1,2)
|
|
||||||
assert(t[1] == 1 and t[2] == 2 and t[3] == nil and t[4] == 'a')
|
|
||||||
f(1,2, -- this one too
|
|
||||||
3,4)
|
|
||||||
assert(t[1] == 1 and t[2] == 2 and t[3] == 3 and t[4] == 'a')
|
|
||||||
|
|
||||||
t = nil -- delete 't'
|
|
||||||
|
|
||||||
function fat(x)
|
|
||||||
if x <= 1 then return 1
|
|
||||||
else return x*load("return fat(" .. x-1 .. ")", "")()
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(load "load 'assert(fat(6)==720)' () ")()
|
|
||||||
a = load('return fat(5), 3')
|
|
||||||
local a,b = a()
|
|
||||||
assert(a == 120 and b == 3)
|
|
||||||
fat = nil
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local function err_on_n (n)
|
|
||||||
if n==0 then error(); exit(1);
|
|
||||||
else err_on_n (n-1); exit(1);
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local function dummy (n)
|
|
||||||
if n > 0 then
|
|
||||||
assert(not pcall(err_on_n, n))
|
|
||||||
dummy(n-1)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
dummy(10)
|
|
||||||
end
|
|
||||||
|
|
||||||
_G.deep = nil -- "declaration" (used by 'all.lua')
|
|
||||||
|
|
||||||
function deep (n)
|
|
||||||
if n>0 then deep(n-1) end
|
|
||||||
end
|
|
||||||
deep(10)
|
|
||||||
deep(180)
|
|
||||||
|
|
||||||
|
|
||||||
print"testing tail calls"
|
|
||||||
|
|
||||||
function deep (n) if n>0 then return deep(n-1) else return 101 end end
|
|
||||||
assert(deep(30000) == 101)
|
|
||||||
a = {}
|
|
||||||
function a:deep (n) if n>0 then return self:deep(n-1) else return 101 end end
|
|
||||||
assert(a:deep(30000) == 101)
|
|
||||||
|
|
||||||
do -- tail calls x varargs
|
|
||||||
local function foo (x, ...) local a = {...}; return x, a[1], a[2] end
|
|
||||||
|
|
||||||
local function foo1 (x) return foo(10, x, x + 1) end
|
|
||||||
|
|
||||||
local a, b, c = foo1(-2)
|
|
||||||
assert(a == 10 and b == -2 and c == -1)
|
|
||||||
|
|
||||||
-- tail calls x metamethods
|
|
||||||
local t = setmetatable({}, {__call = foo})
|
|
||||||
local function foo2 (x) return t(10, x) end
|
|
||||||
a, b, c = foo2(100)
|
|
||||||
assert(a == t and b == 10 and c == 100)
|
|
||||||
|
|
||||||
a, b = (function () return foo() end)()
|
|
||||||
assert(a == nil and b == nil)
|
|
||||||
|
|
||||||
local X, Y, A
|
|
||||||
local function foo (x, y, ...) X = x; Y = y; A = {...} end
|
|
||||||
local function foo1 (...) return foo(...) end
|
|
||||||
|
|
||||||
local a, b, c = foo1()
|
|
||||||
assert(X == nil and Y == nil and #A == 0)
|
|
||||||
|
|
||||||
a, b, c = foo1(10)
|
|
||||||
assert(X == 10 and Y == nil and #A == 0)
|
|
||||||
|
|
||||||
a, b, c = foo1(10, 20)
|
|
||||||
assert(X == 10 and Y == 20 and #A == 0)
|
|
||||||
|
|
||||||
a, b, c = foo1(10, 20, 30)
|
|
||||||
assert(X == 10 and Y == 20 and #A == 1 and A[1] == 30)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- C-stack overflow while handling C-stack overflow
|
|
||||||
local function loop ()
|
|
||||||
assert(pcall(loop))
|
|
||||||
end
|
|
||||||
|
|
||||||
local err, msg = xpcall(loop, loop)
|
|
||||||
assert(not err and string.find(msg, "error"))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
do -- tail calls x chain of __call
|
|
||||||
local n = 10000 -- depth
|
|
||||||
|
|
||||||
local function foo ()
|
|
||||||
if n == 0 then return 1023
|
|
||||||
else n = n - 1; return foo()
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- build a chain of __call metamethods ending in function 'foo'
|
|
||||||
for i = 1, 100 do
|
|
||||||
foo = setmetatable({}, {__call = foo})
|
|
||||||
end
|
|
||||||
|
|
||||||
-- call the first one as a tail call in a new coroutine
|
|
||||||
-- (to ensure stack is not preallocated)
|
|
||||||
assert(coroutine.wrap(function() return foo() end)() == 1023)
|
|
||||||
end
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
|
|
||||||
do -- testing chains of '__call'
|
|
||||||
local N = 20
|
|
||||||
local u = table.pack
|
|
||||||
for i = 1, N do
|
|
||||||
u = setmetatable({i}, {__call = u})
|
|
||||||
end
|
|
||||||
|
|
||||||
local Res = u("a", "b", "c")
|
|
||||||
|
|
||||||
assert(Res.n == N + 3)
|
|
||||||
for i = 1, N do
|
|
||||||
assert(Res[i][1] == i)
|
|
||||||
end
|
|
||||||
assert(Res[N + 1] == "a" and Res[N + 2] == "b" and Res[N + 3] == "c")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
a = nil
|
|
||||||
(function (x) a=x end)(23)
|
|
||||||
assert(a == 23 and (function (x) return x*2 end)(20) == 40)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closures
|
|
||||||
|
|
||||||
-- fixed-point operator
|
|
||||||
local Z = function (le)
|
|
||||||
local function a (f)
|
|
||||||
return le(function (x) return f(f)(x) end)
|
|
||||||
end
|
|
||||||
return a(a)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- non-recursive factorial
|
|
||||||
|
|
||||||
local F = function (f)
|
|
||||||
return function (n)
|
|
||||||
if n == 0 then return 1
|
|
||||||
else return n*f(n-1) end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local fat = Z(F)
|
|
||||||
|
|
||||||
assert(fat(0) == 1 and fat(4) == 24 and Z(F)(5)==5*Z(F)(4))
|
|
||||||
|
|
||||||
local function g (z)
|
|
||||||
local function f (a,b,c,d)
|
|
||||||
return function (x,y) return a+b+c+d+a+x+y+z end
|
|
||||||
end
|
|
||||||
return f(z,z+1,z+2,z+3)
|
|
||||||
end
|
|
||||||
|
|
||||||
local f = g(10)
|
|
||||||
assert(f(9, 16) == 10+11+12+13+10+9+16+10)
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
-- testing multiple returns
|
|
||||||
|
|
||||||
local function unlpack (t, i)
|
|
||||||
i = i or 1
|
|
||||||
if (i <= #t) then
|
|
||||||
return t[i], unlpack(t, i+1)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function equaltab (t1, t2)
|
|
||||||
assert(#t1 == #t2)
|
|
||||||
for i = 1, #t1 do
|
|
||||||
assert(t1[i] == t2[i])
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local pack = function (...) return (table.pack(...)) end
|
|
||||||
|
|
||||||
local function f() return 1,2,30,4 end
|
|
||||||
local function ret2 (a,b) return a,b end
|
|
||||||
|
|
||||||
local a,b,c,d = unlpack{1,2,3}
|
|
||||||
assert(a==1 and b==2 and c==3 and d==nil)
|
|
||||||
a = {1,2,3,4,false,10,'alo',false,assert}
|
|
||||||
equaltab(pack(unlpack(a)), a)
|
|
||||||
equaltab(pack(unlpack(a), -1), {1,-1})
|
|
||||||
a,b,c,d = ret2(f()), ret2(f())
|
|
||||||
assert(a==1 and b==1 and c==2 and d==nil)
|
|
||||||
a,b,c,d = unlpack(pack(ret2(f()), ret2(f())))
|
|
||||||
assert(a==1 and b==1 and c==2 and d==nil)
|
|
||||||
a,b,c,d = unlpack(pack(ret2(f()), (ret2(f()))))
|
|
||||||
assert(a==1 and b==1 and c==nil and d==nil)
|
|
||||||
|
|
||||||
a = ret2{ unlpack{1,2,3}, unlpack{3,2,1}, unlpack{"a", "b"}}
|
|
||||||
assert(a[1] == 1 and a[2] == 3 and a[3] == "a" and a[4] == "b")
|
|
||||||
|
|
||||||
|
|
||||||
-- testing calls with 'incorrect' arguments
|
|
||||||
rawget({}, "x", 1)
|
|
||||||
rawset({}, "x", 1, 2)
|
|
||||||
assert(math.sin(1,2) == math.sin(1))
|
|
||||||
table.sort({10,9,8,4,19,23,0,0}, function (a,b) return a<b end, "extra arg")
|
|
||||||
|
|
||||||
|
|
||||||
-- test for generic load
|
|
||||||
local x = "-- a comment\0\0\0\n x = 10 + \n23; \
|
|
||||||
local a = function () x = 'hi' end; \
|
|
||||||
return '\0'"
|
|
||||||
local function read1 (x)
|
|
||||||
local i = 0
|
|
||||||
return function ()
|
|
||||||
collectgarbage()
|
|
||||||
i=i+1
|
|
||||||
return string.sub(x, i, i)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function cannotload (msg, a,b)
|
|
||||||
assert(not a and string.find(b, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
a = assert(load(read1(x), "modname", "t", _G))
|
|
||||||
assert(a() == "\0" and _G.x == 33)
|
|
||||||
assert(debug.getinfo(a).source == "modname")
|
|
||||||
-- cannot read text in binary mode
|
|
||||||
cannotload("attempt to load a text chunk", load(read1(x), "modname", "b", {}))
|
|
||||||
cannotload("attempt to load a text chunk", load(x, "modname", "b"))
|
|
||||||
|
|
||||||
a = assert(load(function () return nil end))
|
|
||||||
a() -- empty chunk
|
|
||||||
|
|
||||||
assert(not load(function () return true end))
|
|
||||||
|
|
||||||
|
|
||||||
-- small bug
|
|
||||||
local t = {nil, "return ", "3"}
|
|
||||||
f, msg = load(function () return table.remove(t, 1) end)
|
|
||||||
assert(f() == nil) -- should read the empty chunk
|
|
||||||
|
|
||||||
-- another small bug (in 5.2.1)
|
|
||||||
f = load(string.dump(function () return 1 end), nil, "b", {})
|
|
||||||
assert(type(f) == "function" and f() == 1)
|
|
||||||
|
|
||||||
|
|
||||||
do -- another bug (in 5.4.0)
|
|
||||||
-- loading a binary long string interrupted by GC cycles
|
|
||||||
local f = string.dump(function ()
|
|
||||||
return '01234567890123456789012345678901234567890123456789'
|
|
||||||
end)
|
|
||||||
f = load(read1(f))
|
|
||||||
assert(f() == '01234567890123456789012345678901234567890123456789')
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- another bug (since 5.2)
|
|
||||||
-- corrupted binary dump: list of upvalue names is larger than number
|
|
||||||
-- of upvalues, overflowing the array of upvalues.
|
|
||||||
local code =
|
|
||||||
"\x1b\x4c\x75\x61\x54\x00\x19\x93\x0d\x0a\x1a\x0a\x04\x08\x08\x78\x56\z
|
|
||||||
\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x77\x40\x00\x86\x40\z
|
|
||||||
\x74\x65\x6d\x70\x81\x81\x01\x00\x02\x82\x48\x00\x02\x00\xc7\x00\x01\z
|
|
||||||
\x00\x80\x80\x80\x82\x00\x00\x80\x81\x82\x78\x80\x82\x81\x86\x40\x74\z
|
|
||||||
\x65\x6d\x70"
|
|
||||||
|
|
||||||
assert(load(code)) -- segfaults in previous versions
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
x = string.dump(load("x = 1; return x"))
|
|
||||||
a = assert(load(read1(x), nil, "b"))
|
|
||||||
assert(a() == 1 and _G.x == 1)
|
|
||||||
cannotload("attempt to load a binary chunk", load(read1(x), nil, "t"))
|
|
||||||
cannotload("attempt to load a binary chunk", load(x, nil, "t"))
|
|
||||||
_G.x = nil
|
|
||||||
|
|
||||||
assert(not pcall(string.dump, print)) -- no dump of C functions
|
|
||||||
|
|
||||||
cannotload("unexpected symbol", load(read1("*a = 123")))
|
|
||||||
cannotload("unexpected symbol", load("*a = 123"))
|
|
||||||
cannotload("hhi", load(function () error("hhi") end))
|
|
||||||
|
|
||||||
-- any value is valid for _ENV
|
|
||||||
assert(load("return _ENV", nil, nil, 123)() == 123)
|
|
||||||
|
|
||||||
|
|
||||||
-- load when _ENV is not first upvalue
|
|
||||||
local x; XX = 123
|
|
||||||
local function h ()
|
|
||||||
local y=x -- use 'x', so that it becomes 1st upvalue
|
|
||||||
return XX -- global name
|
|
||||||
end
|
|
||||||
local d = string.dump(h)
|
|
||||||
x = load(d, "", "b")
|
|
||||||
assert(debug.getupvalue(x, 2) == '_ENV')
|
|
||||||
debug.setupvalue(x, 2, _G)
|
|
||||||
assert(x() == 123)
|
|
||||||
|
|
||||||
assert(assert(load("return XX + ...", nil, nil, {XX = 13}))(4) == 17)
|
|
||||||
XX = nil
|
|
||||||
|
|
||||||
-- test generic load with nested functions
|
|
||||||
x = [[
|
|
||||||
return function (x)
|
|
||||||
return function (y)
|
|
||||||
return function (z)
|
|
||||||
return x+y+z
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
]]
|
|
||||||
a = assert(load(read1(x), "read", "t"))
|
|
||||||
assert(a()(2)(3)(10) == 15)
|
|
||||||
|
|
||||||
-- repeat the test loading a binary chunk
|
|
||||||
x = string.dump(a)
|
|
||||||
a = assert(load(read1(x), "read", "b"))
|
|
||||||
assert(a()(2)(3)(10) == 15)
|
|
||||||
|
|
||||||
|
|
||||||
-- test for dump/undump with upvalues
|
|
||||||
local a, b = 20, 30
|
|
||||||
x = load(string.dump(function (x)
|
|
||||||
if x == "set" then a = 10+b; b = b+1 else
|
|
||||||
return a
|
|
||||||
end
|
|
||||||
end), "", "b", nil)
|
|
||||||
assert(x() == nil)
|
|
||||||
assert(debug.setupvalue(x, 1, "hi") == "a")
|
|
||||||
assert(x() == "hi")
|
|
||||||
assert(debug.setupvalue(x, 2, 13) == "b")
|
|
||||||
assert(not debug.setupvalue(x, 3, 10)) -- only 2 upvalues
|
|
||||||
x("set")
|
|
||||||
assert(x() == 23)
|
|
||||||
x("set")
|
|
||||||
assert(x() == 24)
|
|
||||||
|
|
||||||
-- test for dump/undump with many upvalues
|
|
||||||
do
|
|
||||||
local nup = 200 -- maximum number of local variables
|
|
||||||
local prog = {"local a1"}
|
|
||||||
for i = 2, nup do prog[#prog + 1] = ", a" .. i end
|
|
||||||
prog[#prog + 1] = " = 1"
|
|
||||||
for i = 2, nup do prog[#prog + 1] = ", " .. i end
|
|
||||||
local sum = 1
|
|
||||||
prog[#prog + 1] = "; return function () return a1"
|
|
||||||
for i = 2, nup do prog[#prog + 1] = " + a" .. i; sum = sum + i end
|
|
||||||
prog[#prog + 1] = " end"
|
|
||||||
prog = table.concat(prog)
|
|
||||||
local f = assert(load(prog))()
|
|
||||||
assert(f() == sum)
|
|
||||||
|
|
||||||
f = load(string.dump(f)) -- main chunk now has many upvalues
|
|
||||||
local a = 10
|
|
||||||
local h = function () return a end
|
|
||||||
for i = 1, nup do
|
|
||||||
debug.upvaluejoin(f, i, h, 1)
|
|
||||||
end
|
|
||||||
assert(f() == 10 * nup)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- test for long method names
|
|
||||||
do
|
|
||||||
local t = {x = 1}
|
|
||||||
function t:_012345678901234567890123456789012345678901234567890123456789 ()
|
|
||||||
return self.x
|
|
||||||
end
|
|
||||||
assert(t:_012345678901234567890123456789012345678901234567890123456789() == 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- test for bug in parameter adjustment
|
|
||||||
assert((function () return nil end)(4) == nil)
|
|
||||||
assert((function () local a; return a end)(4) == nil)
|
|
||||||
assert((function (a) return a end)() == nil)
|
|
||||||
|
|
||||||
|
|
||||||
print("testing binary chunks")
|
|
||||||
do
|
|
||||||
local header = string.pack("c4BBc6BBB",
|
|
||||||
"\27Lua", -- signature
|
|
||||||
0x54, -- version 5.4 (0x54)
|
|
||||||
0, -- format
|
|
||||||
"\x19\x93\r\n\x1a\n", -- data
|
|
||||||
4, -- size of instruction
|
|
||||||
string.packsize("j"), -- sizeof(lua integer)
|
|
||||||
string.packsize("n") -- sizeof(lua number)
|
|
||||||
)
|
|
||||||
local c = string.dump(function ()
|
|
||||||
local a = 1; local b = 3;
|
|
||||||
local f = function () return a + b + _ENV.c; end -- upvalues
|
|
||||||
local s1 = "a constant"
|
|
||||||
local s2 = "another constant"
|
|
||||||
return a + b * 3
|
|
||||||
end)
|
|
||||||
|
|
||||||
assert(assert(load(c))() == 10)
|
|
||||||
|
|
||||||
-- check header
|
|
||||||
assert(string.sub(c, 1, #header) == header)
|
|
||||||
-- check LUAC_INT and LUAC_NUM
|
|
||||||
local ci, cn = string.unpack("jn", c, #header + 1)
|
|
||||||
assert(ci == 0x5678 and cn == 370.5)
|
|
||||||
|
|
||||||
-- corrupted header
|
|
||||||
for i = 1, #header do
|
|
||||||
local s = string.sub(c, 1, i - 1) ..
|
|
||||||
string.char(string.byte(string.sub(c, i, i)) + 1) ..
|
|
||||||
string.sub(c, i + 1, -1)
|
|
||||||
assert(#s == #c)
|
|
||||||
assert(not load(s))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- loading truncated binary chunks
|
|
||||||
for i = 1, #c - 1 do
|
|
||||||
local st, msg = load(string.sub(c, 1, i))
|
|
||||||
assert(not st and string.find(msg, "truncated"))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
return deep
|
|
||||||
@ -1,272 +0,0 @@
|
|||||||
-- $Id: testes/closure.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print "testing closures"
|
|
||||||
|
|
||||||
local A,B = 0,{g=10}
|
|
||||||
local function f(x)
|
|
||||||
local a = {}
|
|
||||||
for i=1,1000 do
|
|
||||||
local y = 0
|
|
||||||
do
|
|
||||||
a[i] = function () B.g = B.g+1; y = y+x; return y+A end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
local dummy = function () return a[A] end
|
|
||||||
collectgarbage()
|
|
||||||
A = 1; assert(dummy() == a[1]); A = 0;
|
|
||||||
assert(a[1]() == x)
|
|
||||||
assert(a[3]() == x)
|
|
||||||
collectgarbage()
|
|
||||||
assert(B.g == 12)
|
|
||||||
return a
|
|
||||||
end
|
|
||||||
|
|
||||||
local a = f(10)
|
|
||||||
-- force a GC in this level
|
|
||||||
local x = {[1] = {}} -- to detect a GC
|
|
||||||
setmetatable(x, {__mode = 'kv'})
|
|
||||||
while x[1] do -- repeat until GC
|
|
||||||
local a = A..A..A..A -- create garbage
|
|
||||||
A = A+1
|
|
||||||
end
|
|
||||||
assert(a[1]() == 20+A)
|
|
||||||
assert(a[1]() == 30+A)
|
|
||||||
assert(a[2]() == 10+A)
|
|
||||||
collectgarbage()
|
|
||||||
assert(a[2]() == 20+A)
|
|
||||||
assert(a[2]() == 30+A)
|
|
||||||
assert(a[3]() == 20+A)
|
|
||||||
assert(a[8]() == 10+A)
|
|
||||||
assert(getmetatable(x).__mode == 'kv')
|
|
||||||
assert(B.g == 19)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing equality
|
|
||||||
a = {}
|
|
||||||
|
|
||||||
for i = 1, 5 do a[i] = function (x) return i + a + _ENV end end
|
|
||||||
assert(a[3] ~= a[4] and a[4] ~= a[5])
|
|
||||||
|
|
||||||
do
|
|
||||||
local a = function (x) return math.sin(_ENV[x]) end
|
|
||||||
local function f()
|
|
||||||
return a
|
|
||||||
end
|
|
||||||
assert(f() == f())
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closures with 'for' control variable
|
|
||||||
a = {}
|
|
||||||
for i=1,10 do
|
|
||||||
a[i] = {set = function(x) i=x end, get = function () return i end}
|
|
||||||
if i == 3 then break end
|
|
||||||
end
|
|
||||||
assert(a[4] == undef)
|
|
||||||
a[1].set(10)
|
|
||||||
assert(a[2].get() == 2)
|
|
||||||
a[2].set('a')
|
|
||||||
assert(a[3].get() == 3)
|
|
||||||
assert(a[2].get() == 'a')
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
local t = {"a", "b"}
|
|
||||||
for i = 1, #t do
|
|
||||||
local k = t[i]
|
|
||||||
a[i] = {set = function(x, y) i=x; k=y end,
|
|
||||||
get = function () return i, k end}
|
|
||||||
if i == 2 then break end
|
|
||||||
end
|
|
||||||
a[1].set(10, 20)
|
|
||||||
local r,s = a[2].get()
|
|
||||||
assert(r == 2 and s == 'b')
|
|
||||||
r,s = a[1].get()
|
|
||||||
assert(r == 10 and s == 20)
|
|
||||||
a[2].set('a', 'b')
|
|
||||||
r,s = a[2].get()
|
|
||||||
assert(r == "a" and s == "b")
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closures with 'for' control variable x break
|
|
||||||
local f
|
|
||||||
for i=1,3 do
|
|
||||||
f = function () return i end
|
|
||||||
break
|
|
||||||
end
|
|
||||||
assert(f() == 1)
|
|
||||||
|
|
||||||
for k = 1, #t do
|
|
||||||
local v = t[k]
|
|
||||||
f = function () return k, v end
|
|
||||||
break
|
|
||||||
end
|
|
||||||
assert(({f()})[1] == 1)
|
|
||||||
assert(({f()})[2] == "a")
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closure x break x return x errors
|
|
||||||
|
|
||||||
local b
|
|
||||||
function f(x)
|
|
||||||
local first = 1
|
|
||||||
while 1 do
|
|
||||||
if x == 3 and not first then return end
|
|
||||||
local a = 'xuxu'
|
|
||||||
b = function (op, y)
|
|
||||||
if op == 'set' then
|
|
||||||
a = x+y
|
|
||||||
else
|
|
||||||
return a
|
|
||||||
end
|
|
||||||
end
|
|
||||||
if x == 1 then do break end
|
|
||||||
elseif x == 2 then return
|
|
||||||
else if x ~= 3 then error() end
|
|
||||||
end
|
|
||||||
first = nil
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for i=1,3 do
|
|
||||||
f(i)
|
|
||||||
assert(b('get') == 'xuxu')
|
|
||||||
b('set', 10); assert(b('get') == 10+i)
|
|
||||||
b = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
pcall(f, 4);
|
|
||||||
assert(b('get') == 'xuxu')
|
|
||||||
b('set', 10); assert(b('get') == 14)
|
|
||||||
|
|
||||||
|
|
||||||
local y, w
|
|
||||||
-- testing multi-level closure
|
|
||||||
function f(x)
|
|
||||||
return function (y)
|
|
||||||
return function (z) return w+x+y+z end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
y = f(10)
|
|
||||||
w = 1.345
|
|
||||||
assert(y(20)(30) == 60+w)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closures x break
|
|
||||||
do
|
|
||||||
local X, Y
|
|
||||||
local a = math.sin(0)
|
|
||||||
|
|
||||||
while a do
|
|
||||||
local b = 10
|
|
||||||
X = function () return b end -- closure with upvalue
|
|
||||||
if a then break end
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local b = 20
|
|
||||||
Y = function () return b end -- closure with upvalue
|
|
||||||
end
|
|
||||||
|
|
||||||
-- upvalues must be different
|
|
||||||
assert(X() == 10 and Y() == 20)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closures x repeat-until
|
|
||||||
|
|
||||||
local a = {}
|
|
||||||
local i = 1
|
|
||||||
repeat
|
|
||||||
local x = i
|
|
||||||
a[i] = function () i = x+1; return x end
|
|
||||||
until i > 10 or a[i]() ~= x
|
|
||||||
assert(i == 11 and a[1]() == 1 and a[3]() == 3 and i == 4)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing closures created in 'then' and 'else' parts of 'if's
|
|
||||||
a = {}
|
|
||||||
for i = 1, 10 do
|
|
||||||
if i % 3 == 0 then
|
|
||||||
local y = 0
|
|
||||||
a[i] = function (x) local t = y; y = x; return t end
|
|
||||||
elseif i % 3 == 1 then
|
|
||||||
goto L1
|
|
||||||
error'not here'
|
|
||||||
::L1::
|
|
||||||
local y = 1
|
|
||||||
a[i] = function (x) local t = y; y = x; return t end
|
|
||||||
elseif i % 3 == 2 then
|
|
||||||
local t
|
|
||||||
goto l4
|
|
||||||
::l4a:: a[i] = t; goto l4b
|
|
||||||
error("should never be here!")
|
|
||||||
::l4::
|
|
||||||
local y = 2
|
|
||||||
t = function (x) local t = y; y = x; return t end
|
|
||||||
goto l4a
|
|
||||||
error("should never be here!")
|
|
||||||
::l4b::
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for i = 1, 10 do
|
|
||||||
assert(a[i](i * 10) == i % 3 and a[i]() == i * 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
|
|
||||||
-- test for correctly closing upvalues in tail calls of vararg functions
|
|
||||||
local function t ()
|
|
||||||
local function c(a,b) assert(a=="test" and b=="OK") end
|
|
||||||
local function v(f, ...) c("test", f() ~= 1 and "FAILED" or "OK") end
|
|
||||||
local x = 1
|
|
||||||
return v(function() return x end)
|
|
||||||
end
|
|
||||||
t()
|
|
||||||
|
|
||||||
|
|
||||||
-- test for debug manipulation of upvalues
|
|
||||||
local debug = require'debug'
|
|
||||||
|
|
||||||
local foo1, foo2, foo3
|
|
||||||
do
|
|
||||||
local a , b, c = 3, 5, 7
|
|
||||||
foo1 = function () return a+b end;
|
|
||||||
foo2 = function () return b+a end;
|
|
||||||
do
|
|
||||||
local a = 10
|
|
||||||
foo3 = function () return a+b end;
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(debug.upvalueid(foo1, 1))
|
|
||||||
assert(debug.upvalueid(foo1, 2))
|
|
||||||
assert(not debug.upvalueid(foo1, 3))
|
|
||||||
assert(debug.upvalueid(foo1, 1) == debug.upvalueid(foo2, 2))
|
|
||||||
assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo2, 1))
|
|
||||||
assert(debug.upvalueid(foo3, 1))
|
|
||||||
assert(debug.upvalueid(foo1, 1) ~= debug.upvalueid(foo3, 1))
|
|
||||||
assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo3, 2))
|
|
||||||
|
|
||||||
assert(debug.upvalueid(string.gmatch("x", "x"), 1) ~= nil)
|
|
||||||
|
|
||||||
assert(foo1() == 3 + 5 and foo2() == 5 + 3)
|
|
||||||
debug.upvaluejoin(foo1, 2, foo2, 2)
|
|
||||||
assert(foo1() == 3 + 3 and foo2() == 5 + 3)
|
|
||||||
assert(foo3() == 10 + 5)
|
|
||||||
debug.upvaluejoin(foo3, 2, foo2, 1)
|
|
||||||
assert(foo3() == 10 + 5)
|
|
||||||
debug.upvaluejoin(foo3, 2, foo2, 2)
|
|
||||||
assert(foo3() == 10 + 3)
|
|
||||||
|
|
||||||
assert(not pcall(debug.upvaluejoin, foo1, 3, foo2, 1))
|
|
||||||
assert(not pcall(debug.upvaluejoin, foo1, 1, foo2, 3))
|
|
||||||
assert(not pcall(debug.upvaluejoin, foo1, 0, foo2, 1))
|
|
||||||
assert(not pcall(debug.upvaluejoin, print, 1, foo2, 1))
|
|
||||||
assert(not pcall(debug.upvaluejoin, {}, 1, foo2, 1))
|
|
||||||
assert(not pcall(debug.upvaluejoin, foo1, 1, print, 1))
|
|
||||||
|
|
||||||
print'OK'
|
|
||||||
@ -1,449 +0,0 @@
|
|||||||
-- $Id: testes/code.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
if T==nil then
|
|
||||||
(Message or print)('\n >>> testC not active: skipping opcode tests <<<\n')
|
|
||||||
return
|
|
||||||
end
|
|
||||||
print "testing code generation and optimizations"
|
|
||||||
|
|
||||||
-- to test constant propagation
|
|
||||||
local k0aux <const> = 0
|
|
||||||
local k0 <const> = k0aux
|
|
||||||
local k1 <const> = 1
|
|
||||||
local k3 <const> = 3
|
|
||||||
local k6 <const> = k3 + (k3 << k0)
|
|
||||||
local kFF0 <const> = 0xFF0
|
|
||||||
local k3_78 <const> = 3.78
|
|
||||||
local x, k3_78_4 <const> = 10, k3_78 / 4
|
|
||||||
assert(x == 10)
|
|
||||||
|
|
||||||
local kx <const> = "x"
|
|
||||||
|
|
||||||
local kTrue <const> = true
|
|
||||||
local kFalse <const> = false
|
|
||||||
|
|
||||||
local kNil <const> = nil
|
|
||||||
|
|
||||||
-- this code gave an error for the code checker
|
|
||||||
do
|
|
||||||
local function f (a)
|
|
||||||
for k,v,w in a do end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing reuse in constant table
|
|
||||||
local function checkKlist (func, list)
|
|
||||||
local k = T.listk(func)
|
|
||||||
assert(#k == #list)
|
|
||||||
for i = 1, #k do
|
|
||||||
assert(k[i] == list[i] and math.type(k[i]) == math.type(list[i]))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function foo ()
|
|
||||||
local a
|
|
||||||
a = k3;
|
|
||||||
a = 0; a = 0.0; a = -7 + 7
|
|
||||||
a = k3_78/4; a = k3_78_4
|
|
||||||
a = -k3_78/4; a = k3_78/4; a = -3.78/4
|
|
||||||
a = -3.79/4; a = 0.0; a = -0;
|
|
||||||
a = k3; a = 3.0; a = 3; a = 3.0
|
|
||||||
end
|
|
||||||
|
|
||||||
checkKlist(foo, {3.78/4, -3.78/4, -3.79/4})
|
|
||||||
|
|
||||||
|
|
||||||
foo = function (f, a)
|
|
||||||
f(100 * 1000)
|
|
||||||
f(100.0 * 1000)
|
|
||||||
f(-100 * 1000)
|
|
||||||
f(-100 * 1000.0)
|
|
||||||
f(100000)
|
|
||||||
f(100000.0)
|
|
||||||
f(-100000)
|
|
||||||
f(-100000.0)
|
|
||||||
end
|
|
||||||
|
|
||||||
checkKlist(foo, {100000, 100000.0, -100000, -100000.0})
|
|
||||||
|
|
||||||
|
|
||||||
-- floats x integers
|
|
||||||
foo = function (t, a)
|
|
||||||
t[a] = 1; t[a] = 1.0
|
|
||||||
t[a] = 1; t[a] = 1.0
|
|
||||||
t[a] = 2; t[a] = 2.0
|
|
||||||
t[a] = 0; t[a] = 0.0
|
|
||||||
t[a] = 1; t[a] = 1.0
|
|
||||||
t[a] = 2; t[a] = 2.0
|
|
||||||
t[a] = 0; t[a] = 0.0
|
|
||||||
end
|
|
||||||
|
|
||||||
checkKlist(foo, {1, 1.0, 2, 2.0, 0, 0.0})
|
|
||||||
|
|
||||||
|
|
||||||
-- testing opcodes
|
|
||||||
|
|
||||||
-- check that 'f' opcodes match '...'
|
|
||||||
local function check (f, ...)
|
|
||||||
local arg = {...}
|
|
||||||
local c = T.listcode(f)
|
|
||||||
for i=1, #arg do
|
|
||||||
local opcode = string.match(c[i], "%u%w+")
|
|
||||||
-- print(arg[i], opcode)
|
|
||||||
assert(arg[i] == opcode)
|
|
||||||
end
|
|
||||||
assert(c[#arg+2] == undef)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- check that 'f' opcodes match '...' and that 'f(p) == r'.
|
|
||||||
local function checkR (f, p, r, ...)
|
|
||||||
local r1 = f(p)
|
|
||||||
assert(r == r1 and math.type(r) == math.type(r1))
|
|
||||||
check(f, ...)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- check that 'a' and 'b' has the same opcodes
|
|
||||||
local function checkequal (a, b)
|
|
||||||
a = T.listcode(a)
|
|
||||||
b = T.listcode(b)
|
|
||||||
assert(#a == #b)
|
|
||||||
for i = 1, #a do
|
|
||||||
a[i] = string.gsub(a[i], '%b()', '') -- remove line number
|
|
||||||
b[i] = string.gsub(b[i], '%b()', '') -- remove line number
|
|
||||||
assert(a[i] == b[i])
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- some basic instructions
|
|
||||||
check(function () -- function does not create upvalues
|
|
||||||
(function () end){f()}
|
|
||||||
end, 'CLOSURE', 'NEWTABLE', 'EXTRAARG', 'GETTABUP', 'CALL',
|
|
||||||
'SETLIST', 'CALL', 'RETURN0')
|
|
||||||
|
|
||||||
check(function (x) -- function creates upvalues
|
|
||||||
(function () return x end){f()}
|
|
||||||
end, 'CLOSURE', 'NEWTABLE', 'EXTRAARG', 'GETTABUP', 'CALL',
|
|
||||||
'SETLIST', 'CALL', 'RETURN')
|
|
||||||
|
|
||||||
|
|
||||||
-- sequence of LOADNILs
|
|
||||||
check(function ()
|
|
||||||
local kNil <const> = nil
|
|
||||||
local a,b,c
|
|
||||||
local d; local e;
|
|
||||||
local f,g,h;
|
|
||||||
d = nil; d=nil; b=nil; a=kNil; c=nil;
|
|
||||||
end, 'LOADNIL', 'RETURN0')
|
|
||||||
|
|
||||||
check(function ()
|
|
||||||
local a,b,c,d = 1,1,1,1
|
|
||||||
d=nil;c=nil;b=nil;a=nil
|
|
||||||
end, 'LOADI', 'LOADI', 'LOADI', 'LOADI', 'LOADNIL', 'RETURN0')
|
|
||||||
|
|
||||||
do
|
|
||||||
local a,b,c,d = 1,1,1,1
|
|
||||||
d=nil;c=nil;b=nil;a=nil
|
|
||||||
assert(a == nil and b == nil and c == nil and d == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- single return
|
|
||||||
check (function (a,b,c) return a end, 'RETURN1')
|
|
||||||
|
|
||||||
|
|
||||||
-- infinite loops
|
|
||||||
check(function () while kTrue do local a = -1 end end,
|
|
||||||
'LOADI', 'JMP', 'RETURN0')
|
|
||||||
|
|
||||||
check(function () while 1 do local a = -1 end end,
|
|
||||||
'LOADI', 'JMP', 'RETURN0')
|
|
||||||
|
|
||||||
check(function () repeat local x = 1 until true end,
|
|
||||||
'LOADI', 'RETURN0')
|
|
||||||
|
|
||||||
|
|
||||||
-- concat optimization
|
|
||||||
check(function (a,b,c,d) return a..b..c..d end,
|
|
||||||
'MOVE', 'MOVE', 'MOVE', 'MOVE', 'CONCAT', 'RETURN1')
|
|
||||||
|
|
||||||
-- not
|
|
||||||
check(function () return not not nil end, 'LOADFALSE', 'RETURN1')
|
|
||||||
check(function () return not not kFalse end, 'LOADFALSE', 'RETURN1')
|
|
||||||
check(function () return not not true end, 'LOADTRUE', 'RETURN1')
|
|
||||||
check(function () return not not k3 end, 'LOADTRUE', 'RETURN1')
|
|
||||||
|
|
||||||
-- direct access to locals
|
|
||||||
check(function ()
|
|
||||||
local a,b,c,d
|
|
||||||
a = b*a
|
|
||||||
c.x, a[b] = -((a + d/b - a[b]) ^ a.x), b
|
|
||||||
end,
|
|
||||||
'LOADNIL',
|
|
||||||
'MUL', 'MMBIN',
|
|
||||||
'DIV', 'MMBIN', 'ADD', 'MMBIN', 'GETTABLE', 'SUB', 'MMBIN',
|
|
||||||
'GETFIELD', 'POW', 'MMBIN', 'UNM', 'SETTABLE', 'SETFIELD', 'RETURN0')
|
|
||||||
|
|
||||||
|
|
||||||
-- direct access to constants
|
|
||||||
check(function ()
|
|
||||||
local a,b
|
|
||||||
local c = kNil
|
|
||||||
a[kx] = 3.2
|
|
||||||
a.x = b
|
|
||||||
a[b] = 'x'
|
|
||||||
end,
|
|
||||||
'LOADNIL', 'SETFIELD', 'SETFIELD', 'SETTABLE', 'RETURN0')
|
|
||||||
|
|
||||||
-- "get/set table" with numeric indices
|
|
||||||
check(function (a)
|
|
||||||
local k255 <const> = 255
|
|
||||||
a[1] = a[100]
|
|
||||||
a[k255] = a[256]
|
|
||||||
a[256] = 5
|
|
||||||
end,
|
|
||||||
'GETI', 'SETI',
|
|
||||||
'LOADI', 'GETTABLE', 'SETI',
|
|
||||||
'LOADI', 'SETTABLE', 'RETURN0')
|
|
||||||
|
|
||||||
check(function ()
|
|
||||||
local a,b
|
|
||||||
a = a - a
|
|
||||||
b = a/a
|
|
||||||
b = 5-4
|
|
||||||
end,
|
|
||||||
'LOADNIL', 'SUB', 'MMBIN', 'DIV', 'MMBIN', 'LOADI', 'RETURN0')
|
|
||||||
|
|
||||||
check(function ()
|
|
||||||
local a,b
|
|
||||||
a[kTrue] = false
|
|
||||||
end,
|
|
||||||
'LOADNIL', 'LOADTRUE', 'SETTABLE', 'RETURN0')
|
|
||||||
|
|
||||||
|
|
||||||
-- equalities
|
|
||||||
checkR(function (a) if a == 1 then return 2 end end, 1, 2,
|
|
||||||
'EQI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if -4.0 == a then return 2 end end, -4, 2,
|
|
||||||
'EQI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if a == "hi" then return 2 end end, 10, nil,
|
|
||||||
'EQK', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if a == 10000 then return 2 end end, 1, nil,
|
|
||||||
'EQK', 'JMP', 'LOADI', 'RETURN1') -- number too large
|
|
||||||
|
|
||||||
checkR(function (a) if -10000 == a then return 2 end end, -10000, 2,
|
|
||||||
'EQK', 'JMP', 'LOADI', 'RETURN1') -- number too large
|
|
||||||
|
|
||||||
-- comparisons
|
|
||||||
|
|
||||||
checkR(function (a) if -10 <= a then return 2 end end, -10, 2,
|
|
||||||
'GEI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if 128.0 > a then return 2 end end, 129, nil,
|
|
||||||
'LTI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if -127.0 < a then return 2 end end, -127, nil,
|
|
||||||
'GTI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if 10 < a then return 2 end end, 11, 2,
|
|
||||||
'GTI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if 129 < a then return 2 end end, 130, 2,
|
|
||||||
'LOADI', 'LT', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if a >= 23.0 then return 2 end end, 25, 2,
|
|
||||||
'GEI', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if a >= 23.1 then return 2 end end, 0, nil,
|
|
||||||
'LOADK', 'LE', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
checkR(function (a) if a > 2300.0 then return 2 end end, 0, nil,
|
|
||||||
'LOADF', 'LT', 'JMP', 'LOADI', 'RETURN1')
|
|
||||||
|
|
||||||
|
|
||||||
-- constant folding
|
|
||||||
local function checkK (func, val)
|
|
||||||
check(func, 'LOADK', 'RETURN1')
|
|
||||||
checkKlist(func, {val})
|
|
||||||
assert(func() == val)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checkI (func, val)
|
|
||||||
check(func, 'LOADI', 'RETURN1')
|
|
||||||
checkKlist(func, {})
|
|
||||||
assert(func() == val)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checkF (func, val)
|
|
||||||
check(func, 'LOADF', 'RETURN1')
|
|
||||||
checkKlist(func, {})
|
|
||||||
assert(func() == val)
|
|
||||||
end
|
|
||||||
|
|
||||||
checkF(function () return 0.0 end, 0.0)
|
|
||||||
checkI(function () return k0 end, 0)
|
|
||||||
checkI(function () return -k0//1 end, 0)
|
|
||||||
checkK(function () return 3^-1 end, 1/3)
|
|
||||||
checkK(function () return (1 + 1)^(50 + 50) end, 2^100)
|
|
||||||
checkK(function () return (-2)^(31 - 2) end, -0x20000000 + 0.0)
|
|
||||||
checkF(function () return (-k3^0 + 5) // 3.0 end, 1.0)
|
|
||||||
checkI(function () return -k3 % 5 end, 2)
|
|
||||||
checkF(function () return -((2.0^8 + -(-1)) % 8)/2 * 4 - 3 end, -5.0)
|
|
||||||
checkF(function () return -((2^8 + -(-1)) % 8)//2 * 4 - 3 end, -7.0)
|
|
||||||
checkI(function () return 0xF0.0 | 0xCC.0 ~ 0xAA & 0xFD end, 0xF4)
|
|
||||||
checkI(function () return ~(~kFF0 | kFF0) end, 0)
|
|
||||||
checkI(function () return ~~-1024.0 end, -1024)
|
|
||||||
checkI(function () return ((100 << k6) << -4) >> 2 end, 100)
|
|
||||||
|
|
||||||
-- borders around MAXARG_sBx ((((1 << 17) - 1) >> 1) == 65535)
|
|
||||||
local a = 17; local sbx = ((1 << a) - 1) >> 1 -- avoid folding
|
|
||||||
local border <const> = 65535
|
|
||||||
checkI(function () return border end, sbx)
|
|
||||||
checkI(function () return -border end, -sbx)
|
|
||||||
checkI(function () return border + 1 end, sbx + 1)
|
|
||||||
checkK(function () return border + 2 end, sbx + 2)
|
|
||||||
checkK(function () return -(border + 1) end, -(sbx + 1))
|
|
||||||
|
|
||||||
local border <const> = 65535.0
|
|
||||||
checkF(function () return border end, sbx + 0.0)
|
|
||||||
checkF(function () return -border end, -sbx + 0.0)
|
|
||||||
checkF(function () return border + 1 end, (sbx + 1.0))
|
|
||||||
checkK(function () return border + 2 end, (sbx + 2.0))
|
|
||||||
checkK(function () return -(border + 1) end, -(sbx + 1.0))
|
|
||||||
|
|
||||||
|
|
||||||
-- immediate operands
|
|
||||||
checkR(function (x) return x + k1 end, 10, 11, 'ADDI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x - 127 end, 10, -117, 'ADDI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return 128 + x end, 0.0, 128.0,
|
|
||||||
'ADDI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x * -127 end, -1.0, 127.0,
|
|
||||||
'MULK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return 20 * x end, 2, 40, 'MULK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x ^ -2 end, 2, 0.25, 'POWK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x / 40 end, 40, 1.0, 'DIVK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x // 1 end, 10.0, 10.0,
|
|
||||||
'IDIVK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x % (100 - 10) end, 91, 1,
|
|
||||||
'MODK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return k1 << x end, 3, 8, 'SHLI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x << 127 end, 10, 0, 'SHRI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x << -127 end, 10, 0, 'SHRI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x >> 128 end, 8, 0, 'SHRI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x >> -127 end, 8, 0, 'SHRI', 'MMBINI', 'RETURN1')
|
|
||||||
checkR(function (x) return x & 1 end, 9, 1, 'BANDK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return 10 | x end, 1, 11, 'BORK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return -10 ~ x end, -1, 9, 'BXORK', 'MMBINK', 'RETURN1')
|
|
||||||
|
|
||||||
-- K operands in arithmetic operations
|
|
||||||
checkR(function (x) return x + 0.0 end, 1, 1.0, 'ADDK', 'MMBINK', 'RETURN1')
|
|
||||||
-- check(function (x) return 128 + x end, 'ADDK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x * -10000 end, 2, -20000,
|
|
||||||
'MULK', 'MMBINK', 'RETURN1')
|
|
||||||
-- check(function (x) return 20 * x end, 'MULK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x ^ 0.5 end, 4, 2.0, 'POWK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x / 2.0 end, 4, 2.0, 'DIVK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x // 10000 end, 10000, 1,
|
|
||||||
'IDIVK', 'MMBINK', 'RETURN1')
|
|
||||||
checkR(function (x) return x % (100.0 - 10) end, 91, 1.0,
|
|
||||||
'MODK', 'MMBINK', 'RETURN1')
|
|
||||||
|
|
||||||
-- no foldings (and immediate operands)
|
|
||||||
check(function () return -0.0 end, 'LOADF', 'UNM', 'RETURN1')
|
|
||||||
check(function () return k3/0 end, 'LOADI', 'DIVK', 'MMBINK', 'RETURN1')
|
|
||||||
check(function () return 0%0 end, 'LOADI', 'MODK', 'MMBINK', 'RETURN1')
|
|
||||||
check(function () return -4//0 end, 'LOADI', 'IDIVK', 'MMBINK', 'RETURN1')
|
|
||||||
check(function (x) return x >> 2.0 end, 'LOADF', 'SHR', 'MMBIN', 'RETURN1')
|
|
||||||
check(function (x) return x << 128 end, 'LOADI', 'SHL', 'MMBIN', 'RETURN1')
|
|
||||||
check(function (x) return x & 2.0 end, 'LOADF', 'BAND', 'MMBIN', 'RETURN1')
|
|
||||||
|
|
||||||
-- basic 'for' loops
|
|
||||||
check(function () for i = -10, 10.5 do end end,
|
|
||||||
'LOADI', 'LOADK', 'LOADI', 'FORPREP', 'FORLOOP', 'RETURN0')
|
|
||||||
check(function () for i = 0xfffffff, 10.0, 1 do end end,
|
|
||||||
'LOADK', 'LOADF', 'LOADI', 'FORPREP', 'FORLOOP', 'RETURN0')
|
|
||||||
|
|
||||||
-- bug in constant folding for 5.1
|
|
||||||
check(function () return -nil end, 'LOADNIL', 'UNM', 'RETURN1')
|
|
||||||
|
|
||||||
|
|
||||||
check(function ()
|
|
||||||
local a,b,c
|
|
||||||
b[c], a = c, b
|
|
||||||
b[a], a = c, b
|
|
||||||
a, b = c, a
|
|
||||||
a = a
|
|
||||||
end,
|
|
||||||
'LOADNIL',
|
|
||||||
'MOVE', 'MOVE', 'SETTABLE',
|
|
||||||
'MOVE', 'MOVE', 'MOVE', 'SETTABLE',
|
|
||||||
'MOVE', 'MOVE', 'MOVE',
|
|
||||||
-- no code for a = a
|
|
||||||
'RETURN0')
|
|
||||||
|
|
||||||
|
|
||||||
-- x == nil , x ~= nil
|
|
||||||
-- checkequal(function (b) if (a==nil) then a=1 end; if a~=nil then a=1 end end,
|
|
||||||
-- function () if (a==9) then a=1 end; if a~=9 then a=1 end end)
|
|
||||||
|
|
||||||
-- check(function () if a==nil then a='a' end end,
|
|
||||||
-- 'GETTABUP', 'EQ', 'JMP', 'SETTABUP', 'RETURN')
|
|
||||||
|
|
||||||
do -- tests for table access in upvalues
|
|
||||||
local t
|
|
||||||
check(function () t[kx] = t.y end, 'GETTABUP', 'SETTABUP')
|
|
||||||
check(function (a) t[a()] = t[a()] end,
|
|
||||||
'MOVE', 'CALL', 'GETUPVAL', 'MOVE', 'CALL',
|
|
||||||
'GETUPVAL', 'GETTABLE', 'SETTABLE')
|
|
||||||
end
|
|
||||||
|
|
||||||
-- de morgan
|
|
||||||
checkequal(function () local a; if not (a or b) then b=a end end,
|
|
||||||
function () local a; if (not a and not b) then b=a end end)
|
|
||||||
|
|
||||||
checkequal(function (l) local a; return 0 <= a and a <= l end,
|
|
||||||
function (l) local a; return not (not(a >= 0) or not(a <= l)) end)
|
|
||||||
|
|
||||||
|
|
||||||
-- if-break optimizations
|
|
||||||
check(function (a, b)
|
|
||||||
while a do
|
|
||||||
if b then break else a = a + 1 end
|
|
||||||
end
|
|
||||||
end,
|
|
||||||
'TEST', 'JMP', 'TEST', 'JMP', 'ADDI', 'MMBINI', 'JMP', 'RETURN0')
|
|
||||||
|
|
||||||
checkequal(function () return 6 or true or nil end,
|
|
||||||
function () return k6 or kTrue or kNil end)
|
|
||||||
|
|
||||||
checkequal(function () return 6 and true or nil end,
|
|
||||||
function () return k6 and kTrue or kNil end)
|
|
||||||
|
|
||||||
|
|
||||||
do -- string constants
|
|
||||||
local k0 <const> = "00000000000000000000000000000000000000000000000000"
|
|
||||||
local function f1 ()
|
|
||||||
local k <const> = k0
|
|
||||||
return function ()
|
|
||||||
return function () return k end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local f2 = f1()
|
|
||||||
local f3 = f2()
|
|
||||||
assert(f3() == k0)
|
|
||||||
checkK(f3, k0)
|
|
||||||
-- string is not needed by other functions
|
|
||||||
assert(T.listk(f1)[1] == nil)
|
|
||||||
assert(T.listk(f2)[1] == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
print 'OK'
|
|
||||||
|
|
||||||
@ -1,406 +0,0 @@
|
|||||||
-- $Id: testes/constructs.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
;;print "testing syntax";;
|
|
||||||
|
|
||||||
local debug = require "debug"
|
|
||||||
|
|
||||||
|
|
||||||
local function checkload (s, msg)
|
|
||||||
assert(string.find(select(2, load(s)), msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- testing semicollons
|
|
||||||
local a
|
|
||||||
do ;;; end
|
|
||||||
; do ; a = 3; assert(a == 3) end;
|
|
||||||
;
|
|
||||||
|
|
||||||
|
|
||||||
-- invalid operations should not raise errors when not executed
|
|
||||||
if false then a = 3 // 0; a = 0 % 0 end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing priorities
|
|
||||||
|
|
||||||
assert(2^3^2 == 2^(3^2));
|
|
||||||
assert(2^3*4 == (2^3)*4);
|
|
||||||
assert(2.0^-2 == 1/4 and -2^- -2 == - - -4);
|
|
||||||
assert(not nil and 2 and not(2>3 or 3<2));
|
|
||||||
assert(-3-1-5 == 0+0-9);
|
|
||||||
assert(-2^2 == -4 and (-2)^2 == 4 and 2*2-3-1 == 0);
|
|
||||||
assert(-3%5 == 2 and -3+5 == 2)
|
|
||||||
assert(2*1+3/3 == 3 and 1+2 .. 3*1 == "33");
|
|
||||||
assert(not(2+1 > 3*1) and "a".."b" > "a");
|
|
||||||
|
|
||||||
assert(0xF0 | 0xCC ~ 0xAA & 0xFD == 0xF4)
|
|
||||||
assert(0xFD & 0xAA ~ 0xCC | 0xF0 == 0xF4)
|
|
||||||
assert(0xF0 & 0x0F + 1 == 0x10)
|
|
||||||
|
|
||||||
assert(3^4//2^3//5 == 2)
|
|
||||||
|
|
||||||
assert(-3+4*5//2^3^2//9+4%10/3 == (-3)+(((4*5)//(2^(3^2)))//9)+((4%10)/3))
|
|
||||||
|
|
||||||
assert(not ((true or false) and nil))
|
|
||||||
assert( true or false and nil)
|
|
||||||
|
|
||||||
-- old bug
|
|
||||||
assert((((1 or false) and true) or false) == true)
|
|
||||||
assert((((nil and true) or false) and true) == false)
|
|
||||||
|
|
||||||
local a,b = 1,nil;
|
|
||||||
assert(-(1 or 2) == -1 and (1 and 2)+(-1.25 or -4) == 0.75);
|
|
||||||
local x = ((b or a)+1 == 2 and (10 or a)+1 == 11); assert(x);
|
|
||||||
x = (((2<3) or 1) == true and (2<3 and 4) == 4); assert(x);
|
|
||||||
|
|
||||||
local x, y = 1, 2;
|
|
||||||
assert((x>y) and x or y == 2);
|
|
||||||
x,y=2,1;
|
|
||||||
assert((x>y) and x or y == 2);
|
|
||||||
|
|
||||||
assert(1234567890 == tonumber('1234567890') and 1234567890+1 == 1234567891)
|
|
||||||
|
|
||||||
do -- testing operators with diffent kinds of constants
|
|
||||||
-- operands to consider:
|
|
||||||
-- * fit in register
|
|
||||||
-- * constant doesn't fit in register
|
|
||||||
-- * floats with integral values
|
|
||||||
local operand = {3, 100, 5.0, -10, -5.0, 10000, -10000}
|
|
||||||
local operator = {"+", "-", "*", "/", "//", "%", "^",
|
|
||||||
"&", "|", "^", "<<", ">>",
|
|
||||||
"==", "~=", "<", ">", "<=", ">=",}
|
|
||||||
for _, op in ipairs(operator) do
|
|
||||||
local f = assert(load(string.format([[return function (x,y)
|
|
||||||
return x %s y
|
|
||||||
end]], op)))();
|
|
||||||
for _, o1 in ipairs(operand) do
|
|
||||||
for _, o2 in ipairs(operand) do
|
|
||||||
local gab = f(o1, o2)
|
|
||||||
|
|
||||||
_ENV.XX = o1
|
|
||||||
local code = string.format("return XX %s %s", op, o2)
|
|
||||||
local res = assert(load(code))()
|
|
||||||
assert(res == gab)
|
|
||||||
|
|
||||||
_ENV.XX = o2
|
|
||||||
code = string.format("return (%s) %s XX", o1, op)
|
|
||||||
res = assert(load(code))()
|
|
||||||
assert(res == gab)
|
|
||||||
|
|
||||||
code = string.format("return (%s) %s %s", o1, op, o2)
|
|
||||||
res = assert(load(code))()
|
|
||||||
assert(res == gab)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
_ENV.XX = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- silly loops
|
|
||||||
repeat until 1; repeat until true;
|
|
||||||
while false do end; while nil do end;
|
|
||||||
|
|
||||||
do -- test old bug (first name could not be an `upvalue')
|
|
||||||
local a; local function f(x) x={a=1}; x={x=1}; x={G=1} end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug since 5.4.0
|
|
||||||
-- create code with a table using more than 256 constants
|
|
||||||
local code = {"local x = {"}
|
|
||||||
for i = 1, 257 do
|
|
||||||
code[#code + 1] = i .. ".1,"
|
|
||||||
end
|
|
||||||
code[#code + 1] = "};"
|
|
||||||
code = table.concat(code)
|
|
||||||
|
|
||||||
-- add "ret" to the end of that code and checks that
|
|
||||||
-- it produces the expected value "val"
|
|
||||||
local function check (ret, val)
|
|
||||||
local code = code .. ret
|
|
||||||
code = load(code)
|
|
||||||
assert(code() == val)
|
|
||||||
end
|
|
||||||
|
|
||||||
check("return (1 ~ (2 or 3))", 1 ~ 2)
|
|
||||||
check("return (1 | (2 or 3))", 1 | 2)
|
|
||||||
check("return (1 + (2 or 3))", 1 + 2)
|
|
||||||
check("return (1 << (2 or 3))", 1 << 2)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function f (i)
|
|
||||||
if type(i) ~= 'number' then return i,'jojo'; end;
|
|
||||||
if i > 0 then return i, f(i-1); end;
|
|
||||||
end
|
|
||||||
|
|
||||||
x = {f(3), f(5), f(10);};
|
|
||||||
assert(x[1] == 3 and x[2] == 5 and x[3] == 10 and x[4] == 9 and x[12] == 1);
|
|
||||||
assert(x[nil] == nil)
|
|
||||||
x = {f'alo', f'xixi', nil};
|
|
||||||
assert(x[1] == 'alo' and x[2] == 'xixi' and x[3] == nil);
|
|
||||||
x = {f'alo'..'xixi'};
|
|
||||||
assert(x[1] == 'aloxixi')
|
|
||||||
x = {f{}}
|
|
||||||
assert(x[2] == 'jojo' and type(x[1]) == 'table')
|
|
||||||
|
|
||||||
|
|
||||||
local f = function (i)
|
|
||||||
if i < 10 then return 'a';
|
|
||||||
elseif i < 20 then return 'b';
|
|
||||||
elseif i < 30 then return 'c';
|
|
||||||
end;
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == nil)
|
|
||||||
|
|
||||||
for i=1,1000 do break; end;
|
|
||||||
local n=100;
|
|
||||||
local i=3;
|
|
||||||
local t = {};
|
|
||||||
local a=nil
|
|
||||||
while not a do
|
|
||||||
a=0; for i=1,n do for i=i,1,-1 do a=a+1; t[i]=1; end; end;
|
|
||||||
end
|
|
||||||
assert(a == n*(n+1)/2 and i==3);
|
|
||||||
assert(t[1] and t[n] and not t[0] and not t[n+1])
|
|
||||||
|
|
||||||
function f(b)
|
|
||||||
local x = 1;
|
|
||||||
repeat
|
|
||||||
local a;
|
|
||||||
if b==1 then local b=1; x=10; break
|
|
||||||
elseif b==2 then x=20; break;
|
|
||||||
elseif b==3 then x=30;
|
|
||||||
else local a,b,c,d=math.sin(1); x=x+1;
|
|
||||||
end
|
|
||||||
until x>=12;
|
|
||||||
return x;
|
|
||||||
end;
|
|
||||||
|
|
||||||
assert(f(1) == 10 and f(2) == 20 and f(3) == 30 and f(4)==12)
|
|
||||||
|
|
||||||
|
|
||||||
local f = function (i)
|
|
||||||
if i < 10 then return 'a'
|
|
||||||
elseif i < 20 then return 'b'
|
|
||||||
elseif i < 30 then return 'c'
|
|
||||||
else return 8
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == 8)
|
|
||||||
|
|
||||||
local a, b = nil, 23
|
|
||||||
x = {f(100)*2+3 or a, a or b+2}
|
|
||||||
assert(x[1] == 19 and x[2] == 25)
|
|
||||||
x = {f=2+3 or a, a = b+2}
|
|
||||||
assert(x.f == 5 and x.a == 25)
|
|
||||||
|
|
||||||
a={y=1}
|
|
||||||
x = {a.y}
|
|
||||||
assert(x[1] == 1)
|
|
||||||
|
|
||||||
local function f (i)
|
|
||||||
while 1 do
|
|
||||||
if i>0 then i=i-1;
|
|
||||||
else return; end;
|
|
||||||
end;
|
|
||||||
end;
|
|
||||||
|
|
||||||
local function g(i)
|
|
||||||
while 1 do
|
|
||||||
if i>0 then i=i-1
|
|
||||||
else return end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
f(10); g(10);
|
|
||||||
|
|
||||||
do
|
|
||||||
function f () return 1,2,3; end
|
|
||||||
local a, b, c = f();
|
|
||||||
assert(a==1 and b==2 and c==3)
|
|
||||||
a, b, c = (f());
|
|
||||||
assert(a==1 and b==nil and c==nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
local a,b = 3 and f();
|
|
||||||
assert(a==1 and b==nil)
|
|
||||||
|
|
||||||
function g() f(); return; end;
|
|
||||||
assert(g() == nil)
|
|
||||||
function g() return nil or f() end
|
|
||||||
a,b = g()
|
|
||||||
assert(a==1 and b==nil)
|
|
||||||
|
|
||||||
print'+';
|
|
||||||
|
|
||||||
do -- testing constants
|
|
||||||
local prog <const> = [[local x <XXX> = 10]]
|
|
||||||
checkload(prog, "unknown attribute 'XXX'")
|
|
||||||
|
|
||||||
checkload([[local xxx <const> = 20; xxx = 10]],
|
|
||||||
":1: attempt to assign to const variable 'xxx'")
|
|
||||||
|
|
||||||
checkload([[
|
|
||||||
local xx;
|
|
||||||
local xxx <const> = 20;
|
|
||||||
local yyy;
|
|
||||||
local function foo ()
|
|
||||||
local abc = xx + yyy + xxx;
|
|
||||||
return function () return function () xxx = yyy end end
|
|
||||||
end
|
|
||||||
]], ":6: attempt to assign to const variable 'xxx'")
|
|
||||||
|
|
||||||
checkload([[
|
|
||||||
local x <close> = nil
|
|
||||||
x = io.open()
|
|
||||||
]], ":2: attempt to assign to const variable 'x'")
|
|
||||||
end
|
|
||||||
|
|
||||||
f = [[
|
|
||||||
return function ( a , b , c , d , e )
|
|
||||||
local x = a >= b or c or ( d and e ) or nil
|
|
||||||
return x
|
|
||||||
end , { a = 1 , b = 2 >= 1 , } or { 1 };
|
|
||||||
]]
|
|
||||||
f = string.gsub(f, "%s+", "\n"); -- force a SETLINE between opcodes
|
|
||||||
f,a = load(f)();
|
|
||||||
assert(a.a == 1 and a.b)
|
|
||||||
|
|
||||||
function g (a,b,c,d,e)
|
|
||||||
if not (a>=b or c or d and e or nil) then return 0; else return 1; end;
|
|
||||||
end
|
|
||||||
|
|
||||||
local function h (a,b,c,d,e)
|
|
||||||
while (a>=b or c or (d and e) or nil) do return 1; end;
|
|
||||||
return 0;
|
|
||||||
end;
|
|
||||||
|
|
||||||
assert(f(2,1) == true and g(2,1) == 1 and h(2,1) == 1)
|
|
||||||
assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1)
|
|
||||||
assert(f(1,2,'a')
|
|
||||||
~= -- force SETLINE before nil
|
|
||||||
nil, "")
|
|
||||||
assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1)
|
|
||||||
assert(f(1,2,nil,1,'x') == 'x' and g(1,2,nil,1,'x') == 1 and
|
|
||||||
h(1,2,nil,1,'x') == 1)
|
|
||||||
assert(f(1,2,nil,nil,'x') == nil and g(1,2,nil,nil,'x') == 0 and
|
|
||||||
h(1,2,nil,nil,'x') == 0)
|
|
||||||
assert(f(1,2,nil,1,nil) == nil and g(1,2,nil,1,nil) == 0 and
|
|
||||||
h(1,2,nil,1,nil) == 0)
|
|
||||||
|
|
||||||
assert(1 and 2<3 == true and 2<3 and 'a'<'b' == true)
|
|
||||||
x = 2<3 and not 3; assert(x==false)
|
|
||||||
x = 2<1 or (2>1 and 'a'); assert(x=='a')
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
local a; if nil then a=1; else a=2; end; -- this nil comes as PUSHNIL 2
|
|
||||||
assert(a==2)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function F (a)
|
|
||||||
assert(debug.getinfo(1, "n").name == 'F')
|
|
||||||
return a,2,3
|
|
||||||
end
|
|
||||||
|
|
||||||
a,b = F(1)~=nil; assert(a == true and b == nil);
|
|
||||||
a,b = F(nil)==nil; assert(a == true and b == nil)
|
|
||||||
|
|
||||||
----------------------------------------------------------------
|
|
||||||
------------------------------------------------------------------
|
|
||||||
|
|
||||||
-- sometimes will be 0, sometimes will not...
|
|
||||||
_ENV.GLOB1 = math.random(0, 1)
|
|
||||||
|
|
||||||
-- basic expressions with their respective values
|
|
||||||
local basiccases = {
|
|
||||||
{"nil", nil},
|
|
||||||
{"false", false},
|
|
||||||
{"true", true},
|
|
||||||
{"10", 10},
|
|
||||||
{"(0==_ENV.GLOB1)", 0 == _ENV.GLOB1},
|
|
||||||
}
|
|
||||||
|
|
||||||
local prog
|
|
||||||
|
|
||||||
if _ENV.GLOB1 == 0 then
|
|
||||||
basiccases[2][1] = "F" -- constant false
|
|
||||||
|
|
||||||
prog = [[
|
|
||||||
local F <const> = false
|
|
||||||
if %s then IX = true end
|
|
||||||
return %s
|
|
||||||
]]
|
|
||||||
else
|
|
||||||
basiccases[4][1] = "k10" -- constant 10
|
|
||||||
|
|
||||||
prog = [[
|
|
||||||
local k10 <const> = 10
|
|
||||||
if %s then IX = true end
|
|
||||||
return %s
|
|
||||||
]]
|
|
||||||
end
|
|
||||||
|
|
||||||
print('testing short-circuit optimizations (' .. _ENV.GLOB1 .. ')')
|
|
||||||
|
|
||||||
|
|
||||||
-- operators with their respective values
|
|
||||||
local binops <const> = {
|
|
||||||
{" and ", function (a,b) if not a then return a else return b end end},
|
|
||||||
{" or ", function (a,b) if a then return a else return b end end},
|
|
||||||
}
|
|
||||||
|
|
||||||
local cases <const> = {}
|
|
||||||
|
|
||||||
-- creates all combinations of '(cases[i] op cases[n-i])' plus
|
|
||||||
-- 'not(cases[i] op cases[n-i])' (syntax + value)
|
|
||||||
local function createcases (n)
|
|
||||||
local res = {}
|
|
||||||
for i = 1, n - 1 do
|
|
||||||
for _, v1 in ipairs(cases[i]) do
|
|
||||||
for _, v2 in ipairs(cases[n - i]) do
|
|
||||||
for _, op in ipairs(binops) do
|
|
||||||
local t = {
|
|
||||||
"(" .. v1[1] .. op[1] .. v2[1] .. ")",
|
|
||||||
op[2](v1[2], v2[2])
|
|
||||||
}
|
|
||||||
res[#res + 1] = t
|
|
||||||
res[#res + 1] = {"not" .. t[1], not t[2]}
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
return res
|
|
||||||
end
|
|
||||||
|
|
||||||
-- do not do too many combinations for soft tests
|
|
||||||
local level = _soft and 3 or 4
|
|
||||||
|
|
||||||
cases[1] = basiccases
|
|
||||||
for i = 2, level do cases[i] = createcases(i) end
|
|
||||||
print("+")
|
|
||||||
|
|
||||||
local i = 0
|
|
||||||
for n = 1, level do
|
|
||||||
for _, v in pairs(cases[n]) do
|
|
||||||
local s = v[1]
|
|
||||||
local p = load(string.format(prog, s, s), "")
|
|
||||||
IX = false
|
|
||||||
assert(p() == v[2] and IX == not not v[2])
|
|
||||||
i = i + 1
|
|
||||||
if i % 60000 == 0 then print('+') end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
IX = nil
|
|
||||||
_G.GLOB1 = nil
|
|
||||||
------------------------------------------------------------------
|
|
||||||
|
|
||||||
-- testing some syntax errors (chosen through 'gcov')
|
|
||||||
checkload("for x do", "expected")
|
|
||||||
checkload("x:call", "expected")
|
|
||||||
|
|
||||||
print'OK'
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,197 +0,0 @@
|
|||||||
-- $Id: testes/cstack.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
|
|
||||||
local tracegc = require"tracegc"
|
|
||||||
|
|
||||||
print"testing stack overflow detection"
|
|
||||||
|
|
||||||
-- Segmentation faults in these tests probably result from a C-stack
|
|
||||||
-- overflow. To avoid these errors, you should set a smaller limit for
|
|
||||||
-- the use of C stack by Lua, by changing the constant 'LUAI_MAXCCALLS'.
|
|
||||||
-- Alternatively, you can ensure a larger stack for the program.
|
|
||||||
|
|
||||||
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local s, err = pcall(f, ...)
|
|
||||||
assert(not s and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
do print("testing stack overflow in message handling")
|
|
||||||
local count = 0
|
|
||||||
local function loop (x, y, z)
|
|
||||||
count = count + 1
|
|
||||||
return 1 + loop(x, y, z)
|
|
||||||
end
|
|
||||||
tracegc.stop() -- __gc should not be called with a full stack
|
|
||||||
local res, msg = xpcall(loop, loop)
|
|
||||||
tracegc.start()
|
|
||||||
assert(msg == "error in error handling")
|
|
||||||
print("final count: ", count)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- bug since 2.5 (C-stack overflow in recursion inside pattern matching)
|
|
||||||
do print("testing recursion inside pattern matching")
|
|
||||||
local function f (size)
|
|
||||||
local s = string.rep("a", size)
|
|
||||||
local p = string.rep(".?", size)
|
|
||||||
return string.match(s, p)
|
|
||||||
end
|
|
||||||
local m = f(80)
|
|
||||||
assert(#m == 80)
|
|
||||||
checkerror("too complex", f, 2000)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do print("testing stack-overflow in recursive 'gsub'")
|
|
||||||
local count = 0
|
|
||||||
local function foo ()
|
|
||||||
count = count + 1
|
|
||||||
string.gsub("a", ".", foo)
|
|
||||||
end
|
|
||||||
checkerror("stack overflow", foo)
|
|
||||||
print("final count: ", count)
|
|
||||||
|
|
||||||
print("testing stack-overflow in recursive 'gsub' with metatables")
|
|
||||||
local count = 0
|
|
||||||
local t = setmetatable({}, {__index = foo})
|
|
||||||
foo = function ()
|
|
||||||
count = count + 1
|
|
||||||
string.gsub("a", ".", t)
|
|
||||||
end
|
|
||||||
checkerror("stack overflow", foo)
|
|
||||||
print("final count: ", count)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug in 5.4.0
|
|
||||||
print("testing limits in coroutines inside deep calls")
|
|
||||||
local count = 0
|
|
||||||
local lim = 1000
|
|
||||||
local function stack (n)
|
|
||||||
if n > 0 then return stack(n - 1) + 1
|
|
||||||
else coroutine.wrap(function ()
|
|
||||||
count = count + 1
|
|
||||||
stack(lim)
|
|
||||||
end)()
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local st, msg = xpcall(stack, function () return "ok" end, lim)
|
|
||||||
assert(not st and msg == "ok")
|
|
||||||
print("final count: ", count)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug since 5.4.0
|
|
||||||
local count = 0
|
|
||||||
print("chain of 'coroutine.close'")
|
|
||||||
-- create N coroutines forming a list so that each one, when closed,
|
|
||||||
-- closes the previous one. (With a large enough N, previous Lua
|
|
||||||
-- versions crash in this test.)
|
|
||||||
local coro = false
|
|
||||||
for i = 1, 1000 do
|
|
||||||
local previous = coro
|
|
||||||
coro = coroutine.create(function()
|
|
||||||
local cc <close> = setmetatable({}, {__close=function()
|
|
||||||
count = count + 1
|
|
||||||
if previous then
|
|
||||||
assert(coroutine.close(previous))
|
|
||||||
end
|
|
||||||
end})
|
|
||||||
coroutine.yield() -- leaves 'cc' pending to be closed
|
|
||||||
end)
|
|
||||||
assert(coroutine.resume(coro)) -- start it and run until it yields
|
|
||||||
end
|
|
||||||
local st, msg = coroutine.close(coro)
|
|
||||||
assert(not st and string.find(msg, "C stack overflow"))
|
|
||||||
print("final count: ", count)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
print("nesting of resuming yielded coroutines")
|
|
||||||
local count = 0
|
|
||||||
|
|
||||||
local function body ()
|
|
||||||
coroutine.yield()
|
|
||||||
local f = coroutine.wrap(body)
|
|
||||||
f(); -- start new coroutine (will stop in previous yield)
|
|
||||||
count = count + 1
|
|
||||||
f() -- call it recursively
|
|
||||||
end
|
|
||||||
|
|
||||||
local f = coroutine.wrap(body)
|
|
||||||
f()
|
|
||||||
assert(not pcall(f))
|
|
||||||
print("final count: ", count)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug in 5.4.2
|
|
||||||
print("nesting coroutines running after recoverable errors")
|
|
||||||
local count = 0
|
|
||||||
local function foo()
|
|
||||||
count = count + 1
|
|
||||||
pcall(1) -- create an error
|
|
||||||
-- running now inside 'precover' ("protected recover")
|
|
||||||
coroutine.wrap(foo)() -- call another coroutine
|
|
||||||
end
|
|
||||||
checkerror("C stack overflow", foo)
|
|
||||||
print("final count: ", count)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if T then
|
|
||||||
print("testing stack recovery")
|
|
||||||
local N = 0 -- trace number of calls
|
|
||||||
local LIM = -1 -- will store N just before stack overflow
|
|
||||||
|
|
||||||
-- trace stack size; after stack overflow, it should be
|
|
||||||
-- the maximum allowed stack size.
|
|
||||||
local stack1
|
|
||||||
local dummy
|
|
||||||
|
|
||||||
local function err(msg)
|
|
||||||
assert(string.find(msg, "stack overflow"))
|
|
||||||
local _, stacknow = T.stacklevel()
|
|
||||||
assert(stacknow == stack1 + 200)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- When LIM==-1, the 'if' is not executed, so this function only
|
|
||||||
-- counts and stores the stack limits up to overflow. Then, LIM
|
|
||||||
-- becomes N, and then the 'if' code is run when the stack is
|
|
||||||
-- full. Then, there is a stack overflow inside 'xpcall', after which
|
|
||||||
-- the stack must have been restored back to its maximum normal size.
|
|
||||||
local function f()
|
|
||||||
dummy, stack1 = T.stacklevel()
|
|
||||||
if N == LIM then
|
|
||||||
xpcall(f, err)
|
|
||||||
local _, stacknow = T.stacklevel()
|
|
||||||
assert(stacknow == stack1)
|
|
||||||
return
|
|
||||||
end
|
|
||||||
N = N + 1
|
|
||||||
f()
|
|
||||||
end
|
|
||||||
|
|
||||||
local topB, sizeB -- top and size Before overflow
|
|
||||||
local topA, sizeA -- top and size After overflow
|
|
||||||
topB, sizeB = T.stacklevel()
|
|
||||||
tracegc.stop() -- __gc should not be called with a full stack
|
|
||||||
xpcall(f, err)
|
|
||||||
tracegc.start()
|
|
||||||
topA, sizeA = T.stacklevel()
|
|
||||||
-- sizes should be comparable
|
|
||||||
assert(topA == topB and sizeA < sizeB * 2)
|
|
||||||
print(string.format("maximum stack size: %d", stack1))
|
|
||||||
LIM = N -- will stop recursion at maximum level
|
|
||||||
N = 0 -- to count again
|
|
||||||
tracegc.stop() -- __gc should not be called with a full stack
|
|
||||||
f()
|
|
||||||
tracegc.start()
|
|
||||||
print"+"
|
|
||||||
end
|
|
||||||
|
|
||||||
print'OK'
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,680 +0,0 @@
|
|||||||
-- $Id: testes/errors.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print("testing errors")
|
|
||||||
|
|
||||||
local debug = require"debug"
|
|
||||||
|
|
||||||
-- avoid problems with 'strict' module (which may generate other error messages)
|
|
||||||
local mt = getmetatable(_G) or {}
|
|
||||||
local oldmm = mt.__index
|
|
||||||
mt.__index = nil
|
|
||||||
|
|
||||||
local function checkerr (msg, f, ...)
|
|
||||||
local st, err = pcall(f, ...)
|
|
||||||
assert(not st and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function doit (s)
|
|
||||||
local f, msg = load(s)
|
|
||||||
if not f then return msg end
|
|
||||||
local cond, msg = pcall(f)
|
|
||||||
return (not cond) and msg
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function checkmessage (prog, msg, debug)
|
|
||||||
local m = doit(prog)
|
|
||||||
if debug then print(m, msg) end
|
|
||||||
assert(string.find(m, msg, 1, true))
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checksyntax (prog, extra, token, line)
|
|
||||||
local msg = doit(prog)
|
|
||||||
if not string.find(token, "^<%a") and not string.find(token, "^char%(")
|
|
||||||
then token = "'"..token.."'" end
|
|
||||||
token = string.gsub(token, "(%p)", "%%%1")
|
|
||||||
local pt = string.format([[^%%[string ".*"%%]:%d: .- near %s$]],
|
|
||||||
line, token)
|
|
||||||
assert(string.find(msg, pt))
|
|
||||||
assert(string.find(msg, msg, 1, true))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- test error message with no extra info
|
|
||||||
assert(doit("error('hi', 0)") == 'hi')
|
|
||||||
|
|
||||||
-- test error message with no info
|
|
||||||
assert(doit("error()") == nil)
|
|
||||||
|
|
||||||
|
|
||||||
-- test common errors/errors that crashed in the past
|
|
||||||
assert(doit("table.unpack({}, 1, n=2^30)"))
|
|
||||||
assert(doit("a=math.sin()"))
|
|
||||||
assert(not doit("tostring(1)") and doit("tostring()"))
|
|
||||||
assert(doit"tonumber()")
|
|
||||||
assert(doit"repeat until 1; a")
|
|
||||||
assert(doit"return;;")
|
|
||||||
assert(doit"assert(false)")
|
|
||||||
assert(doit"assert(nil)")
|
|
||||||
assert(doit("function a (... , ...) end"))
|
|
||||||
assert(doit("function a (, ...) end"))
|
|
||||||
assert(doit("local t={}; t = t[#t] + 1"))
|
|
||||||
|
|
||||||
checksyntax([[
|
|
||||||
local a = {4
|
|
||||||
|
|
||||||
]], "'}' expected (to close '{' at line 1)", "<eof>", 3)
|
|
||||||
|
|
||||||
|
|
||||||
do -- testing errors in goto/break
|
|
||||||
local function checksyntax (prog, msg, line)
|
|
||||||
local st, err = load(prog)
|
|
||||||
assert(string.find(err, "line " .. line))
|
|
||||||
assert(string.find(err, msg, 1, true))
|
|
||||||
end
|
|
||||||
|
|
||||||
checksyntax([[
|
|
||||||
::A:: a = 1
|
|
||||||
::A::
|
|
||||||
]], "label 'A' already defined", 1)
|
|
||||||
|
|
||||||
checksyntax([[
|
|
||||||
a = 1
|
|
||||||
goto A
|
|
||||||
do ::A:: end
|
|
||||||
]], "no visible label 'A'", 2)
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not T then
|
|
||||||
(Message or print)
|
|
||||||
('\n >>> testC not active: skipping memory message test <<<\n')
|
|
||||||
else
|
|
||||||
print "testing memory error message"
|
|
||||||
local a = {}
|
|
||||||
for i = 1, 10000 do a[i] = true end -- preallocate array
|
|
||||||
collectgarbage()
|
|
||||||
T.totalmem(T.totalmem() + 10000)
|
|
||||||
-- force a memory error (by a small margin)
|
|
||||||
local st, msg = pcall(function()
|
|
||||||
for i = 1, 100000 do a[i] = tostring(i) end
|
|
||||||
end)
|
|
||||||
T.totalmem(0)
|
|
||||||
assert(not st and msg == "not enough" .. " memory")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- tests for better error messages
|
|
||||||
|
|
||||||
checkmessage("a = {} + 1", "arithmetic")
|
|
||||||
checkmessage("a = {} | 1", "bitwise operation")
|
|
||||||
checkmessage("a = {} < 1", "attempt to compare")
|
|
||||||
checkmessage("a = {} <= 1", "attempt to compare")
|
|
||||||
|
|
||||||
checkmessage("aaa=1; bbbb=2; aaa=math.sin(3)+bbbb(3)", "global 'bbbb'")
|
|
||||||
checkmessage("aaa={}; do local aaa=1 end aaa:bbbb(3)", "method 'bbbb'")
|
|
||||||
checkmessage("local a={}; a.bbbb(3)", "field 'bbbb'")
|
|
||||||
assert(not string.find(doit"aaa={13}; local bbbb=1; aaa[bbbb](3)", "'bbbb'"))
|
|
||||||
checkmessage("aaa={13}; local bbbb=1; aaa[bbbb](3)", "number")
|
|
||||||
checkmessage("aaa=(1)..{}", "a table value")
|
|
||||||
|
|
||||||
_G.aaa, _G.bbbb = nil
|
|
||||||
|
|
||||||
-- calls
|
|
||||||
checkmessage("local a; a(13)", "local 'a'")
|
|
||||||
checkmessage([[
|
|
||||||
local a = setmetatable({}, {__add = 34})
|
|
||||||
a = a + 1
|
|
||||||
]], "metamethod 'add'")
|
|
||||||
checkmessage([[
|
|
||||||
local a = setmetatable({}, {__lt = {}})
|
|
||||||
a = a > a
|
|
||||||
]], "metamethod 'lt'")
|
|
||||||
|
|
||||||
-- tail calls
|
|
||||||
checkmessage("local a={}; return a.bbbb(3)", "field 'bbbb'")
|
|
||||||
checkmessage("aaa={}; do local aaa=1 end; return aaa:bbbb(3)", "method 'bbbb'")
|
|
||||||
|
|
||||||
checkmessage("aaa = #print", "length of a function value")
|
|
||||||
checkmessage("aaa = #3", "length of a number value")
|
|
||||||
|
|
||||||
_G.aaa = nil
|
|
||||||
|
|
||||||
checkmessage("aaa.bbb:ddd(9)", "global 'aaa'")
|
|
||||||
checkmessage("local aaa={bbb=1}; aaa.bbb:ddd(9)", "field 'bbb'")
|
|
||||||
checkmessage("local aaa={bbb={}}; aaa.bbb:ddd(9)", "method 'ddd'")
|
|
||||||
checkmessage("local a,b,c; (function () a = b+1.1 end)()", "upvalue 'b'")
|
|
||||||
assert(not doit"local aaa={bbb={ddd=next}}; aaa.bbb:ddd(nil)")
|
|
||||||
|
|
||||||
-- upvalues being indexed do not go to the stack
|
|
||||||
checkmessage("local a,b,cc; (function () a = cc[1] end)()", "upvalue 'cc'")
|
|
||||||
checkmessage("local a,b,cc; (function () a.x = 1 end)()", "upvalue 'a'")
|
|
||||||
|
|
||||||
checkmessage("local _ENV = {x={}}; a = a + 1", "global 'a'")
|
|
||||||
|
|
||||||
checkmessage("BB=1; local aaa={}; x=aaa+BB", "local 'aaa'")
|
|
||||||
checkmessage("aaa={}; x=3.3/aaa", "global 'aaa'")
|
|
||||||
checkmessage("aaa=2; BB=nil;x=aaa*BB", "global 'BB'")
|
|
||||||
checkmessage("aaa={}; x=-aaa", "global 'aaa'")
|
|
||||||
|
|
||||||
-- short circuit
|
|
||||||
checkmessage("aaa=1; local aaa,bbbb=2,3; aaa = math.sin(1) and bbbb(3)",
|
|
||||||
"local 'bbbb'")
|
|
||||||
checkmessage("aaa=1; local aaa,bbbb=2,3; aaa = bbbb(1) or aaa(3)",
|
|
||||||
"local 'bbbb'")
|
|
||||||
checkmessage("local a,b,c,f = 1,1,1; f((a and b) or c)", "local 'f'")
|
|
||||||
checkmessage("local a,b,c = 1,1,1; ((a and b) or c)()", "call a number value")
|
|
||||||
assert(not string.find(doit"aaa={}; x=(aaa or aaa)+(aaa and aaa)", "'aaa'"))
|
|
||||||
assert(not string.find(doit"aaa={}; (aaa or aaa)()", "'aaa'"))
|
|
||||||
|
|
||||||
checkmessage("print(print < 10)", "function with number")
|
|
||||||
checkmessage("print(print < print)", "two function values")
|
|
||||||
checkmessage("print('10' < 10)", "string with number")
|
|
||||||
checkmessage("print(10 < '23')", "number with string")
|
|
||||||
|
|
||||||
-- float->integer conversions
|
|
||||||
checkmessage("local a = 2.0^100; x = a << 2", "local a")
|
|
||||||
checkmessage("local a = 1 >> 2.0^100", "has no integer representation")
|
|
||||||
checkmessage("local a = 10.1 << 2.0^100", "has no integer representation")
|
|
||||||
checkmessage("local a = 2.0^100 & 1", "has no integer representation")
|
|
||||||
checkmessage("local a = 2.0^100 & 1e100", "has no integer representation")
|
|
||||||
checkmessage("local a = 2.0 | 1e40", "has no integer representation")
|
|
||||||
checkmessage("local a = 2e100 ~ 1", "has no integer representation")
|
|
||||||
checkmessage("string.sub('a', 2.0^100)", "has no integer representation")
|
|
||||||
checkmessage("string.rep('a', 3.3)", "has no integer representation")
|
|
||||||
checkmessage("return 6e40 & 7", "has no integer representation")
|
|
||||||
checkmessage("return 34 << 7e30", "has no integer representation")
|
|
||||||
checkmessage("return ~-3e40", "has no integer representation")
|
|
||||||
checkmessage("return ~-3.009", "has no integer representation")
|
|
||||||
checkmessage("return 3.009 & 1", "has no integer representation")
|
|
||||||
checkmessage("return 34 >> {}", "table value")
|
|
||||||
checkmessage("aaa = 24 // 0", "divide by zero")
|
|
||||||
checkmessage("aaa = 1 % 0", "'n%0'")
|
|
||||||
|
|
||||||
|
|
||||||
-- type error for an object which is neither in an upvalue nor a register.
|
|
||||||
-- The following code will try to index the value 10 that is stored in
|
|
||||||
-- the metatable, without moving it to a register.
|
|
||||||
checkmessage("local a = setmetatable({}, {__index = 10}).x",
|
|
||||||
"attempt to index a number value")
|
|
||||||
|
|
||||||
|
|
||||||
-- numeric for loops
|
|
||||||
checkmessage("for i = {}, 10 do end", "table")
|
|
||||||
checkmessage("for i = io.stdin, 10 do end", "FILE")
|
|
||||||
checkmessage("for i = {}, 10 do end", "initial value")
|
|
||||||
checkmessage("for i = 1, 'x', 10 do end", "string")
|
|
||||||
checkmessage("for i = 1, {}, 10 do end", "limit")
|
|
||||||
checkmessage("for i = 1, {} do end", "limit")
|
|
||||||
checkmessage("for i = 1, 10, print do end", "step")
|
|
||||||
checkmessage("for i = 1, 10, print do end", "function")
|
|
||||||
|
|
||||||
-- passing light userdata instead of full userdata
|
|
||||||
_G.D = debug
|
|
||||||
checkmessage([[
|
|
||||||
-- create light udata
|
|
||||||
local x = D.upvalueid(function () return debug end, 1)
|
|
||||||
D.setuservalue(x, {})
|
|
||||||
]], "light userdata")
|
|
||||||
_G.D = nil
|
|
||||||
|
|
||||||
do -- named objects (field '__name')
|
|
||||||
checkmessage("math.sin(io.input())", "(number expected, got FILE*)")
|
|
||||||
_G.XX = setmetatable({}, {__name = "My Type"})
|
|
||||||
assert(string.find(tostring(XX), "^My Type"))
|
|
||||||
checkmessage("io.input(XX)", "(FILE* expected, got My Type)")
|
|
||||||
checkmessage("return XX + 1", "on a My Type value")
|
|
||||||
checkmessage("return ~io.stdin", "on a FILE* value")
|
|
||||||
checkmessage("return XX < XX", "two My Type values")
|
|
||||||
checkmessage("return {} < XX", "table with My Type")
|
|
||||||
checkmessage("return XX < io.stdin", "My Type with FILE*")
|
|
||||||
_G.XX = nil
|
|
||||||
|
|
||||||
if T then -- extra tests for 'luaL_tolstring'
|
|
||||||
-- bug in 5.4.3; 'luaL_tolstring' with negative indices
|
|
||||||
local x = setmetatable({}, {__name="TABLE"})
|
|
||||||
assert(T.testC("Ltolstring -1; return 1", x) == tostring(x))
|
|
||||||
|
|
||||||
local a, b = T.testC("pushint 10; Ltolstring -2; return 2", x)
|
|
||||||
assert(a == 10 and b == tostring(x))
|
|
||||||
|
|
||||||
setmetatable(x, {__tostring=function (o)
|
|
||||||
assert(o == x)
|
|
||||||
return "ABC"
|
|
||||||
end})
|
|
||||||
local a, b, c = T.testC("pushint 10; Ltolstring -2; return 3", x)
|
|
||||||
assert(a == x and b == 10 and c == "ABC")
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- global functions
|
|
||||||
checkmessage("(io.write or print){}", "io.write")
|
|
||||||
checkmessage("(collectgarbage or print){}", "collectgarbage")
|
|
||||||
|
|
||||||
-- errors in functions without debug info
|
|
||||||
do
|
|
||||||
local f = function (a) return a + 1 end
|
|
||||||
f = assert(load(string.dump(f, true)))
|
|
||||||
assert(f(3) == 4)
|
|
||||||
checkerr("^%?:%-1:", f, {})
|
|
||||||
|
|
||||||
-- code with a move to a local var ('OP_MOV A B' with A<B)
|
|
||||||
f = function () local a; a = {}; return a + 2 end
|
|
||||||
-- no debug info (so that 'a' is unknown)
|
|
||||||
f = assert(load(string.dump(f, true)))
|
|
||||||
-- symbolic execution should not get lost
|
|
||||||
checkerr("^%?:%-1:.*table value", f)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- tests for field accesses after RK limit
|
|
||||||
local t = {}
|
|
||||||
for i = 1, 1000 do
|
|
||||||
t[i] = "aaa = x" .. i
|
|
||||||
end
|
|
||||||
local s = table.concat(t, "; ")
|
|
||||||
t = nil
|
|
||||||
checkmessage(s.."; aaa = bbb + 1", "global 'bbb'")
|
|
||||||
checkmessage("local _ENV=_ENV;"..s.."; aaa = bbb + 1", "global 'bbb'")
|
|
||||||
checkmessage(s.."; local t = {}; aaa = t.bbb + 1", "field 'bbb'")
|
|
||||||
checkmessage(s.."; local t = {}; t:bbb()", "method 'bbb'")
|
|
||||||
|
|
||||||
checkmessage([[aaa=9
|
|
||||||
repeat until 3==3
|
|
||||||
local x=math.sin(math.cos(3))
|
|
||||||
if math.sin(1) == x then return math.sin(1) end -- tail call
|
|
||||||
local a,b = 1, {
|
|
||||||
{x='a'..'b'..'c', y='b', z=x},
|
|
||||||
{1,2,3,4,5} or 3+3<=3+3,
|
|
||||||
3+1>3+1,
|
|
||||||
{d = x and aaa[x or y]}}
|
|
||||||
]], "global 'aaa'")
|
|
||||||
|
|
||||||
checkmessage([[
|
|
||||||
local x,y = {},1
|
|
||||||
if math.sin(1) == 0 then return 3 end -- return
|
|
||||||
x.a()]], "field 'a'")
|
|
||||||
|
|
||||||
checkmessage([[
|
|
||||||
prefix = nil
|
|
||||||
insert = nil
|
|
||||||
while 1 do
|
|
||||||
local a
|
|
||||||
if nil then break end
|
|
||||||
insert(prefix, a)
|
|
||||||
end]], "global 'insert'")
|
|
||||||
|
|
||||||
checkmessage([[ -- tail call
|
|
||||||
return math.sin("a")
|
|
||||||
]], "sin")
|
|
||||||
|
|
||||||
checkmessage([[collectgarbage("nooption")]], "invalid option")
|
|
||||||
|
|
||||||
checkmessage([[x = print .. "a"]], "concatenate")
|
|
||||||
checkmessage([[x = "a" .. false]], "concatenate")
|
|
||||||
checkmessage([[x = {} .. 2]], "concatenate")
|
|
||||||
|
|
||||||
checkmessage("getmetatable(io.stdin).__gc()", "no value")
|
|
||||||
|
|
||||||
checkmessage([[
|
|
||||||
local Var
|
|
||||||
local function main()
|
|
||||||
NoSuchName (function() Var=0 end)
|
|
||||||
end
|
|
||||||
main()
|
|
||||||
]], "global 'NoSuchName'")
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
aaa = {}; setmetatable(aaa, {__index = string})
|
|
||||||
checkmessage("aaa:sub()", "bad self")
|
|
||||||
checkmessage("string.sub('a', {})", "#2")
|
|
||||||
checkmessage("('a'):sub{}", "#1")
|
|
||||||
|
|
||||||
checkmessage("table.sort({1,2,3}, table.sort)", "'table.sort'")
|
|
||||||
checkmessage("string.gsub('s', 's', setmetatable)", "'setmetatable'")
|
|
||||||
|
|
||||||
_G.aaa = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- tests for errors in coroutines
|
|
||||||
|
|
||||||
local function f (n)
|
|
||||||
local c = coroutine.create(f)
|
|
||||||
local a,b = coroutine.resume(c)
|
|
||||||
return b
|
|
||||||
end
|
|
||||||
assert(string.find(f(), "C stack overflow"))
|
|
||||||
|
|
||||||
checkmessage("coroutine.yield()", "outside a coroutine")
|
|
||||||
|
|
||||||
f = coroutine.wrap(function () table.sort({1,2,3}, coroutine.yield) end)
|
|
||||||
checkerr("yield across", f)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing size of 'source' info; size of buffer for that info is
|
|
||||||
-- LUA_IDSIZE, declared as 60 in luaconf. Get one position for '\0'.
|
|
||||||
local idsize = 60 - 1
|
|
||||||
local function checksize (source)
|
|
||||||
-- syntax error
|
|
||||||
local _, msg = load("x", source)
|
|
||||||
msg = string.match(msg, "^([^:]*):") -- get source (1st part before ':')
|
|
||||||
assert(msg:len() <= idsize)
|
|
||||||
end
|
|
||||||
|
|
||||||
for i = 60 - 10, 60 + 10 do -- check border cases around 60
|
|
||||||
checksize("@" .. string.rep("x", i)) -- file names
|
|
||||||
checksize(string.rep("x", i - 10)) -- string sources
|
|
||||||
checksize("=" .. string.rep("x", i)) -- exact sources
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing line error
|
|
||||||
|
|
||||||
local function lineerror (s, l)
|
|
||||||
local err,msg = pcall(load(s))
|
|
||||||
local line = tonumber(string.match(msg, ":(%d+):"))
|
|
||||||
assert(line == l or (not line and not l))
|
|
||||||
end
|
|
||||||
|
|
||||||
lineerror("local a\n for i=1,'a' do \n print(i) \n end", 2)
|
|
||||||
lineerror("\n local a \n for k,v in 3 \n do \n print(k) \n end", 3)
|
|
||||||
lineerror("\n\n for k,v in \n 3 \n do \n print(k) \n end", 4)
|
|
||||||
lineerror("function a.x.y ()\na=a+1\nend", 1)
|
|
||||||
|
|
||||||
lineerror("a = \na\n+\n{}", 3)
|
|
||||||
lineerror("a = \n3\n+\n(\n4\n/\nprint)", 6)
|
|
||||||
lineerror("a = \nprint\n+\n(\n4\n/\n7)", 3)
|
|
||||||
|
|
||||||
lineerror("a\n=\n-\n\nprint\n;", 3)
|
|
||||||
|
|
||||||
lineerror([[
|
|
||||||
a
|
|
||||||
(
|
|
||||||
23)
|
|
||||||
]], 1)
|
|
||||||
|
|
||||||
lineerror([[
|
|
||||||
local a = {x = 13}
|
|
||||||
a
|
|
||||||
.
|
|
||||||
x
|
|
||||||
(
|
|
||||||
23
|
|
||||||
)
|
|
||||||
]], 2)
|
|
||||||
|
|
||||||
lineerror([[
|
|
||||||
local a = {x = 13}
|
|
||||||
a
|
|
||||||
.
|
|
||||||
x
|
|
||||||
(
|
|
||||||
23 + a
|
|
||||||
)
|
|
||||||
]], 6)
|
|
||||||
|
|
||||||
local p = [[
|
|
||||||
function g() f() end
|
|
||||||
function f(x) error('a', XX) end
|
|
||||||
g()
|
|
||||||
]]
|
|
||||||
XX=3;lineerror((p), 3)
|
|
||||||
XX=0;lineerror((p), false)
|
|
||||||
XX=1;lineerror((p), 2)
|
|
||||||
XX=2;lineerror((p), 1)
|
|
||||||
_G.XX, _G.g, _G.f = nil
|
|
||||||
|
|
||||||
|
|
||||||
lineerror([[
|
|
||||||
local b = false
|
|
||||||
if not b then
|
|
||||||
error 'test'
|
|
||||||
end]], 3)
|
|
||||||
|
|
||||||
lineerror([[
|
|
||||||
local b = false
|
|
||||||
if not b then
|
|
||||||
if not b then
|
|
||||||
if not b then
|
|
||||||
error 'test'
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end]], 5)
|
|
||||||
|
|
||||||
|
|
||||||
-- bug in 5.4.0
|
|
||||||
lineerror([[
|
|
||||||
local a = 0
|
|
||||||
local b = 1
|
|
||||||
local c = b % a
|
|
||||||
]], 3)
|
|
||||||
|
|
||||||
do
|
|
||||||
-- Force a negative estimate for base line. Error in instruction 2
|
|
||||||
-- (after VARARGPREP, GETGLOBAL), with first absolute line information
|
|
||||||
-- (forced by too many lines) in instruction 0.
|
|
||||||
local s = string.format("%s return __A.x", string.rep("\n", 300))
|
|
||||||
lineerror(s, 301)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not _soft then
|
|
||||||
-- several tests that exaust the Lua stack
|
|
||||||
collectgarbage()
|
|
||||||
print"testing stack overflow"
|
|
||||||
local C = 0
|
|
||||||
-- get line where stack overflow will happen
|
|
||||||
local l = debug.getinfo(1, "l").currentline + 1
|
|
||||||
local function auxy () C=C+1; auxy() end -- produce a stack overflow
|
|
||||||
function YY ()
|
|
||||||
collectgarbage("stop") -- avoid running finalizers without stack space
|
|
||||||
auxy()
|
|
||||||
collectgarbage("restart")
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checkstackmessage (m)
|
|
||||||
print("(expected stack overflow after " .. C .. " calls)")
|
|
||||||
C = 0 -- prepare next count
|
|
||||||
return (string.find(m, "stack overflow"))
|
|
||||||
end
|
|
||||||
-- repeated stack overflows (to check stack recovery)
|
|
||||||
assert(checkstackmessage(doit('YY()')))
|
|
||||||
assert(checkstackmessage(doit('YY()')))
|
|
||||||
assert(checkstackmessage(doit('YY()')))
|
|
||||||
|
|
||||||
_G.YY = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- error lines in stack overflow
|
|
||||||
local l1
|
|
||||||
local function g(x)
|
|
||||||
l1 = debug.getinfo(x, "l").currentline + 2
|
|
||||||
collectgarbage("stop") -- avoid running finalizers without stack space
|
|
||||||
auxy()
|
|
||||||
collectgarbage("restart")
|
|
||||||
end
|
|
||||||
local _, stackmsg = xpcall(g, debug.traceback, 1)
|
|
||||||
print('+')
|
|
||||||
local stack = {}
|
|
||||||
for line in string.gmatch(stackmsg, "[^\n]*") do
|
|
||||||
local curr = string.match(line, ":(%d+):")
|
|
||||||
if curr then table.insert(stack, tonumber(curr)) end
|
|
||||||
end
|
|
||||||
local i=1
|
|
||||||
while stack[i] ~= l1 do
|
|
||||||
assert(stack[i] == l)
|
|
||||||
i = i+1
|
|
||||||
end
|
|
||||||
assert(i > 15)
|
|
||||||
|
|
||||||
|
|
||||||
-- error in error handling
|
|
||||||
local res, msg = xpcall(error, error)
|
|
||||||
assert(not res and type(msg) == 'string')
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local function f (x)
|
|
||||||
if x==0 then error('a\n')
|
|
||||||
else
|
|
||||||
local aux = function () return f(x-1) end
|
|
||||||
local a,b = xpcall(aux, aux)
|
|
||||||
return a,b
|
|
||||||
end
|
|
||||||
end
|
|
||||||
f(3)
|
|
||||||
|
|
||||||
local function loop (x,y,z) return 1 + loop(x, y, z) end
|
|
||||||
|
|
||||||
local res, msg = xpcall(loop, function (m)
|
|
||||||
assert(string.find(m, "stack overflow"))
|
|
||||||
checkerr("error handling", loop)
|
|
||||||
assert(math.sin(0) == 0)
|
|
||||||
return 15
|
|
||||||
end)
|
|
||||||
assert(msg == 15)
|
|
||||||
|
|
||||||
local f = function ()
|
|
||||||
for i = 999900, 1000000, 1 do table.unpack({}, 1, i) end
|
|
||||||
end
|
|
||||||
checkerr("too many results", f)
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
-- non string messages
|
|
||||||
local t = {}
|
|
||||||
local res, msg = pcall(function () error(t) end)
|
|
||||||
assert(not res and msg == t)
|
|
||||||
|
|
||||||
res, msg = pcall(function () error(nil) end)
|
|
||||||
assert(not res and msg == nil)
|
|
||||||
|
|
||||||
local function f() error{msg='x'} end
|
|
||||||
res, msg = xpcall(f, function (r) return {msg=r.msg..'y'} end)
|
|
||||||
assert(msg.msg == 'xy')
|
|
||||||
|
|
||||||
-- 'assert' with extra arguments
|
|
||||||
res, msg = pcall(assert, false, "X", t)
|
|
||||||
assert(not res and msg == "X")
|
|
||||||
|
|
||||||
-- 'assert' with no message
|
|
||||||
res, msg = pcall(function () assert(false) end)
|
|
||||||
local line = string.match(msg, "%w+%.lua:(%d+): assertion failed!$")
|
|
||||||
assert(tonumber(line) == debug.getinfo(1, "l").currentline - 2)
|
|
||||||
|
|
||||||
-- 'assert' with non-string messages
|
|
||||||
res, msg = pcall(assert, false, t)
|
|
||||||
assert(not res and msg == t)
|
|
||||||
|
|
||||||
res, msg = pcall(assert, nil, nil)
|
|
||||||
assert(not res and msg == nil)
|
|
||||||
|
|
||||||
-- 'assert' without arguments
|
|
||||||
res, msg = pcall(assert)
|
|
||||||
assert(not res and string.find(msg, "value expected"))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- xpcall with arguments
|
|
||||||
local a, b, c = xpcall(string.find, error, "alo", "al")
|
|
||||||
assert(a and b == 1 and c == 2)
|
|
||||||
a, b, c = xpcall(string.find, function (x) return {} end, true, "al")
|
|
||||||
assert(not a and type(b) == "table" and c == nil)
|
|
||||||
|
|
||||||
|
|
||||||
print("testing tokens in error messages")
|
|
||||||
checksyntax("syntax error", "", "error", 1)
|
|
||||||
checksyntax("1.000", "", "1.000", 1)
|
|
||||||
checksyntax("[[a]]", "", "[[a]]", 1)
|
|
||||||
checksyntax("'aa'", "", "'aa'", 1)
|
|
||||||
checksyntax("while << do end", "", "<<", 1)
|
|
||||||
checksyntax("for >> do end", "", ">>", 1)
|
|
||||||
|
|
||||||
-- test invalid non-printable char in a chunk
|
|
||||||
checksyntax("a\1a = 1", "", "<\\1>", 1)
|
|
||||||
|
|
||||||
-- test 255 as first char in a chunk
|
|
||||||
checksyntax("\255a = 1", "", "<\\255>", 1)
|
|
||||||
|
|
||||||
doit('I = load("a=9+"); aaa=3')
|
|
||||||
assert(_G.aaa==3 and not _G.I)
|
|
||||||
_G.I,_G.aaa = nil
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local lim = 1000
|
|
||||||
if _soft then lim = 100 end
|
|
||||||
for i=1,lim do
|
|
||||||
doit('a = ')
|
|
||||||
doit('a = 4+nil')
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing syntax limits
|
|
||||||
|
|
||||||
local function testrep (init, rep, close, repc, finalresult)
|
|
||||||
local s = init .. string.rep(rep, 100) .. close .. string.rep(repc, 100)
|
|
||||||
local res, msg = load(s)
|
|
||||||
assert(res) -- 100 levels is OK
|
|
||||||
if (finalresult) then
|
|
||||||
assert(res() == finalresult)
|
|
||||||
end
|
|
||||||
s = init .. string.rep(rep, 500)
|
|
||||||
local res, msg = load(s) -- 500 levels not ok
|
|
||||||
assert(not res and (string.find(msg, "too many") or
|
|
||||||
string.find(msg, "overflow")))
|
|
||||||
end
|
|
||||||
|
|
||||||
testrep("local a; a", ",a", "= 1", ",1") -- multiple assignment
|
|
||||||
testrep("local a; a=", "{", "0", "}")
|
|
||||||
testrep("return ", "(", "2", ")", 2)
|
|
||||||
testrep("local function a (x) return x end; return ", "a(", "2.2", ")", 2.2)
|
|
||||||
testrep("", "do ", "", " end")
|
|
||||||
testrep("", "while a do ", "", " end")
|
|
||||||
testrep("local a; ", "if a then else ", "", " end")
|
|
||||||
testrep("", "function foo () ", "", " end")
|
|
||||||
testrep("local a = ''; return ", "a..", "'a'", "", "a")
|
|
||||||
testrep("local a = 1; return ", "a^", "a", "", 1)
|
|
||||||
|
|
||||||
checkmessage("a = f(x" .. string.rep(",x", 260) .. ")", "too many registers")
|
|
||||||
|
|
||||||
|
|
||||||
-- testing other limits
|
|
||||||
|
|
||||||
-- upvalues
|
|
||||||
local lim = 127
|
|
||||||
local s = "local function fooA ()\n local "
|
|
||||||
for j = 1,lim do
|
|
||||||
s = s.."a"..j..", "
|
|
||||||
end
|
|
||||||
s = s.."b,c\n"
|
|
||||||
s = s.."local function fooB ()\n local "
|
|
||||||
for j = 1,lim do
|
|
||||||
s = s.."b"..j..", "
|
|
||||||
end
|
|
||||||
s = s.."b\n"
|
|
||||||
s = s.."function fooC () return b+c"
|
|
||||||
local c = 1+2
|
|
||||||
for j = 1,lim do
|
|
||||||
s = s.."+a"..j.."+b"..j
|
|
||||||
c = c + 2
|
|
||||||
end
|
|
||||||
s = s.."\nend end end"
|
|
||||||
local a,b = load(s)
|
|
||||||
assert(c > 255 and string.find(b, "too many upvalues") and
|
|
||||||
string.find(b, "line 5"))
|
|
||||||
|
|
||||||
-- local variables
|
|
||||||
s = "\nfunction foo ()\n local "
|
|
||||||
for j = 1,300 do
|
|
||||||
s = s.."a"..j..", "
|
|
||||||
end
|
|
||||||
s = s.."b\n"
|
|
||||||
local a,b = load(s)
|
|
||||||
assert(string.find(b, "line 2") and string.find(b, "too many local variables"))
|
|
||||||
|
|
||||||
mt.__index = oldmm
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
@ -1,491 +0,0 @@
|
|||||||
-- $Id: testes/events.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing metatables')
|
|
||||||
|
|
||||||
local debug = require'debug'
|
|
||||||
|
|
||||||
X = 20; B = 30
|
|
||||||
|
|
||||||
_ENV = setmetatable({}, {__index=_G})
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
X = X+10
|
|
||||||
assert(X == 30 and _G.X == 20)
|
|
||||||
B = false
|
|
||||||
assert(B == false)
|
|
||||||
_ENV["B"] = undef
|
|
||||||
assert(B == 30)
|
|
||||||
|
|
||||||
assert(getmetatable{} == nil)
|
|
||||||
assert(getmetatable(4) == nil)
|
|
||||||
assert(getmetatable(nil) == nil)
|
|
||||||
a={name = "NAME"}; setmetatable(a, {__metatable = "xuxu",
|
|
||||||
__tostring=function(x) return x.name end})
|
|
||||||
assert(getmetatable(a) == "xuxu")
|
|
||||||
assert(tostring(a) == "NAME")
|
|
||||||
-- cannot change a protected metatable
|
|
||||||
assert(pcall(setmetatable, a, {}) == false)
|
|
||||||
a.name = "gororoba"
|
|
||||||
assert(tostring(a) == "gororoba")
|
|
||||||
|
|
||||||
local a, t = {10,20,30; x="10", y="20"}, {}
|
|
||||||
assert(setmetatable(a,t) == a)
|
|
||||||
assert(getmetatable(a) == t)
|
|
||||||
assert(setmetatable(a,nil) == a)
|
|
||||||
assert(getmetatable(a) == nil)
|
|
||||||
assert(setmetatable(a,t) == a)
|
|
||||||
|
|
||||||
|
|
||||||
function f (t, i, e)
|
|
||||||
assert(not e)
|
|
||||||
local p = rawget(t, "parent")
|
|
||||||
return (p and p[i]+3), "dummy return"
|
|
||||||
end
|
|
||||||
|
|
||||||
t.__index = f
|
|
||||||
|
|
||||||
a.parent = {z=25, x=12, [4] = 24}
|
|
||||||
assert(a[1] == 10 and a.z == 28 and a[4] == 27 and a.x == "10")
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
a = setmetatable({}, t)
|
|
||||||
function f(t, i, v) rawset(t, i, v-3) end
|
|
||||||
setmetatable(t, t) -- causes a bug in 5.1 !
|
|
||||||
t.__newindex = f
|
|
||||||
a[1] = 30; a.x = "101"; a[5] = 200
|
|
||||||
assert(a[1] == 27 and a.x == 98 and a[5] == 197)
|
|
||||||
|
|
||||||
do -- bug in Lua 5.3.2
|
|
||||||
local mt = {}
|
|
||||||
mt.__newindex = mt
|
|
||||||
local t = setmetatable({}, mt)
|
|
||||||
t[1] = 10 -- will segfault on some machines
|
|
||||||
assert(mt[1] == 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local c = {}
|
|
||||||
a = setmetatable({}, t)
|
|
||||||
t.__newindex = c
|
|
||||||
t.__index = c
|
|
||||||
a[1] = 10; a[2] = 20; a[3] = 90;
|
|
||||||
for i = 4, 20 do a[i] = i * 10 end
|
|
||||||
assert(a[1] == 10 and a[2] == 20 and a[3] == 90)
|
|
||||||
for i = 4, 20 do assert(a[i] == i * 10) end
|
|
||||||
assert(next(a) == nil)
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
local a;
|
|
||||||
a = setmetatable({}, {__index = setmetatable({},
|
|
||||||
{__index = setmetatable({},
|
|
||||||
{__index = function (_,n) return a[n-3]+4, "lixo" end})})})
|
|
||||||
a[0] = 20
|
|
||||||
for i=0,10 do
|
|
||||||
assert(a[i*3] == 20 + i*4)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- newindex
|
|
||||||
local foi
|
|
||||||
local a = {}
|
|
||||||
for i=1,10 do a[i] = 0; a['a'..i] = 0; end
|
|
||||||
setmetatable(a, {__newindex = function (t,k,v) foi=true; rawset(t,k,v) end})
|
|
||||||
foi = false; a[1]=0; assert(not foi)
|
|
||||||
foi = false; a['a1']=0; assert(not foi)
|
|
||||||
foi = false; a['a11']=0; assert(foi)
|
|
||||||
foi = false; a[11]=0; assert(foi)
|
|
||||||
foi = false; a[1]=undef; assert(not foi)
|
|
||||||
a[1] = undef
|
|
||||||
foi = false; a[1]=nil; assert(foi)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
setmetatable(t, nil)
|
|
||||||
function f (t, ...) return t, {...} end
|
|
||||||
t.__call = f
|
|
||||||
|
|
||||||
do
|
|
||||||
local x,y = a(table.unpack{'a', 1})
|
|
||||||
assert(x==a and y[1]=='a' and y[2]==1 and y[3]==undef)
|
|
||||||
x,y = a()
|
|
||||||
assert(x==a and y[1]==undef)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local b = setmetatable({}, t)
|
|
||||||
setmetatable(b,t)
|
|
||||||
|
|
||||||
function f(op)
|
|
||||||
return function (...) cap = {[0] = op, ...} ; return (...) end
|
|
||||||
end
|
|
||||||
t.__add = f("add")
|
|
||||||
t.__sub = f("sub")
|
|
||||||
t.__mul = f("mul")
|
|
||||||
t.__div = f("div")
|
|
||||||
t.__idiv = f("idiv")
|
|
||||||
t.__mod = f("mod")
|
|
||||||
t.__unm = f("unm")
|
|
||||||
t.__pow = f("pow")
|
|
||||||
t.__len = f("len")
|
|
||||||
t.__band = f("band")
|
|
||||||
t.__bor = f("bor")
|
|
||||||
t.__bxor = f("bxor")
|
|
||||||
t.__shl = f("shl")
|
|
||||||
t.__shr = f("shr")
|
|
||||||
t.__bnot = f("bnot")
|
|
||||||
t.__lt = f("lt")
|
|
||||||
t.__le = f("le")
|
|
||||||
|
|
||||||
|
|
||||||
local function checkcap (t)
|
|
||||||
assert(#cap + 1 == #t)
|
|
||||||
for i = 1, #t do
|
|
||||||
assert(cap[i - 1] == t[i])
|
|
||||||
assert(math.type(cap[i - 1]) == math.type(t[i]))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Some tests are done inside small anonymous functions to ensure
|
|
||||||
-- that constants go to constant table even in debug compilation,
|
|
||||||
-- when the constant table is very small.
|
|
||||||
assert(b+5 == b); checkcap{"add", b, 5}
|
|
||||||
assert(5.2 + b == 5.2); checkcap{"add", 5.2, b}
|
|
||||||
assert(b+'5' == b); checkcap{"add", b, '5'}
|
|
||||||
assert(5+b == 5); checkcap{"add", 5, b}
|
|
||||||
assert('5'+b == '5'); checkcap{"add", '5', b}
|
|
||||||
b=b-3; assert(getmetatable(b) == t); checkcap{"sub", b, 3}
|
|
||||||
assert(5-a == 5); checkcap{"sub", 5, a}
|
|
||||||
assert('5'-a == '5'); checkcap{"sub", '5', a}
|
|
||||||
assert(a*a == a); checkcap{"mul", a, a}
|
|
||||||
assert(a/0 == a); checkcap{"div", a, 0}
|
|
||||||
assert(a/0.0 == a); checkcap{"div", a, 0.0}
|
|
||||||
assert(a%2 == a); checkcap{"mod", a, 2}
|
|
||||||
assert(a // (1/0) == a); checkcap{"idiv", a, 1/0}
|
|
||||||
;(function () assert(a & "hi" == a) end)(); checkcap{"band", a, "hi"}
|
|
||||||
;(function () assert(10 & a == 10) end)(); checkcap{"band", 10, a}
|
|
||||||
;(function () assert(a | 10 == a) end)(); checkcap{"bor", a, 10}
|
|
||||||
assert(a | "hi" == a); checkcap{"bor", a, "hi"}
|
|
||||||
assert("hi" ~ a == "hi"); checkcap{"bxor", "hi", a}
|
|
||||||
;(function () assert(10 ~ a == 10) end)(); checkcap{"bxor", 10, a}
|
|
||||||
assert(-a == a); checkcap{"unm", a, a}
|
|
||||||
assert(a^4.0 == a); checkcap{"pow", a, 4.0}
|
|
||||||
assert(a^'4' == a); checkcap{"pow", a, '4'}
|
|
||||||
assert(4^a == 4); checkcap{"pow", 4, a}
|
|
||||||
assert('4'^a == '4'); checkcap{"pow", '4', a}
|
|
||||||
assert(#a == a); checkcap{"len", a, a}
|
|
||||||
assert(~a == a); checkcap{"bnot", a, a}
|
|
||||||
assert(a << 3 == a); checkcap{"shl", a, 3}
|
|
||||||
assert(1.5 >> a == 1.5); checkcap{"shr", 1.5, a}
|
|
||||||
|
|
||||||
-- for comparison operators, all results are true
|
|
||||||
assert(5.0 > a); checkcap{"lt", a, 5.0}
|
|
||||||
assert(a >= 10); checkcap{"le", 10, a}
|
|
||||||
assert(a <= -10.0); checkcap{"le", a, -10.0}
|
|
||||||
assert(a < -10); checkcap{"lt", a, -10}
|
|
||||||
|
|
||||||
|
|
||||||
-- test for rawlen
|
|
||||||
t = setmetatable({1,2,3}, {__len = function () return 10 end})
|
|
||||||
assert(#t == 10 and rawlen(t) == 3)
|
|
||||||
assert(rawlen"abc" == 3)
|
|
||||||
assert(not pcall(rawlen, io.stdin))
|
|
||||||
assert(not pcall(rawlen, 34))
|
|
||||||
assert(not pcall(rawlen))
|
|
||||||
|
|
||||||
-- rawlen for long strings
|
|
||||||
assert(rawlen(string.rep('a', 1000)) == 1000)
|
|
||||||
|
|
||||||
|
|
||||||
t = {}
|
|
||||||
t.__lt = function (a,b,c)
|
|
||||||
collectgarbage()
|
|
||||||
assert(c == nil)
|
|
||||||
if type(a) == 'table' then a = a.x end
|
|
||||||
if type(b) == 'table' then b = b.x end
|
|
||||||
return a<b, "dummy"
|
|
||||||
end
|
|
||||||
|
|
||||||
t.__le = function (a,b,c)
|
|
||||||
assert(c == nil)
|
|
||||||
if type(a) == 'table' then a = a.x end
|
|
||||||
if type(b) == 'table' then b = b.x end
|
|
||||||
return a<=b, "dummy"
|
|
||||||
end
|
|
||||||
|
|
||||||
t.__eq = function (a,b,c)
|
|
||||||
assert(c == nil)
|
|
||||||
if type(a) == 'table' then a = a.x end
|
|
||||||
if type(b) == 'table' then b = b.x end
|
|
||||||
return a == b, "dummy"
|
|
||||||
end
|
|
||||||
|
|
||||||
function Op(x) return setmetatable({x=x}, t) end
|
|
||||||
|
|
||||||
local function test (a, b, c)
|
|
||||||
assert(not(Op(1)<Op(1)) and (Op(1)<Op(2)) and not(Op(2)<Op(1)))
|
|
||||||
assert(not(1 < Op(1)) and (Op(1) < 2) and not(2 < Op(1)))
|
|
||||||
assert(not(Op('a')<Op('a')) and (Op('a')<Op('b')) and not(Op('b')<Op('a')))
|
|
||||||
assert(not('a' < Op('a')) and (Op('a') < 'b') and not(Op('b') < Op('a')))
|
|
||||||
assert((Op(1)<=Op(1)) and (Op(1)<=Op(2)) and not(Op(2)<=Op(1)))
|
|
||||||
assert((Op('a')<=Op('a')) and (Op('a')<=Op('b')) and not(Op('b')<=Op('a')))
|
|
||||||
assert(not(Op(1)>Op(1)) and not(Op(1)>Op(2)) and (Op(2)>Op(1)))
|
|
||||||
assert(not(Op('a')>Op('a')) and not(Op('a')>Op('b')) and (Op('b')>Op('a')))
|
|
||||||
assert((Op(1)>=Op(1)) and not(Op(1)>=Op(2)) and (Op(2)>=Op(1)))
|
|
||||||
assert((1 >= Op(1)) and not(1 >= Op(2)) and (Op(2) >= 1))
|
|
||||||
assert((Op('a')>=Op('a')) and not(Op('a')>=Op('b')) and (Op('b')>=Op('a')))
|
|
||||||
assert(('a' >= Op('a')) and not(Op('a') >= 'b') and (Op('b') >= Op('a')))
|
|
||||||
assert(Op(1) == Op(1) and Op(1) ~= Op(2))
|
|
||||||
assert(Op('a') == Op('a') and Op('a') ~= Op('b'))
|
|
||||||
assert(a == a and a ~= b)
|
|
||||||
assert(Op(3) == c)
|
|
||||||
end
|
|
||||||
|
|
||||||
test(Op(1), Op(2), Op(3))
|
|
||||||
|
|
||||||
|
|
||||||
-- test `partial order'
|
|
||||||
|
|
||||||
local function rawSet(x)
|
|
||||||
local y = {}
|
|
||||||
for _,k in pairs(x) do y[k] = 1 end
|
|
||||||
return y
|
|
||||||
end
|
|
||||||
|
|
||||||
local function Set(x)
|
|
||||||
return setmetatable(rawSet(x), t)
|
|
||||||
end
|
|
||||||
|
|
||||||
t.__lt = function (a,b)
|
|
||||||
for k in pairs(a) do
|
|
||||||
if not b[k] then return false end
|
|
||||||
b[k] = undef
|
|
||||||
end
|
|
||||||
return next(b) ~= nil
|
|
||||||
end
|
|
||||||
|
|
||||||
t.__le = function (a,b)
|
|
||||||
for k in pairs(a) do
|
|
||||||
if not b[k] then return false end
|
|
||||||
end
|
|
||||||
return true
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(Set{1,2,3} < Set{1,2,3,4})
|
|
||||||
assert(not(Set{1,2,3,4} < Set{1,2,3,4}))
|
|
||||||
assert((Set{1,2,3,4} <= Set{1,2,3,4}))
|
|
||||||
assert((Set{1,2,3,4} >= Set{1,2,3,4}))
|
|
||||||
assert(not (Set{1,3} <= Set{3,5}))
|
|
||||||
assert(not(Set{1,3} <= Set{3,5}))
|
|
||||||
assert(not(Set{1,3} >= Set{3,5}))
|
|
||||||
|
|
||||||
|
|
||||||
t.__eq = function (a,b)
|
|
||||||
for k in pairs(a) do
|
|
||||||
if not b[k] then return false end
|
|
||||||
b[k] = undef
|
|
||||||
end
|
|
||||||
return next(b) == nil
|
|
||||||
end
|
|
||||||
|
|
||||||
local s = Set{1,3,5}
|
|
||||||
assert(s == Set{3,5,1})
|
|
||||||
assert(not rawequal(s, Set{3,5,1}))
|
|
||||||
assert(rawequal(s, s))
|
|
||||||
assert(Set{1,3,5,1} == rawSet{3,5,1})
|
|
||||||
assert(rawSet{1,3,5,1} == Set{3,5,1})
|
|
||||||
assert(Set{1,3,5} ~= Set{3,5,1,6})
|
|
||||||
|
|
||||||
-- '__eq' is not used for table accesses
|
|
||||||
t[Set{1,3,5}] = 1
|
|
||||||
assert(t[Set{1,3,5}] == undef)
|
|
||||||
|
|
||||||
|
|
||||||
do -- test invalidating flags
|
|
||||||
local mt = {__eq = true}
|
|
||||||
local a = setmetatable({10}, mt)
|
|
||||||
local b = setmetatable({10}, mt)
|
|
||||||
mt.__eq = nil
|
|
||||||
assert(a ~= b) -- no metamethod
|
|
||||||
mt.__eq = function (x,y) return x[1] == y[1] end
|
|
||||||
assert(a == b) -- must use metamethod now
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not T then
|
|
||||||
(Message or print)('\n >>> testC not active: skipping tests for \z
|
|
||||||
userdata <<<\n')
|
|
||||||
else
|
|
||||||
local u1 = T.newuserdata(0, 1)
|
|
||||||
local u2 = T.newuserdata(0, 1)
|
|
||||||
local u3 = T.newuserdata(0, 1)
|
|
||||||
assert(u1 ~= u2 and u1 ~= u3)
|
|
||||||
debug.setuservalue(u1, 1);
|
|
||||||
debug.setuservalue(u2, 2);
|
|
||||||
debug.setuservalue(u3, 1);
|
|
||||||
debug.setmetatable(u1, {__eq = function (a, b)
|
|
||||||
return debug.getuservalue(a) == debug.getuservalue(b)
|
|
||||||
end})
|
|
||||||
debug.setmetatable(u2, {__eq = function (a, b)
|
|
||||||
return true
|
|
||||||
end})
|
|
||||||
assert(u1 == u3 and u3 == u1 and u1 ~= u2)
|
|
||||||
assert(u2 == u1 and u2 == u3 and u3 == u2)
|
|
||||||
assert(u2 ~= {}) -- different types cannot be equal
|
|
||||||
assert(rawequal(u1, u1) and not rawequal(u1, u3))
|
|
||||||
|
|
||||||
local mirror = {}
|
|
||||||
debug.setmetatable(u3, {__index = mirror, __newindex = mirror})
|
|
||||||
for i = 1, 10 do u3[i] = i end
|
|
||||||
for i = 1, 10 do assert(u3[i] == i) end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
t.__concat = function (a,b,c)
|
|
||||||
assert(c == nil)
|
|
||||||
if type(a) == 'table' then a = a.val end
|
|
||||||
if type(b) == 'table' then b = b.val end
|
|
||||||
if A then return a..b
|
|
||||||
else
|
|
||||||
return setmetatable({val=a..b}, t)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
c = {val="c"}; setmetatable(c, t)
|
|
||||||
d = {val="d"}; setmetatable(d, t)
|
|
||||||
|
|
||||||
A = true
|
|
||||||
assert(c..d == 'cd')
|
|
||||||
assert(0 .."a".."b"..c..d.."e".."f"..(5+3).."g" == "0abcdef8g")
|
|
||||||
|
|
||||||
A = false
|
|
||||||
assert((c..d..c..d).val == 'cdcd')
|
|
||||||
x = c..d
|
|
||||||
assert(getmetatable(x) == t and x.val == 'cd')
|
|
||||||
x = 0 .."a".."b"..c..d.."e".."f".."g"
|
|
||||||
assert(x.val == "0abcdefg")
|
|
||||||
|
|
||||||
|
|
||||||
-- concat metamethod x numbers (bug in 5.1.1)
|
|
||||||
c = {}
|
|
||||||
local x
|
|
||||||
setmetatable(c, {__concat = function (a,b)
|
|
||||||
assert(type(a) == "number" and b == c or type(b) == "number" and a == c)
|
|
||||||
return c
|
|
||||||
end})
|
|
||||||
assert(c..5 == c and 5 .. c == c)
|
|
||||||
assert(4 .. c .. 5 == c and 4 .. 5 .. 6 .. 7 .. c == c)
|
|
||||||
|
|
||||||
|
|
||||||
-- test comparison compatibilities
|
|
||||||
local t1, t2, c, d
|
|
||||||
t1 = {}; c = {}; setmetatable(c, t1)
|
|
||||||
d = {}
|
|
||||||
t1.__eq = function () return true end
|
|
||||||
t1.__lt = function () return true end
|
|
||||||
t1.__le = function () return false end
|
|
||||||
setmetatable(d, t1)
|
|
||||||
assert(c == d and c < d and not(d <= c))
|
|
||||||
t2 = {}
|
|
||||||
t2.__eq = t1.__eq
|
|
||||||
t2.__lt = t1.__lt
|
|
||||||
setmetatable(d, t2)
|
|
||||||
assert(c == d and c < d and not(d <= c))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
-- test for several levels of calls
|
|
||||||
local i
|
|
||||||
local tt = {
|
|
||||||
__call = function (t, ...)
|
|
||||||
i = i+1
|
|
||||||
if t.f then return t.f(...)
|
|
||||||
else return {...}
|
|
||||||
end
|
|
||||||
end
|
|
||||||
}
|
|
||||||
|
|
||||||
local a = setmetatable({}, tt)
|
|
||||||
local b = setmetatable({f=a}, tt)
|
|
||||||
local c = setmetatable({f=b}, tt)
|
|
||||||
|
|
||||||
i = 0
|
|
||||||
x = c(3,4,5)
|
|
||||||
assert(i == 3 and x[1] == 3 and x[3] == 5)
|
|
||||||
|
|
||||||
|
|
||||||
assert(_G.X == 20)
|
|
||||||
|
|
||||||
_G.X, _G.B = nil
|
|
||||||
|
|
||||||
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
local _g = _G
|
|
||||||
_ENV = setmetatable({}, {__index=function (_,k) return _g[k] end})
|
|
||||||
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
rawset(a, "x", 1, 2, 3)
|
|
||||||
assert(a.x == 1 and rawget(a, "x", 3) == 1)
|
|
||||||
|
|
||||||
print '+'
|
|
||||||
|
|
||||||
-- testing metatables for basic types
|
|
||||||
mt = {__index = function (a,b) return a+b end,
|
|
||||||
__len = function (x) return math.floor(x) end}
|
|
||||||
debug.setmetatable(10, mt)
|
|
||||||
assert(getmetatable(-2) == mt)
|
|
||||||
assert((10)[3] == 13)
|
|
||||||
assert((10)["3"] == 13)
|
|
||||||
assert(#3.45 == 3)
|
|
||||||
debug.setmetatable(23, nil)
|
|
||||||
assert(getmetatable(-2) == nil)
|
|
||||||
|
|
||||||
debug.setmetatable(true, mt)
|
|
||||||
assert(getmetatable(false) == mt)
|
|
||||||
mt.__index = function (a,b) return a or b end
|
|
||||||
assert((true)[false] == true)
|
|
||||||
assert((false)[false] == false)
|
|
||||||
debug.setmetatable(false, nil)
|
|
||||||
assert(getmetatable(true) == nil)
|
|
||||||
|
|
||||||
debug.setmetatable(nil, mt)
|
|
||||||
assert(getmetatable(nil) == mt)
|
|
||||||
mt.__add = function (a,b) return (a or 1) + (b or 2) end
|
|
||||||
assert(10 + nil == 12)
|
|
||||||
assert(nil + 23 == 24)
|
|
||||||
assert(nil + nil == 3)
|
|
||||||
debug.setmetatable(nil, nil)
|
|
||||||
assert(getmetatable(nil) == nil)
|
|
||||||
|
|
||||||
debug.setmetatable(nil, {})
|
|
||||||
|
|
||||||
|
|
||||||
-- loops in delegation
|
|
||||||
a = {}; setmetatable(a, a); a.__index = a; a.__newindex = a
|
|
||||||
assert(not pcall(function (a,b) return a[b] end, a, 10))
|
|
||||||
assert(not pcall(function (a,b,c) a[b] = c end, a, 10, true))
|
|
||||||
|
|
||||||
-- bug in 5.1
|
|
||||||
T, K, V = nil
|
|
||||||
grandparent = {}
|
|
||||||
grandparent.__newindex = function(t,k,v) T=t; K=k; V=v end
|
|
||||||
|
|
||||||
parent = {}
|
|
||||||
parent.__newindex = parent
|
|
||||||
setmetatable(parent, grandparent)
|
|
||||||
|
|
||||||
child = setmetatable({}, parent)
|
|
||||||
child.foo = 10 --> CRASH (on some machines)
|
|
||||||
assert(T == parent and K == "foo" and V == 10)
|
|
||||||
|
|
||||||
print 'OK'
|
|
||||||
|
|
||||||
return 12
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,951 +0,0 @@
|
|||||||
-- $Id: testes/files.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
local debug = require "debug"
|
|
||||||
|
|
||||||
local maxint = math.maxinteger
|
|
||||||
|
|
||||||
assert(type(os.getenv"PATH") == "string")
|
|
||||||
|
|
||||||
assert(io.input(io.stdin) == io.stdin)
|
|
||||||
assert(not pcall(io.input, "non-existent-file"))
|
|
||||||
assert(io.output(io.stdout) == io.stdout)
|
|
||||||
|
|
||||||
|
|
||||||
local function testerr (msg, f, ...)
|
|
||||||
local stat, err = pcall(f, ...)
|
|
||||||
return (not stat and string.find(err, msg, 1, true))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function checkerr (msg, f, ...)
|
|
||||||
assert(testerr(msg, f, ...))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- cannot close standard files
|
|
||||||
assert(not io.close(io.stdin) and
|
|
||||||
not io.stdout:close() and
|
|
||||||
not io.stderr:close())
|
|
||||||
|
|
||||||
-- cannot call close method without an argument (new in 5.3.5)
|
|
||||||
checkerr("got no value", io.stdin.close)
|
|
||||||
|
|
||||||
|
|
||||||
assert(type(io.input()) == "userdata" and io.type(io.output()) == "file")
|
|
||||||
assert(type(io.stdin) == "userdata" and io.type(io.stderr) == "file")
|
|
||||||
assert(not io.type(8))
|
|
||||||
local a = {}; setmetatable(a, {})
|
|
||||||
assert(not io.type(a))
|
|
||||||
|
|
||||||
assert(getmetatable(io.input()).__name == "FILE*")
|
|
||||||
|
|
||||||
local a,b,c = io.open('xuxu_nao_existe')
|
|
||||||
assert(not a and type(b) == "string" and type(c) == "number")
|
|
||||||
|
|
||||||
a,b,c = io.open('/a/b/c/d', 'w')
|
|
||||||
assert(not a and type(b) == "string" and type(c) == "number")
|
|
||||||
|
|
||||||
local file = os.tmpname()
|
|
||||||
local f, msg = io.open(file, "w")
|
|
||||||
if not f then
|
|
||||||
(Message or print)("'os.tmpname' file cannot be open; skipping file tests")
|
|
||||||
|
|
||||||
else --{ most tests here need tmpname
|
|
||||||
f:close()
|
|
||||||
|
|
||||||
print('testing i/o')
|
|
||||||
|
|
||||||
local otherfile = os.tmpname()
|
|
||||||
|
|
||||||
checkerr("invalid mode", io.open, file, "rw")
|
|
||||||
checkerr("invalid mode", io.open, file, "rb+")
|
|
||||||
checkerr("invalid mode", io.open, file, "r+bk")
|
|
||||||
checkerr("invalid mode", io.open, file, "")
|
|
||||||
checkerr("invalid mode", io.open, file, "+")
|
|
||||||
checkerr("invalid mode", io.open, file, "b")
|
|
||||||
assert(io.open(file, "r+b")):close()
|
|
||||||
assert(io.open(file, "r+")):close()
|
|
||||||
assert(io.open(file, "rb")):close()
|
|
||||||
|
|
||||||
assert(os.setlocale('C', 'all'))
|
|
||||||
|
|
||||||
io.input(io.stdin); io.output(io.stdout);
|
|
||||||
|
|
||||||
os.remove(file)
|
|
||||||
assert(not loadfile(file))
|
|
||||||
checkerr("", dofile, file)
|
|
||||||
assert(not io.open(file))
|
|
||||||
io.output(file)
|
|
||||||
assert(io.output() ~= io.stdout)
|
|
||||||
|
|
||||||
if not _port then -- invalid seek
|
|
||||||
local status, msg, code = io.stdin:seek("set", 1000)
|
|
||||||
assert(not status and type(msg) == "string" and type(code) == "number")
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(io.output():seek() == 0)
|
|
||||||
assert(io.write("alo alo"):seek() == string.len("alo alo"))
|
|
||||||
assert(io.output():seek("cur", -3) == string.len("alo alo")-3)
|
|
||||||
assert(io.write("joao"))
|
|
||||||
assert(io.output():seek("end") == string.len("alo joao"))
|
|
||||||
|
|
||||||
assert(io.output():seek("set") == 0)
|
|
||||||
|
|
||||||
assert(io.write('"álo"', "{a}\n", "second line\n", "third line \n"))
|
|
||||||
assert(io.write('çfourth_line'))
|
|
||||||
io.output(io.stdout)
|
|
||||||
collectgarbage() -- file should be closed by GC
|
|
||||||
assert(io.input() == io.stdin and rawequal(io.output(), io.stdout))
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
-- test GC for files
|
|
||||||
collectgarbage()
|
|
||||||
for i=1,120 do
|
|
||||||
for i=1,5 do
|
|
||||||
io.input(file)
|
|
||||||
assert(io.open(file, 'r'))
|
|
||||||
io.lines(file)
|
|
||||||
end
|
|
||||||
collectgarbage()
|
|
||||||
end
|
|
||||||
|
|
||||||
io.input():close()
|
|
||||||
io.close()
|
|
||||||
|
|
||||||
assert(os.rename(file, otherfile))
|
|
||||||
assert(not os.rename(file, otherfile))
|
|
||||||
|
|
||||||
io.output(io.open(otherfile, "ab"))
|
|
||||||
assert(io.write("\n\n\t\t ", 3450, "\n"));
|
|
||||||
io.close()
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
-- closing file by scope
|
|
||||||
local F = nil
|
|
||||||
do
|
|
||||||
local f <close> = assert(io.open(file, "w"))
|
|
||||||
F = f
|
|
||||||
end
|
|
||||||
assert(tostring(F) == "file (closed)")
|
|
||||||
end
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
-- test writing/reading numbers
|
|
||||||
local f <close> = assert(io.open(file, "w"))
|
|
||||||
f:write(maxint, '\n')
|
|
||||||
f:write(string.format("0X%x\n", maxint))
|
|
||||||
f:write("0xABCp-3", '\n')
|
|
||||||
f:write(0, '\n')
|
|
||||||
f:write(-maxint, '\n')
|
|
||||||
f:write(string.format("0x%X\n", -maxint))
|
|
||||||
f:write("-0xABCp-3", '\n')
|
|
||||||
assert(f:close())
|
|
||||||
local f <close> = assert(io.open(file, "r"))
|
|
||||||
assert(f:read("n") == maxint)
|
|
||||||
assert(f:read("n") == maxint)
|
|
||||||
assert(f:read("n") == 0xABCp-3)
|
|
||||||
assert(f:read("n") == 0)
|
|
||||||
assert(f:read("*n") == -maxint) -- test old format (with '*')
|
|
||||||
assert(f:read("n") == -maxint)
|
|
||||||
assert(f:read("*n") == -0xABCp-3) -- test old format (with '*')
|
|
||||||
end
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
|
|
||||||
-- testing multiple arguments to io.read
|
|
||||||
do
|
|
||||||
local f <close> = assert(io.open(file, "w"))
|
|
||||||
f:write[[
|
|
||||||
a line
|
|
||||||
another line
|
|
||||||
1234
|
|
||||||
3.45
|
|
||||||
one
|
|
||||||
two
|
|
||||||
three
|
|
||||||
]]
|
|
||||||
local l1, l2, l3, l4, n1, n2, c, dummy
|
|
||||||
assert(f:close())
|
|
||||||
local f <close> = assert(io.open(file, "r"))
|
|
||||||
l1, l2, n1, n2, dummy = f:read("l", "L", "n", "n")
|
|
||||||
assert(l1 == "a line" and l2 == "another line\n" and
|
|
||||||
n1 == 1234 and n2 == 3.45 and dummy == nil)
|
|
||||||
assert(f:close())
|
|
||||||
local f <close> = assert(io.open(file, "r"))
|
|
||||||
l1, l2, n1, n2, c, l3, l4, dummy = f:read(7, "l", "n", "n", 1, "l", "l")
|
|
||||||
assert(l1 == "a line\n" and l2 == "another line" and c == '\n' and
|
|
||||||
n1 == 1234 and n2 == 3.45 and l3 == "one" and l4 == "two"
|
|
||||||
and dummy == nil)
|
|
||||||
assert(f:close())
|
|
||||||
local f <close> = assert(io.open(file, "r"))
|
|
||||||
-- second item failing
|
|
||||||
l1, n1, n2, dummy = f:read("l", "n", "n", "l")
|
|
||||||
assert(l1 == "a line" and not n1)
|
|
||||||
end
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
-- test yielding during 'dofile'
|
|
||||||
f = assert(io.open(file, "w"))
|
|
||||||
f:write[[
|
|
||||||
local x, z = coroutine.yield(10)
|
|
||||||
local y = coroutine.yield(20)
|
|
||||||
return x + y * z
|
|
||||||
]]
|
|
||||||
assert(f:close())
|
|
||||||
f = coroutine.wrap(dofile)
|
|
||||||
assert(f(file) == 10)
|
|
||||||
assert(f(100, 101) == 20)
|
|
||||||
assert(f(200) == 100 + 200 * 101)
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
|
|
||||||
f = assert(io.open(file, "w"))
|
|
||||||
-- test number termination
|
|
||||||
f:write[[
|
|
||||||
-12.3- -0xffff+ .3|5.E-3X +234e+13E 0xDEADBEEFDEADBEEFx
|
|
||||||
0x1.13Ap+3e
|
|
||||||
]]
|
|
||||||
-- very long number
|
|
||||||
f:write("1234"); for i = 1, 1000 do f:write("0") end; f:write("\n")
|
|
||||||
-- invalid sequences (must read and discard valid prefixes)
|
|
||||||
f:write[[
|
|
||||||
.e+ 0.e; --; 0xX;
|
|
||||||
]]
|
|
||||||
assert(f:close())
|
|
||||||
f = assert(io.open(file, "r"))
|
|
||||||
assert(f:read("n") == -12.3); assert(f:read(1) == "-")
|
|
||||||
assert(f:read("n") == -0xffff); assert(f:read(2) == "+ ")
|
|
||||||
assert(f:read("n") == 0.3); assert(f:read(1) == "|")
|
|
||||||
assert(f:read("n") == 5e-3); assert(f:read(1) == "X")
|
|
||||||
assert(f:read("n") == 234e13); assert(f:read(1) == "E")
|
|
||||||
assert(f:read("n") == 0Xdeadbeefdeadbeef); assert(f:read(2) == "x\n")
|
|
||||||
assert(f:read("n") == 0x1.13aP3); assert(f:read(1) == "e")
|
|
||||||
|
|
||||||
do -- attempt to read too long number
|
|
||||||
assert(not f:read("n")) -- fails
|
|
||||||
local s = f:read("L") -- read rest of line
|
|
||||||
assert(string.find(s, "^00*\n$")) -- lots of 0's left
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(not f:read("n")); assert(f:read(2) == "e+")
|
|
||||||
assert(not f:read("n")); assert(f:read(1) == ";")
|
|
||||||
assert(not f:read("n")); assert(f:read(2) == "-;")
|
|
||||||
assert(not f:read("n")); assert(f:read(1) == "X")
|
|
||||||
assert(not f:read("n")); assert(f:read(1) == ";")
|
|
||||||
assert(not f:read("n")); assert(not f:read(0)) -- end of file
|
|
||||||
assert(f:close())
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
|
|
||||||
-- test line generators
|
|
||||||
assert(not pcall(io.lines, "non-existent-file"))
|
|
||||||
assert(os.rename(otherfile, file))
|
|
||||||
io.output(otherfile)
|
|
||||||
local n = 0
|
|
||||||
local f = io.lines(file)
|
|
||||||
while f() do n = n + 1 end;
|
|
||||||
assert(n == 6) -- number of lines in the file
|
|
||||||
checkerr("file is already closed", f)
|
|
||||||
checkerr("file is already closed", f)
|
|
||||||
-- copy from file to otherfile
|
|
||||||
n = 0
|
|
||||||
for l in io.lines(file) do io.write(l, "\n"); n = n + 1 end
|
|
||||||
io.close()
|
|
||||||
assert(n == 6)
|
|
||||||
-- copy from otherfile back to file
|
|
||||||
local f = assert(io.open(otherfile))
|
|
||||||
assert(io.type(f) == "file")
|
|
||||||
io.output(file)
|
|
||||||
assert(not io.output():read())
|
|
||||||
n = 0
|
|
||||||
for l in f:lines() do io.write(l, "\n"); n = n + 1 end
|
|
||||||
assert(tostring(f):sub(1, 5) == "file ")
|
|
||||||
assert(f:close()); io.close()
|
|
||||||
assert(n == 6)
|
|
||||||
checkerr("closed file", io.close, f)
|
|
||||||
assert(tostring(f) == "file (closed)")
|
|
||||||
assert(io.type(f) == "closed file")
|
|
||||||
io.input(file)
|
|
||||||
f = io.open(otherfile):lines()
|
|
||||||
n = 0
|
|
||||||
for l in io.lines() do assert(l == f()); n = n + 1 end
|
|
||||||
f = nil; collectgarbage()
|
|
||||||
assert(n == 6)
|
|
||||||
assert(os.remove(otherfile))
|
|
||||||
|
|
||||||
do -- bug in 5.3.1
|
|
||||||
io.output(otherfile)
|
|
||||||
io.write(string.rep("a", 300), "\n")
|
|
||||||
io.close()
|
|
||||||
local t ={}; for i = 1, 250 do t[i] = 1 end
|
|
||||||
t = {io.lines(otherfile, table.unpack(t))()}
|
|
||||||
-- everything ok here
|
|
||||||
assert(#t == 250 and t[1] == 'a' and t[#t] == 'a')
|
|
||||||
t[#t + 1] = 1 -- one too many
|
|
||||||
checkerr("too many arguments", io.lines, otherfile, table.unpack(t))
|
|
||||||
collectgarbage() -- ensure 'otherfile' is closed
|
|
||||||
assert(os.remove(otherfile))
|
|
||||||
end
|
|
||||||
|
|
||||||
io.input(file)
|
|
||||||
do -- test error returns
|
|
||||||
local a,b,c = io.input():write("xuxu")
|
|
||||||
assert(not a and type(b) == "string" and type(c) == "number")
|
|
||||||
end
|
|
||||||
checkerr("invalid format", io.read, "x")
|
|
||||||
assert(io.read(0) == "") -- not eof
|
|
||||||
assert(io.read(5, 'l') == '"álo"')
|
|
||||||
assert(io.read(0) == "")
|
|
||||||
assert(io.read() == "second line")
|
|
||||||
local x = io.input():seek()
|
|
||||||
assert(io.read() == "third line ")
|
|
||||||
assert(io.input():seek("set", x))
|
|
||||||
assert(io.read('L') == "third line \n")
|
|
||||||
assert(io.read(1) == "ç")
|
|
||||||
assert(io.read(string.len"fourth_line") == "fourth_line")
|
|
||||||
assert(io.input():seek("cur", -string.len"fourth_line"))
|
|
||||||
assert(io.read() == "fourth_line")
|
|
||||||
assert(io.read() == "") -- empty line
|
|
||||||
assert(io.read('n') == 3450)
|
|
||||||
assert(io.read(1) == '\n')
|
|
||||||
assert(not io.read(0)) -- end of file
|
|
||||||
assert(not io.read(1)) -- end of file
|
|
||||||
assert(not io.read(30000)) -- end of file
|
|
||||||
assert(({io.read(1)})[2] == undef)
|
|
||||||
assert(not io.read()) -- end of file
|
|
||||||
assert(({io.read()})[2] == undef)
|
|
||||||
assert(not io.read('n')) -- end of file
|
|
||||||
assert(({io.read('n')})[2] == undef)
|
|
||||||
assert(io.read('a') == '') -- end of file (OK for 'a')
|
|
||||||
assert(io.read('a') == '') -- end of file (OK for 'a')
|
|
||||||
collectgarbage()
|
|
||||||
print('+')
|
|
||||||
io.close(io.input())
|
|
||||||
checkerr(" input file is closed", io.read)
|
|
||||||
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
local t = '0123456789'
|
|
||||||
for i=1,10 do t = t..t; end
|
|
||||||
assert(string.len(t) == 10*2^10)
|
|
||||||
|
|
||||||
io.output(file)
|
|
||||||
io.write("alo"):write("\n")
|
|
||||||
io.close()
|
|
||||||
checkerr(" output file is closed", io.write)
|
|
||||||
local f = io.open(file, "a+b")
|
|
||||||
io.output(f)
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
assert(io.write(' ' .. t .. ' '))
|
|
||||||
assert(io.write(';', 'end of file\n'))
|
|
||||||
f:flush(); io.flush()
|
|
||||||
f:close()
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
io.input(file)
|
|
||||||
assert(io.read() == "alo")
|
|
||||||
assert(io.read(1) == ' ')
|
|
||||||
assert(io.read(string.len(t)) == t)
|
|
||||||
assert(io.read(1) == ' ')
|
|
||||||
assert(io.read(0))
|
|
||||||
assert(io.read('a') == ';end of file\n')
|
|
||||||
assert(not io.read(0))
|
|
||||||
assert(io.close(io.input()))
|
|
||||||
|
|
||||||
|
|
||||||
-- test errors in read/write
|
|
||||||
do
|
|
||||||
local function ismsg (m)
|
|
||||||
-- error message is not a code number
|
|
||||||
return (type(m) == "string" and not tonumber(m))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- read
|
|
||||||
local f = io.open(file, "w")
|
|
||||||
local r, m, c = f:read()
|
|
||||||
assert(not r and ismsg(m) and type(c) == "number")
|
|
||||||
assert(f:close())
|
|
||||||
-- write
|
|
||||||
f = io.open(file, "r")
|
|
||||||
r, m, c = f:write("whatever")
|
|
||||||
assert(not r and ismsg(m) and type(c) == "number")
|
|
||||||
assert(f:close())
|
|
||||||
-- lines
|
|
||||||
f = io.open(file, "w")
|
|
||||||
r, m = pcall(f:lines())
|
|
||||||
assert(r == false and ismsg(m))
|
|
||||||
assert(f:close())
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
-- test for L format
|
|
||||||
io.output(file); io.write"\n\nline\nother":close()
|
|
||||||
io.input(file)
|
|
||||||
assert(io.read"L" == "\n")
|
|
||||||
assert(io.read"L" == "\n")
|
|
||||||
assert(io.read"L" == "line\n")
|
|
||||||
assert(io.read"L" == "other")
|
|
||||||
assert(not io.read"L")
|
|
||||||
io.input():close()
|
|
||||||
|
|
||||||
local f = assert(io.open(file))
|
|
||||||
local s = ""
|
|
||||||
for l in f:lines("L") do s = s .. l end
|
|
||||||
assert(s == "\n\nline\nother")
|
|
||||||
f:close()
|
|
||||||
|
|
||||||
io.input(file)
|
|
||||||
s = ""
|
|
||||||
for l in io.lines(nil, "L") do s = s .. l end
|
|
||||||
assert(s == "\n\nline\nother")
|
|
||||||
io.input():close()
|
|
||||||
|
|
||||||
s = ""
|
|
||||||
for l in io.lines(file, "L") do s = s .. l end
|
|
||||||
assert(s == "\n\nline\nother")
|
|
||||||
|
|
||||||
s = ""
|
|
||||||
for l in io.lines(file, "l") do s = s .. l end
|
|
||||||
assert(s == "lineother")
|
|
||||||
|
|
||||||
io.output(file); io.write"a = 10 + 34\na = 2*a\na = -a\n":close()
|
|
||||||
local t = {}
|
|
||||||
assert(load(io.lines(file, "L"), nil, nil, t))()
|
|
||||||
assert(t.a == -((10 + 34) * 2))
|
|
||||||
|
|
||||||
|
|
||||||
do -- testing closing file in line iteration
|
|
||||||
|
|
||||||
-- get the to-be-closed variable from a loop
|
|
||||||
local function gettoclose (lv)
|
|
||||||
lv = lv + 1
|
|
||||||
local stvar = 0 -- to-be-closed is 4th state variable in the loop
|
|
||||||
for i = 1, 1000 do
|
|
||||||
local n, v = debug.getlocal(lv, i)
|
|
||||||
if n == "(for state)" then
|
|
||||||
stvar = stvar + 1
|
|
||||||
if stvar == 4 then return v end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local f
|
|
||||||
for l in io.lines(file) do
|
|
||||||
f = gettoclose(1)
|
|
||||||
assert(io.type(f) == "file")
|
|
||||||
break
|
|
||||||
end
|
|
||||||
assert(io.type(f) == "closed file")
|
|
||||||
|
|
||||||
f = nil
|
|
||||||
local function foo (name)
|
|
||||||
for l in io.lines(name) do
|
|
||||||
f = gettoclose(1)
|
|
||||||
assert(io.type(f) == "file")
|
|
||||||
error(f) -- exit loop with an error
|
|
||||||
end
|
|
||||||
end
|
|
||||||
local st, msg = pcall(foo, file)
|
|
||||||
assert(st == false and io.type(msg) == "closed file")
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- test for multipe arguments in 'lines'
|
|
||||||
io.output(file); io.write"0123456789\n":close()
|
|
||||||
for a,b in io.lines(file, 1, 1) do
|
|
||||||
if a == "\n" then assert(not b)
|
|
||||||
else assert(tonumber(a) == tonumber(b) - 1)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for a,b,c in io.lines(file, 1, 2, "a") do
|
|
||||||
assert(a == "0" and b == "12" and c == "3456789\n")
|
|
||||||
end
|
|
||||||
|
|
||||||
for a,b,c in io.lines(file, "a", 0, 1) do
|
|
||||||
if a == "" then break end
|
|
||||||
assert(a == "0123456789\n" and not b and not c)
|
|
||||||
end
|
|
||||||
collectgarbage() -- to close file in previous iteration
|
|
||||||
|
|
||||||
io.output(file); io.write"00\n10\n20\n30\n40\n":close()
|
|
||||||
for a, b in io.lines(file, "n", "n") do
|
|
||||||
if a == 40 then assert(not b)
|
|
||||||
else assert(a == b - 10)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- test load x lines
|
|
||||||
io.output(file);
|
|
||||||
io.write[[
|
|
||||||
local y
|
|
||||||
= X
|
|
||||||
X =
|
|
||||||
X *
|
|
||||||
2 +
|
|
||||||
X;
|
|
||||||
X =
|
|
||||||
X
|
|
||||||
- y;
|
|
||||||
]]:close()
|
|
||||||
_G.X = 1
|
|
||||||
assert(not load((io.lines(file))))
|
|
||||||
collectgarbage() -- to close file in previous iteration
|
|
||||||
load((io.lines(file, "L")))()
|
|
||||||
assert(_G.X == 2)
|
|
||||||
load((io.lines(file, 1)))()
|
|
||||||
assert(_G.X == 4)
|
|
||||||
load((io.lines(file, 3)))()
|
|
||||||
assert(_G.X == 8)
|
|
||||||
_G.X = nil
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local x1 = "string\n\n\\com \"\"''coisas [[estranhas]] ]]'"
|
|
||||||
io.output(file)
|
|
||||||
assert(io.write(string.format("X2 = %q\n-- comment without ending EOS", x1)))
|
|
||||||
io.close()
|
|
||||||
assert(loadfile(file))()
|
|
||||||
assert(x1 == _G.X2)
|
|
||||||
_G.X2 = nil
|
|
||||||
print('+')
|
|
||||||
assert(os.remove(file))
|
|
||||||
assert(not os.remove(file))
|
|
||||||
assert(not os.remove(otherfile))
|
|
||||||
|
|
||||||
-- testing loadfile
|
|
||||||
local function testloadfile (s, expres)
|
|
||||||
io.output(file)
|
|
||||||
if s then io.write(s) end
|
|
||||||
io.close()
|
|
||||||
local res = assert(loadfile(file))()
|
|
||||||
assert(os.remove(file))
|
|
||||||
assert(res == expres)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- loading empty file
|
|
||||||
testloadfile(nil, nil)
|
|
||||||
|
|
||||||
-- loading file with initial comment without end of line
|
|
||||||
testloadfile("# a non-ending comment", nil)
|
|
||||||
|
|
||||||
|
|
||||||
-- checking Unicode BOM in files
|
|
||||||
testloadfile("\xEF\xBB\xBF# some comment\nreturn 234", 234)
|
|
||||||
testloadfile("\xEF\xBB\xBFreturn 239", 239)
|
|
||||||
testloadfile("\xEF\xBB\xBF", nil) -- empty file with a BOM
|
|
||||||
|
|
||||||
|
|
||||||
-- checking line numbers in files with initial comments
|
|
||||||
testloadfile("# a comment\nreturn require'debug'.getinfo(1).currentline", 2)
|
|
||||||
|
|
||||||
|
|
||||||
-- loading binary file
|
|
||||||
io.output(io.open(file, "wb"))
|
|
||||||
assert(io.write(string.dump(function () return 10, '\0alo\255', 'hi' end)))
|
|
||||||
io.close()
|
|
||||||
a, b, c = assert(loadfile(file))()
|
|
||||||
assert(a == 10 and b == "\0alo\255" and c == "hi")
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
-- bug in 5.2.1
|
|
||||||
do
|
|
||||||
io.output(io.open(file, "wb"))
|
|
||||||
-- save function with no upvalues
|
|
||||||
assert(io.write(string.dump(function () return 1 end)))
|
|
||||||
io.close()
|
|
||||||
f = assert(loadfile(file, "b", {}))
|
|
||||||
assert(type(f) == "function" and f() == 1)
|
|
||||||
assert(os.remove(file))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- loading binary file with initial comment
|
|
||||||
io.output(io.open(file, "wb"))
|
|
||||||
assert(io.write("#this is a comment for a binary file\0\n",
|
|
||||||
string.dump(function () return 20, '\0\0\0' end)))
|
|
||||||
io.close()
|
|
||||||
a, b, c = assert(loadfile(file))()
|
|
||||||
assert(a == 20 and b == "\0\0\0" and c == nil)
|
|
||||||
assert(os.remove(file))
|
|
||||||
|
|
||||||
|
|
||||||
-- 'loadfile' with 'env'
|
|
||||||
do
|
|
||||||
local f = io.open(file, 'w')
|
|
||||||
f:write[[
|
|
||||||
if (...) then a = 15; return b, c, d
|
|
||||||
else return _ENV
|
|
||||||
end
|
|
||||||
]]
|
|
||||||
f:close()
|
|
||||||
local t = {b = 12, c = "xuxu", d = print}
|
|
||||||
local f = assert(loadfile(file, 't', t))
|
|
||||||
local b, c, d = f(1)
|
|
||||||
assert(t.a == 15 and b == 12 and c == t.c and d == print)
|
|
||||||
assert(f() == t)
|
|
||||||
f = assert(loadfile(file, 't', nil))
|
|
||||||
assert(f() == nil)
|
|
||||||
f = assert(loadfile(file))
|
|
||||||
assert(f() == _G)
|
|
||||||
assert(os.remove(file))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- 'loadfile' x modes
|
|
||||||
do
|
|
||||||
io.open(file, 'w'):write("return 10"):close()
|
|
||||||
local s, m = loadfile(file, 'b')
|
|
||||||
assert(not s and string.find(m, "a text chunk"))
|
|
||||||
io.open(file, 'w'):write("\27 return 10"):close()
|
|
||||||
local s, m = loadfile(file, 't')
|
|
||||||
assert(not s and string.find(m, "a binary chunk"))
|
|
||||||
assert(os.remove(file))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
io.output(file)
|
|
||||||
assert(io.write("qualquer coisa\n"))
|
|
||||||
assert(io.write("mais qualquer coisa"))
|
|
||||||
io.close()
|
|
||||||
assert(io.output(assert(io.open(otherfile, 'wb')))
|
|
||||||
:write("outra coisa\0\1\3\0\0\0\0\255\0")
|
|
||||||
:close())
|
|
||||||
|
|
||||||
local filehandle = assert(io.open(file, 'r+'))
|
|
||||||
local otherfilehandle = assert(io.open(otherfile, 'rb'))
|
|
||||||
assert(filehandle ~= otherfilehandle)
|
|
||||||
assert(type(filehandle) == "userdata")
|
|
||||||
assert(filehandle:read('l') == "qualquer coisa")
|
|
||||||
io.input(otherfilehandle)
|
|
||||||
assert(io.read(string.len"outra coisa") == "outra coisa")
|
|
||||||
assert(filehandle:read('l') == "mais qualquer coisa")
|
|
||||||
filehandle:close();
|
|
||||||
assert(type(filehandle) == "userdata")
|
|
||||||
io.input(otherfilehandle)
|
|
||||||
assert(io.read(4) == "\0\1\3\0")
|
|
||||||
assert(io.read(3) == "\0\0\0")
|
|
||||||
assert(io.read(0) == "") -- 255 is not eof
|
|
||||||
assert(io.read(1) == "\255")
|
|
||||||
assert(io.read('a') == "\0")
|
|
||||||
assert(not io.read(0))
|
|
||||||
assert(otherfilehandle == io.input())
|
|
||||||
otherfilehandle:close()
|
|
||||||
assert(os.remove(file))
|
|
||||||
assert(os.remove(otherfile))
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
io.output(file)
|
|
||||||
:write[[
|
|
||||||
123.4 -56e-2 not a number
|
|
||||||
second line
|
|
||||||
third line
|
|
||||||
|
|
||||||
and the rest of the file
|
|
||||||
]]
|
|
||||||
:close()
|
|
||||||
io.input(file)
|
|
||||||
local _,a,b,c,d,e,h,__ = io.read(1, 'n', 'n', 'l', 'l', 'l', 'a', 10)
|
|
||||||
assert(io.close(io.input()))
|
|
||||||
assert(_ == ' ' and not __)
|
|
||||||
assert(type(a) == 'number' and a==123.4 and b==-56e-2)
|
|
||||||
assert(d=='second line' and e=='third line')
|
|
||||||
assert(h==[[
|
|
||||||
|
|
||||||
and the rest of the file
|
|
||||||
]])
|
|
||||||
assert(os.remove(file))
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
-- testing buffers
|
|
||||||
do
|
|
||||||
local f = assert(io.open(file, "w"))
|
|
||||||
local fr = assert(io.open(file, "r"))
|
|
||||||
assert(f:setvbuf("full", 2000))
|
|
||||||
f:write("x")
|
|
||||||
assert(fr:read("all") == "") -- full buffer; output not written yet
|
|
||||||
f:close()
|
|
||||||
fr:seek("set")
|
|
||||||
assert(fr:read("all") == "x") -- `close' flushes it
|
|
||||||
f = assert(io.open(file), "w")
|
|
||||||
assert(f:setvbuf("no"))
|
|
||||||
f:write("x")
|
|
||||||
fr:seek("set")
|
|
||||||
assert(fr:read("all") == "x") -- no buffer; output is ready
|
|
||||||
f:close()
|
|
||||||
f = assert(io.open(file, "a"))
|
|
||||||
assert(f:setvbuf("line"))
|
|
||||||
f:write("x")
|
|
||||||
fr:seek("set", 1)
|
|
||||||
assert(fr:read("all") == "") -- line buffer; no output without `\n'
|
|
||||||
f:write("a\n"):seek("set", 1)
|
|
||||||
assert(fr:read("all") == "xa\n") -- now we have a whole line
|
|
||||||
f:close(); fr:close()
|
|
||||||
assert(os.remove(file))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not _soft then
|
|
||||||
print("testing large files (> BUFSIZ)")
|
|
||||||
io.output(file)
|
|
||||||
for i=1,5001 do io.write('0123456789123') end
|
|
||||||
io.write('\n12346'):close()
|
|
||||||
io.input(file)
|
|
||||||
local x = io.read('a')
|
|
||||||
io.input():seek('set', 0)
|
|
||||||
local y = io.read(30001)..io.read(1005)..io.read(0)..
|
|
||||||
io.read(1)..io.read(100003)
|
|
||||||
assert(x == y and string.len(x) == 5001*13 + 6)
|
|
||||||
io.input():seek('set', 0)
|
|
||||||
y = io.read() -- huge line
|
|
||||||
assert(x == y..'\n'..io.read())
|
|
||||||
assert(not io.read())
|
|
||||||
io.close(io.input())
|
|
||||||
assert(os.remove(file))
|
|
||||||
x = nil; y = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
if not _port then
|
|
||||||
local progname
|
|
||||||
do -- get name of running executable
|
|
||||||
local arg = arg or ARG
|
|
||||||
local i = 0
|
|
||||||
while arg[i] do i = i - 1 end
|
|
||||||
progname = '"' .. arg[i + 1] .. '"'
|
|
||||||
end
|
|
||||||
print("testing popen/pclose and execute")
|
|
||||||
-- invalid mode for popen
|
|
||||||
checkerr("invalid mode", io.popen, "cat", "")
|
|
||||||
checkerr("invalid mode", io.popen, "cat", "r+")
|
|
||||||
checkerr("invalid mode", io.popen, "cat", "rw")
|
|
||||||
do -- basic tests for popen
|
|
||||||
local file = os.tmpname()
|
|
||||||
local f = assert(io.popen("cat - > " .. file, "w"))
|
|
||||||
f:write("a line")
|
|
||||||
assert(f:close())
|
|
||||||
local f = assert(io.popen("cat - < " .. file, "r"))
|
|
||||||
assert(f:read("a") == "a line")
|
|
||||||
assert(f:close())
|
|
||||||
assert(os.remove(file))
|
|
||||||
end
|
|
||||||
|
|
||||||
local tests = {
|
|
||||||
-- command, what, code
|
|
||||||
{"ls > /dev/null", "ok"},
|
|
||||||
{"not-to-be-found-command", "exit"},
|
|
||||||
{"exit 3", "exit", 3},
|
|
||||||
{"exit 129", "exit", 129},
|
|
||||||
{"kill -s HUP $$", "signal", 1},
|
|
||||||
{"kill -s KILL $$", "signal", 9},
|
|
||||||
{"sh -c 'kill -s HUP $$'", "exit"},
|
|
||||||
{progname .. ' -e " "', "ok"},
|
|
||||||
{progname .. ' -e "os.exit(0, true)"', "ok"},
|
|
||||||
{progname .. ' -e "os.exit(20, true)"', "exit", 20},
|
|
||||||
}
|
|
||||||
print("\n(some error messages are expected now)")
|
|
||||||
for _, v in ipairs(tests) do
|
|
||||||
local x, y, z = io.popen(v[1]):close()
|
|
||||||
local x1, y1, z1 = os.execute(v[1])
|
|
||||||
assert(x == x1 and y == y1 and z == z1)
|
|
||||||
if v[2] == "ok" then
|
|
||||||
assert(x and y == 'exit' and z == 0)
|
|
||||||
else
|
|
||||||
assert(not x and y == v[2]) -- correct status and 'what'
|
|
||||||
-- correct code if known (but always different from 0)
|
|
||||||
assert((v[3] == nil and z > 0) or v[3] == z)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing tmpfile
|
|
||||||
f = io.tmpfile()
|
|
||||||
assert(io.type(f) == "file")
|
|
||||||
f:write("alo")
|
|
||||||
f:seek("set")
|
|
||||||
assert(f:read"a" == "alo")
|
|
||||||
|
|
||||||
end --}
|
|
||||||
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
print("testing date/time")
|
|
||||||
|
|
||||||
assert(os.date("") == "")
|
|
||||||
assert(os.date("!") == "")
|
|
||||||
assert(os.date("\0\0") == "\0\0")
|
|
||||||
assert(os.date("!\0\0") == "\0\0")
|
|
||||||
local x = string.rep("a", 10000)
|
|
||||||
assert(os.date(x) == x)
|
|
||||||
local t = os.time()
|
|
||||||
D = os.date("*t", t)
|
|
||||||
assert(os.date(string.rep("%d", 1000), t) ==
|
|
||||||
string.rep(os.date("%d", t), 1000))
|
|
||||||
assert(os.date(string.rep("%", 200)) == string.rep("%", 100))
|
|
||||||
|
|
||||||
local function checkDateTable (t)
|
|
||||||
_G.D = os.date("*t", t)
|
|
||||||
assert(os.time(D) == t)
|
|
||||||
load(os.date([[assert(D.year==%Y and D.month==%m and D.day==%d and
|
|
||||||
D.hour==%H and D.min==%M and D.sec==%S and
|
|
||||||
D.wday==%w+1 and D.yday==%j)]], t))()
|
|
||||||
_G.D = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
checkDateTable(os.time())
|
|
||||||
if not _port then
|
|
||||||
-- assume that time_t can represent these values
|
|
||||||
checkDateTable(0)
|
|
||||||
checkDateTable(1)
|
|
||||||
checkDateTable(1000)
|
|
||||||
checkDateTable(0x7fffffff)
|
|
||||||
checkDateTable(0x80000000)
|
|
||||||
end
|
|
||||||
|
|
||||||
checkerr("invalid conversion specifier", os.date, "%")
|
|
||||||
checkerr("invalid conversion specifier", os.date, "%9")
|
|
||||||
checkerr("invalid conversion specifier", os.date, "%")
|
|
||||||
checkerr("invalid conversion specifier", os.date, "%O")
|
|
||||||
checkerr("invalid conversion specifier", os.date, "%E")
|
|
||||||
checkerr("invalid conversion specifier", os.date, "%Ea")
|
|
||||||
|
|
||||||
checkerr("not an integer", os.time, {year=1000, month=1, day=1, hour='x'})
|
|
||||||
checkerr("not an integer", os.time, {year=1000, month=1, day=1, hour=1.5})
|
|
||||||
|
|
||||||
checkerr("missing", os.time, {hour = 12}) -- missing date
|
|
||||||
|
|
||||||
|
|
||||||
if string.packsize("i") == 4 then -- 4-byte ints
|
|
||||||
checkerr("field 'year' is out-of-bound", os.time,
|
|
||||||
{year = -(1 << 31) + 1899, month = 1, day = 1})
|
|
||||||
|
|
||||||
checkerr("field 'year' is out-of-bound", os.time,
|
|
||||||
{year = -(1 << 31), month = 1, day = 1})
|
|
||||||
|
|
||||||
if math.maxinteger > 2^31 then -- larger lua_integer?
|
|
||||||
checkerr("field 'year' is out-of-bound", os.time,
|
|
||||||
{year = (1 << 31) + 1900, month = 1, day = 1})
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not _port then
|
|
||||||
-- test Posix-specific modifiers
|
|
||||||
assert(type(os.date("%Ex")) == 'string')
|
|
||||||
assert(type(os.date("%Oy")) == 'string')
|
|
||||||
|
|
||||||
-- test large dates (assume at least 4-byte ints and time_t)
|
|
||||||
local t0 = os.time{year = 1970, month = 1, day = 0}
|
|
||||||
local t1 = os.time{year = 1970, month = 1, day = 0, sec = (1 << 31) - 1}
|
|
||||||
assert(t1 - t0 == (1 << 31) - 1)
|
|
||||||
t0 = os.time{year = 1970, month = 1, day = 1}
|
|
||||||
t1 = os.time{year = 1970, month = 1, day = 1, sec = -(1 << 31)}
|
|
||||||
assert(t1 - t0 == -(1 << 31))
|
|
||||||
|
|
||||||
-- test out-of-range dates (at least for Unix)
|
|
||||||
if maxint >= 2^62 then -- cannot do these tests in Small Lua
|
|
||||||
-- no arith overflows
|
|
||||||
checkerr("out-of-bound", os.time, {year = -maxint, month = 1, day = 1})
|
|
||||||
if string.packsize("i") == 4 then -- 4-byte ints
|
|
||||||
if testerr("out-of-bound", os.date, "%Y", 2^40) then
|
|
||||||
-- time_t has 4 bytes and therefore cannot represent year 4000
|
|
||||||
print(" 4-byte time_t")
|
|
||||||
checkerr("cannot be represented", os.time, {year=4000, month=1, day=1})
|
|
||||||
else
|
|
||||||
-- time_t has 8 bytes; an int year cannot represent a huge time
|
|
||||||
print(" 8-byte time_t")
|
|
||||||
checkerr("cannot be represented", os.date, "%Y", 2^60)
|
|
||||||
|
|
||||||
-- this is the maximum year
|
|
||||||
assert(tonumber(os.time
|
|
||||||
{year=(1 << 31) + 1899, month=12, day=31, hour=23, min=59, sec=59}))
|
|
||||||
|
|
||||||
-- this is too much
|
|
||||||
checkerr("represented", os.time,
|
|
||||||
{year=(1 << 31) + 1899, month=12, day=31, hour=23, min=59, sec=60})
|
|
||||||
end
|
|
||||||
|
|
||||||
-- internal 'int' fields cannot hold these values
|
|
||||||
checkerr("field 'day' is out-of-bound", os.time,
|
|
||||||
{year = 0, month = 1, day = 2^32})
|
|
||||||
|
|
||||||
checkerr("field 'month' is out-of-bound", os.time,
|
|
||||||
{year = 0, month = -((1 << 31) + 1), day = 1})
|
|
||||||
|
|
||||||
checkerr("field 'year' is out-of-bound", os.time,
|
|
||||||
{year = (1 << 31) + 1900, month = 1, day = 1})
|
|
||||||
|
|
||||||
else -- 8-byte ints
|
|
||||||
-- assume time_t has 8 bytes too
|
|
||||||
print(" 8-byte time_t")
|
|
||||||
assert(tonumber(os.date("%Y", 2^60)))
|
|
||||||
|
|
||||||
-- but still cannot represent a huge year
|
|
||||||
checkerr("cannot be represented", os.time, {year=2^60, month=1, day=1})
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local D = os.date("*t")
|
|
||||||
local t = os.time(D)
|
|
||||||
if D.isdst == nil then
|
|
||||||
print("no daylight saving information")
|
|
||||||
else
|
|
||||||
assert(type(D.isdst) == 'boolean')
|
|
||||||
end
|
|
||||||
D.isdst = nil
|
|
||||||
local t1 = os.time(D)
|
|
||||||
assert(t == t1) -- if isdst is absent uses correct default
|
|
||||||
end
|
|
||||||
|
|
||||||
local D = os.date("*t")
|
|
||||||
t = os.time(D)
|
|
||||||
D.year = D.year-1;
|
|
||||||
local t1 = os.time(D)
|
|
||||||
-- allow for leap years
|
|
||||||
assert(math.abs(os.difftime(t,t1)/(24*3600) - 365) < 2)
|
|
||||||
|
|
||||||
-- should not take more than 1 second to execute these two lines
|
|
||||||
t = os.time()
|
|
||||||
t1 = os.time(os.date("*t"))
|
|
||||||
local diff = os.difftime(t1,t)
|
|
||||||
assert(0 <= diff and diff <= 1)
|
|
||||||
diff = os.difftime(t,t1)
|
|
||||||
assert(-1 <= diff and diff <= 0)
|
|
||||||
|
|
||||||
local t1 = os.time{year=2000, month=10, day=1, hour=23, min=12}
|
|
||||||
local t2 = os.time{year=2000, month=10, day=1, hour=23, min=10, sec=19}
|
|
||||||
assert(os.difftime(t1,t2) == 60*2-19)
|
|
||||||
|
|
||||||
-- since 5.3.3, 'os.time' normalizes table fields
|
|
||||||
t1 = {year = 2005, month = 1, day = 1, hour = 1, min = 0, sec = -3602}
|
|
||||||
os.time(t1)
|
|
||||||
assert(t1.day == 31 and t1.month == 12 and t1.year == 2004 and
|
|
||||||
t1.hour == 23 and t1.min == 59 and t1.sec == 58 and
|
|
||||||
t1.yday == 366)
|
|
||||||
|
|
||||||
io.output(io.stdout)
|
|
||||||
local t = os.date('%d %m %Y %H %M %S')
|
|
||||||
local d, m, a, h, min, s = string.match(t,
|
|
||||||
"(%d+) (%d+) (%d+) (%d+) (%d+) (%d+)")
|
|
||||||
d = tonumber(d)
|
|
||||||
m = tonumber(m)
|
|
||||||
a = tonumber(a)
|
|
||||||
h = tonumber(h)
|
|
||||||
min = tonumber(min)
|
|
||||||
s = tonumber(s)
|
|
||||||
io.write(string.format('test done on %2.2d/%2.2d/%d', d, m, a))
|
|
||||||
io.write(string.format(', at %2.2d:%2.2d:%2.2d\n', h, min, s))
|
|
||||||
io.write(string.format('%s\n', _VERSION))
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,695 +0,0 @@
|
|||||||
-- $Id: testes/gc.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing incremental garbage collection')
|
|
||||||
|
|
||||||
local debug = require"debug"
|
|
||||||
|
|
||||||
assert(collectgarbage("isrunning"))
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
local oldmode = collectgarbage("incremental")
|
|
||||||
|
|
||||||
-- changing modes should return previous mode
|
|
||||||
assert(collectgarbage("generational") == "incremental")
|
|
||||||
assert(collectgarbage("generational") == "generational")
|
|
||||||
assert(collectgarbage("incremental") == "generational")
|
|
||||||
assert(collectgarbage("incremental") == "incremental")
|
|
||||||
|
|
||||||
|
|
||||||
local function nop () end
|
|
||||||
|
|
||||||
local function gcinfo ()
|
|
||||||
return collectgarbage"count" * 1024
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- test weird parameters to 'collectgarbage'
|
|
||||||
do
|
|
||||||
-- save original parameters
|
|
||||||
local a = collectgarbage("setpause", 200)
|
|
||||||
local b = collectgarbage("setstepmul", 200)
|
|
||||||
local t = {0, 2, 10, 90, 500, 5000, 30000, 0x7ffffffe}
|
|
||||||
for i = 1, #t do
|
|
||||||
local p = t[i]
|
|
||||||
for j = 1, #t do
|
|
||||||
local m = t[j]
|
|
||||||
collectgarbage("setpause", p)
|
|
||||||
collectgarbage("setstepmul", m)
|
|
||||||
collectgarbage("step", 0)
|
|
||||||
collectgarbage("step", 10000)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
-- restore original parameters
|
|
||||||
collectgarbage("setpause", a)
|
|
||||||
collectgarbage("setstepmul", b)
|
|
||||||
collectgarbage()
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
_G["while"] = 234
|
|
||||||
|
|
||||||
|
|
||||||
--
|
|
||||||
-- tests for GC activation when creating different kinds of objects
|
|
||||||
--
|
|
||||||
local function GC1 ()
|
|
||||||
local u
|
|
||||||
local b -- (above 'u' it in the stack)
|
|
||||||
local finish = false
|
|
||||||
u = setmetatable({}, {__gc = function () finish = true end})
|
|
||||||
b = {34}
|
|
||||||
repeat u = {} until finish
|
|
||||||
assert(b[1] == 34) -- 'u' was collected, but 'b' was not
|
|
||||||
|
|
||||||
finish = false; local i = 1
|
|
||||||
u = setmetatable({}, {__gc = function () finish = true end})
|
|
||||||
repeat i = i + 1; u = tostring(i) .. tostring(i) until finish
|
|
||||||
assert(b[1] == 34) -- 'u' was collected, but 'b' was not
|
|
||||||
|
|
||||||
finish = false
|
|
||||||
u = setmetatable({}, {__gc = function () finish = true end})
|
|
||||||
repeat local i; u = function () return i end until finish
|
|
||||||
assert(b[1] == 34) -- 'u' was collected, but 'b' was not
|
|
||||||
end
|
|
||||||
|
|
||||||
local function GC2 ()
|
|
||||||
local u
|
|
||||||
local finish = false
|
|
||||||
u = {setmetatable({}, {__gc = function () finish = true end})}
|
|
||||||
local b = {34}
|
|
||||||
repeat u = {{}} until finish
|
|
||||||
assert(b[1] == 34) -- 'u' was collected, but 'b' was not
|
|
||||||
|
|
||||||
finish = false; local i = 1
|
|
||||||
u = {setmetatable({}, {__gc = function () finish = true end})}
|
|
||||||
repeat i = i + 1; u = {tostring(i) .. tostring(i)} until finish
|
|
||||||
assert(b[1] == 34) -- 'u' was collected, but 'b' was not
|
|
||||||
|
|
||||||
finish = false
|
|
||||||
u = {setmetatable({}, {__gc = function () finish = true end})}
|
|
||||||
repeat local i; u = {function () return i end} until finish
|
|
||||||
assert(b[1] == 34) -- 'u' was collected, but 'b' was not
|
|
||||||
end
|
|
||||||
|
|
||||||
local function GC() GC1(); GC2() end
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
print("creating many objects")
|
|
||||||
|
|
||||||
local limit = 5000
|
|
||||||
|
|
||||||
for i = 1, limit do
|
|
||||||
local a = {}; a = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
local a = "a"
|
|
||||||
|
|
||||||
for i = 1, limit do
|
|
||||||
a = i .. "b";
|
|
||||||
a = string.gsub(a, '(%d%d*)', "%1 %1")
|
|
||||||
a = "a"
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
|
|
||||||
function a:test ()
|
|
||||||
for i = 1, limit do
|
|
||||||
load(string.format("function temp(a) return 'a%d' end", i), "")()
|
|
||||||
assert(temp() == string.format('a%d', i))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
a:test()
|
|
||||||
_G.temp = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- collection of functions without locals, globals, etc.
|
|
||||||
do local f = function () end end
|
|
||||||
|
|
||||||
|
|
||||||
print("functions with errors")
|
|
||||||
local prog = [[
|
|
||||||
do
|
|
||||||
a = 10;
|
|
||||||
function foo(x,y)
|
|
||||||
a = sin(a+0.456-0.23e-12);
|
|
||||||
return function (z) return sin(%x+z) end
|
|
||||||
end
|
|
||||||
local x = function (w) a=a+w; end
|
|
||||||
end
|
|
||||||
]]
|
|
||||||
do
|
|
||||||
local step = 1
|
|
||||||
if _soft then step = 13 end
|
|
||||||
for i=1, string.len(prog), step do
|
|
||||||
for j=i, string.len(prog), step do
|
|
||||||
pcall(load(string.sub(prog, i, j), ""))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
rawset(_G, "a", nil)
|
|
||||||
_G.x = nil
|
|
||||||
|
|
||||||
do
|
|
||||||
foo = nil
|
|
||||||
print('long strings')
|
|
||||||
local x = "01234567890123456789012345678901234567890123456789012345678901234567890123456789"
|
|
||||||
assert(string.len(x)==80)
|
|
||||||
local s = ''
|
|
||||||
local k = math.min(300, (math.maxinteger // 80) // 2)
|
|
||||||
for n = 1, k do s = s..x; local j=tostring(n) end
|
|
||||||
assert(string.len(s) == k*80)
|
|
||||||
s = string.sub(s, 1, 10000)
|
|
||||||
local s, i = string.gsub(s, '(%d%d%d%d)', '')
|
|
||||||
assert(i==10000 // 4)
|
|
||||||
|
|
||||||
assert(_G["while"] == 234)
|
|
||||||
_G["while"] = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--
|
|
||||||
-- test the "size" of basic GC steps (whatever they mean...)
|
|
||||||
--
|
|
||||||
do
|
|
||||||
print("steps")
|
|
||||||
|
|
||||||
print("steps (2)")
|
|
||||||
|
|
||||||
local function dosteps (siz)
|
|
||||||
collectgarbage()
|
|
||||||
local a = {}
|
|
||||||
for i=1,100 do a[i] = {{}}; local b = {} end
|
|
||||||
local x = gcinfo()
|
|
||||||
local i = 0
|
|
||||||
repeat -- do steps until it completes a collection cycle
|
|
||||||
i = i+1
|
|
||||||
until collectgarbage("step", siz)
|
|
||||||
assert(gcinfo() < x)
|
|
||||||
return i -- number of steps
|
|
||||||
end
|
|
||||||
|
|
||||||
collectgarbage"stop"
|
|
||||||
|
|
||||||
if not _port then
|
|
||||||
assert(dosteps(10) < dosteps(2))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- collector should do a full collection with so many steps
|
|
||||||
assert(dosteps(20000) == 1)
|
|
||||||
assert(collectgarbage("step", 20000) == true)
|
|
||||||
assert(collectgarbage("step", 20000) == true)
|
|
||||||
|
|
||||||
assert(not collectgarbage("isrunning"))
|
|
||||||
collectgarbage"restart"
|
|
||||||
assert(collectgarbage("isrunning"))
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not _port then
|
|
||||||
-- test the pace of the collector
|
|
||||||
collectgarbage(); collectgarbage()
|
|
||||||
local x = gcinfo()
|
|
||||||
collectgarbage"stop"
|
|
||||||
repeat
|
|
||||||
local a = {}
|
|
||||||
until gcinfo() > 3 * x
|
|
||||||
collectgarbage"restart"
|
|
||||||
assert(collectgarbage("isrunning"))
|
|
||||||
repeat
|
|
||||||
local a = {}
|
|
||||||
until gcinfo() <= x * 2
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
print("clearing tables")
|
|
||||||
local lim = 15
|
|
||||||
local a = {}
|
|
||||||
-- fill a with `collectable' indices
|
|
||||||
for i=1,lim do a[{}] = i end
|
|
||||||
b = {}
|
|
||||||
for k,v in pairs(a) do b[k]=v end
|
|
||||||
-- remove all indices and collect them
|
|
||||||
for n in pairs(b) do
|
|
||||||
a[n] = undef
|
|
||||||
assert(type(n) == 'table' and next(n) == nil)
|
|
||||||
collectgarbage()
|
|
||||||
end
|
|
||||||
b = nil
|
|
||||||
collectgarbage()
|
|
||||||
for n in pairs(a) do error'cannot be here' end
|
|
||||||
for i=1,lim do a[i] = i end
|
|
||||||
for i=1,lim do assert(a[i] == i) end
|
|
||||||
|
|
||||||
|
|
||||||
print('weak tables')
|
|
||||||
a = {}; setmetatable(a, {__mode = 'k'});
|
|
||||||
-- fill a with some `collectable' indices
|
|
||||||
for i=1,lim do a[{}] = i end
|
|
||||||
-- and some non-collectable ones
|
|
||||||
for i=1,lim do a[i] = i end
|
|
||||||
for i=1,lim do local s=string.rep('@', i); a[s] = s..'#' end
|
|
||||||
collectgarbage()
|
|
||||||
local i = 0
|
|
||||||
for k,v in pairs(a) do assert(k==v or k..'#'==v); i=i+1 end
|
|
||||||
assert(i == 2*lim)
|
|
||||||
|
|
||||||
a = {}; setmetatable(a, {__mode = 'v'});
|
|
||||||
a[1] = string.rep('b', 21)
|
|
||||||
collectgarbage()
|
|
||||||
assert(a[1]) -- strings are *values*
|
|
||||||
a[1] = undef
|
|
||||||
-- fill a with some `collectable' values (in both parts of the table)
|
|
||||||
for i=1,lim do a[i] = {} end
|
|
||||||
for i=1,lim do a[i..'x'] = {} end
|
|
||||||
-- and some non-collectable ones
|
|
||||||
for i=1,lim do local t={}; a[t]=t end
|
|
||||||
for i=1,lim do a[i+lim]=i..'x' end
|
|
||||||
collectgarbage()
|
|
||||||
local i = 0
|
|
||||||
for k,v in pairs(a) do assert(k==v or k-lim..'x' == v); i=i+1 end
|
|
||||||
assert(i == 2*lim)
|
|
||||||
|
|
||||||
a = {}; setmetatable(a, {__mode = 'kv'});
|
|
||||||
local x, y, z = {}, {}, {}
|
|
||||||
-- keep only some items
|
|
||||||
a[1], a[2], a[3] = x, y, z
|
|
||||||
a[string.rep('$', 11)] = string.rep('$', 11)
|
|
||||||
-- fill a with some `collectable' values
|
|
||||||
for i=4,lim do a[i] = {} end
|
|
||||||
for i=1,lim do a[{}] = i end
|
|
||||||
for i=1,lim do local t={}; a[t]=t end
|
|
||||||
collectgarbage()
|
|
||||||
assert(next(a) ~= nil)
|
|
||||||
local i = 0
|
|
||||||
for k,v in pairs(a) do
|
|
||||||
assert((k == 1 and v == x) or
|
|
||||||
(k == 2 and v == y) or
|
|
||||||
(k == 3 and v == z) or k==v);
|
|
||||||
i = i+1
|
|
||||||
end
|
|
||||||
assert(i == 4)
|
|
||||||
x,y,z=nil
|
|
||||||
collectgarbage()
|
|
||||||
assert(next(a) == string.rep('$', 11))
|
|
||||||
|
|
||||||
|
|
||||||
-- 'bug' in 5.1
|
|
||||||
a = {}
|
|
||||||
local t = {x = 10}
|
|
||||||
local C = setmetatable({key = t}, {__mode = 'v'})
|
|
||||||
local C1 = setmetatable({[t] = 1}, {__mode = 'k'})
|
|
||||||
a.x = t -- this should not prevent 't' from being removed from
|
|
||||||
-- weak table 'C' by the time 'a' is finalized
|
|
||||||
|
|
||||||
setmetatable(a, {__gc = function (u)
|
|
||||||
assert(C.key == nil)
|
|
||||||
assert(type(next(C1)) == 'table')
|
|
||||||
end})
|
|
||||||
|
|
||||||
a, t = nil
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage()
|
|
||||||
assert(next(C) == nil and next(C1) == nil)
|
|
||||||
C, C1 = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- ephemerons
|
|
||||||
local mt = {__mode = 'k'}
|
|
||||||
a = {{10},{20},{30},{40}}; setmetatable(a, mt)
|
|
||||||
x = nil
|
|
||||||
for i = 1, 100 do local n = {}; a[n] = {k = {x}}; x = n end
|
|
||||||
GC()
|
|
||||||
local n = x
|
|
||||||
local i = 0
|
|
||||||
while n do n = a[n].k[1]; i = i + 1 end
|
|
||||||
assert(i == 100)
|
|
||||||
x = nil
|
|
||||||
GC()
|
|
||||||
for i = 1, 4 do assert(a[i][1] == i * 10); a[i] = undef end
|
|
||||||
assert(next(a) == nil)
|
|
||||||
|
|
||||||
local K = {}
|
|
||||||
a[K] = {}
|
|
||||||
for i=1,10 do a[K][i] = {}; a[a[K][i]] = setmetatable({}, mt) end
|
|
||||||
x = nil
|
|
||||||
local k = 1
|
|
||||||
for j = 1,100 do
|
|
||||||
local n = {}; local nk = k%10 + 1
|
|
||||||
a[a[K][nk]][n] = {x, k = k}; x = n; k = nk
|
|
||||||
end
|
|
||||||
GC()
|
|
||||||
local n = x
|
|
||||||
local i = 0
|
|
||||||
while n do local t = a[a[K][k]][n]; n = t[1]; k = t.k; i = i + 1 end
|
|
||||||
assert(i == 100)
|
|
||||||
K = nil
|
|
||||||
GC()
|
|
||||||
-- assert(next(a) == nil)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing errors during GC
|
|
||||||
if T then
|
|
||||||
collectgarbage("stop") -- stop collection
|
|
||||||
local u = {}
|
|
||||||
local s = {}; setmetatable(s, {__mode = 'k'})
|
|
||||||
setmetatable(u, {__gc = function (o)
|
|
||||||
local i = s[o]
|
|
||||||
s[i] = true
|
|
||||||
assert(not s[i - 1]) -- check proper finalization order
|
|
||||||
if i == 8 then error("@expected@") end -- error during GC
|
|
||||||
end})
|
|
||||||
|
|
||||||
for i = 6, 10 do
|
|
||||||
local n = setmetatable({}, getmetatable(u))
|
|
||||||
s[n] = i
|
|
||||||
end
|
|
||||||
|
|
||||||
warn("@on"); warn("@store")
|
|
||||||
collectgarbage()
|
|
||||||
assert(string.find(_WARN, "error in __gc"))
|
|
||||||
assert(string.match(_WARN, "@(.-)@") == "expected"); _WARN = false
|
|
||||||
for i = 8, 10 do assert(s[i]) end
|
|
||||||
|
|
||||||
for i = 1, 5 do
|
|
||||||
local n = setmetatable({}, getmetatable(u))
|
|
||||||
s[n] = i
|
|
||||||
end
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
for i = 1, 10 do assert(s[i]) end
|
|
||||||
|
|
||||||
getmetatable(u).__gc = nil
|
|
||||||
warn("@normal")
|
|
||||||
|
|
||||||
end
|
|
||||||
print '+'
|
|
||||||
|
|
||||||
|
|
||||||
-- testing userdata
|
|
||||||
if T==nil then
|
|
||||||
(Message or print)('\n >>> testC not active: skipping userdata GC tests <<<\n')
|
|
||||||
|
|
||||||
else
|
|
||||||
|
|
||||||
local function newproxy(u)
|
|
||||||
return debug.setmetatable(T.newuserdata(0), debug.getmetatable(u))
|
|
||||||
end
|
|
||||||
|
|
||||||
collectgarbage("stop") -- stop collection
|
|
||||||
local u = newproxy(nil)
|
|
||||||
debug.setmetatable(u, {__gc = true})
|
|
||||||
local s = 0
|
|
||||||
local a = {[u] = 0}; setmetatable(a, {__mode = 'vk'})
|
|
||||||
for i=1,10 do a[newproxy(u)] = i end
|
|
||||||
for k in pairs(a) do assert(getmetatable(k) == getmetatable(u)) end
|
|
||||||
local a1 = {}; for k,v in pairs(a) do a1[k] = v end
|
|
||||||
for k,v in pairs(a1) do a[v] = k end
|
|
||||||
for i =1,10 do assert(a[i]) end
|
|
||||||
getmetatable(u).a = a1
|
|
||||||
getmetatable(u).u = u
|
|
||||||
do
|
|
||||||
local u = u
|
|
||||||
getmetatable(u).__gc = function (o)
|
|
||||||
assert(a[o] == 10-s)
|
|
||||||
assert(a[10-s] == undef) -- udata already removed from weak table
|
|
||||||
assert(getmetatable(o) == getmetatable(u))
|
|
||||||
assert(getmetatable(o).a[o] == 10-s)
|
|
||||||
s=s+1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
a1, u = nil
|
|
||||||
assert(next(a) ~= nil)
|
|
||||||
collectgarbage()
|
|
||||||
assert(s==11)
|
|
||||||
collectgarbage()
|
|
||||||
assert(next(a) == nil) -- finalized keys are removed in two cycles
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- __gc x weak tables
|
|
||||||
local u = setmetatable({}, {__gc = true})
|
|
||||||
-- __gc metamethod should be collected before running
|
|
||||||
setmetatable(getmetatable(u), {__mode = "v"})
|
|
||||||
getmetatable(u).__gc = function (o) os.exit(1) end -- cannot happen
|
|
||||||
u = nil
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
local u = setmetatable({}, {__gc = true})
|
|
||||||
local m = getmetatable(u)
|
|
||||||
m.x = {[{0}] = 1; [0] = {1}}; setmetatable(m.x, {__mode = "kv"});
|
|
||||||
m.__gc = function (o)
|
|
||||||
assert(next(getmetatable(o).x) == nil)
|
|
||||||
m = 10
|
|
||||||
end
|
|
||||||
u, m = nil
|
|
||||||
collectgarbage()
|
|
||||||
assert(m==10)
|
|
||||||
|
|
||||||
do -- tests for string keys in weak tables
|
|
||||||
collectgarbage(); collectgarbage()
|
|
||||||
local m = collectgarbage("count") -- current memory
|
|
||||||
local a = setmetatable({}, {__mode = "kv"})
|
|
||||||
a[string.rep("a", 2^22)] = 25 -- long string key -> number value
|
|
||||||
a[string.rep("b", 2^22)] = {} -- long string key -> colectable value
|
|
||||||
a[{}] = 14 -- colectable key
|
|
||||||
assert(collectgarbage("count") > m + 2^13) -- 2^13 == 2 * 2^22 in KB
|
|
||||||
collectgarbage()
|
|
||||||
assert(collectgarbage("count") >= m + 2^12 and
|
|
||||||
collectgarbage("count") < m + 2^13) -- one key was collected
|
|
||||||
local k, v = next(a) -- string key with number value preserved
|
|
||||||
assert(k == string.rep("a", 2^22) and v == 25)
|
|
||||||
assert(next(a, k) == nil) -- everything else cleared
|
|
||||||
assert(a[string.rep("b", 2^22)] == undef)
|
|
||||||
a[k] = undef -- erase this last entry
|
|
||||||
k = nil
|
|
||||||
collectgarbage()
|
|
||||||
assert(next(a) == nil)
|
|
||||||
-- make sure will not try to compare with dead key
|
|
||||||
assert(a[string.rep("b", 100)] == undef)
|
|
||||||
assert(collectgarbage("count") <= m + 1) -- eveything collected
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- errors during collection
|
|
||||||
if T then
|
|
||||||
warn("@store")
|
|
||||||
u = setmetatable({}, {__gc = function () error "@expected error" end})
|
|
||||||
u = nil
|
|
||||||
collectgarbage()
|
|
||||||
assert(string.find(_WARN, "@expected error")); _WARN = false
|
|
||||||
warn("@normal")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if not _soft then
|
|
||||||
print("long list")
|
|
||||||
local a = {}
|
|
||||||
for i = 1,200000 do
|
|
||||||
a = {next = a}
|
|
||||||
end
|
|
||||||
a = nil
|
|
||||||
collectgarbage()
|
|
||||||
end
|
|
||||||
|
|
||||||
-- create many threads with self-references and open upvalues
|
|
||||||
print("self-referenced threads")
|
|
||||||
local thread_id = 0
|
|
||||||
local threads = {}
|
|
||||||
|
|
||||||
local function fn (thread)
|
|
||||||
local x = {}
|
|
||||||
threads[thread_id] = function()
|
|
||||||
thread = x
|
|
||||||
end
|
|
||||||
coroutine.yield()
|
|
||||||
end
|
|
||||||
|
|
||||||
while thread_id < 1000 do
|
|
||||||
local thread = coroutine.create(fn)
|
|
||||||
coroutine.resume(thread, thread)
|
|
||||||
thread_id = thread_id + 1
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- Create a closure (function inside 'f') with an upvalue ('param') that
|
|
||||||
-- points (through a table) to the closure itself and to the thread
|
|
||||||
-- ('co' and the initial value of 'param') where closure is running.
|
|
||||||
-- Then, assert that table (and therefore everything else) will be
|
|
||||||
-- collected.
|
|
||||||
do
|
|
||||||
local collected = false -- to detect collection
|
|
||||||
collectgarbage(); collectgarbage("stop")
|
|
||||||
do
|
|
||||||
local function f (param)
|
|
||||||
;(function ()
|
|
||||||
assert(type(f) == 'function' and type(param) == 'thread')
|
|
||||||
param = {param, f}
|
|
||||||
setmetatable(param, {__gc = function () collected = true end})
|
|
||||||
coroutine.yield(100)
|
|
||||||
end)()
|
|
||||||
end
|
|
||||||
local co = coroutine.create(f)
|
|
||||||
assert(coroutine.resume(co, co))
|
|
||||||
end
|
|
||||||
-- Now, thread and closure are not reacheable any more.
|
|
||||||
collectgarbage()
|
|
||||||
assert(collected)
|
|
||||||
collectgarbage("restart")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage"stop"
|
|
||||||
collectgarbage("step", 0) -- steps should not unblock the collector
|
|
||||||
local x = gcinfo()
|
|
||||||
repeat
|
|
||||||
for i=1,1000 do _ENV.a = {} end -- no collection during the loop
|
|
||||||
until gcinfo() > 2 * x
|
|
||||||
collectgarbage"restart"
|
|
||||||
_ENV.a = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if T then -- tests for weird cases collecting upvalues
|
|
||||||
|
|
||||||
local function foo ()
|
|
||||||
local a = {x = 20}
|
|
||||||
coroutine.yield(function () return a.x end) -- will run collector
|
|
||||||
assert(a.x == 20) -- 'a' is 'ok'
|
|
||||||
a = {x = 30} -- create a new object
|
|
||||||
assert(T.gccolor(a) == "white") -- of course it is new...
|
|
||||||
coroutine.yield(100) -- 'a' is still local to this thread
|
|
||||||
end
|
|
||||||
|
|
||||||
local t = setmetatable({}, {__mode = "kv"})
|
|
||||||
collectgarbage(); collectgarbage('stop')
|
|
||||||
-- create coroutine in a weak table, so it will never be marked
|
|
||||||
t.co = coroutine.wrap(foo)
|
|
||||||
local f = t.co() -- create function to access local 'a'
|
|
||||||
T.gcstate("atomic") -- ensure all objects are traversed
|
|
||||||
assert(T.gcstate() == "atomic")
|
|
||||||
assert(t.co() == 100) -- resume coroutine, creating new table for 'a'
|
|
||||||
assert(T.gccolor(t.co) == "white") -- thread was not traversed
|
|
||||||
T.gcstate("pause") -- collect thread, but should mark 'a' before that
|
|
||||||
assert(t.co == nil and f() == 30) -- ensure correct access to 'a'
|
|
||||||
|
|
||||||
collectgarbage("restart")
|
|
||||||
|
|
||||||
-- test barrier in sweep phase (backing userdata to gray)
|
|
||||||
local u = T.newuserdata(0, 1) -- create a userdata
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage"stop"
|
|
||||||
local a = {} -- avoid 'u' as first element in 'allgc'
|
|
||||||
T.gcstate"atomic"
|
|
||||||
T.gcstate"sweepallgc"
|
|
||||||
local x = {}
|
|
||||||
assert(T.gccolor(u) == "black") -- userdata is "old" (black)
|
|
||||||
assert(T.gccolor(x) == "white") -- table is "new" (white)
|
|
||||||
debug.setuservalue(u, x) -- trigger barrier
|
|
||||||
assert(T.gccolor(u) == "gray") -- userdata changed back to gray
|
|
||||||
collectgarbage"restart"
|
|
||||||
|
|
||||||
print"+"
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if T then
|
|
||||||
local debug = require "debug"
|
|
||||||
collectgarbage("stop")
|
|
||||||
local x = T.newuserdata(0)
|
|
||||||
local y = T.newuserdata(0)
|
|
||||||
debug.setmetatable(y, {__gc = nop}) -- bless the new udata before...
|
|
||||||
debug.setmetatable(x, {__gc = nop}) -- ...the old one
|
|
||||||
assert(T.gccolor(y) == "white")
|
|
||||||
T.checkmemory()
|
|
||||||
collectgarbage("restart")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if T then
|
|
||||||
print("emergency collections")
|
|
||||||
collectgarbage()
|
|
||||||
collectgarbage()
|
|
||||||
T.totalmem(T.totalmem() + 200)
|
|
||||||
for i=1,200 do local a = {} end
|
|
||||||
T.totalmem(0)
|
|
||||||
collectgarbage()
|
|
||||||
local t = T.totalmem("table")
|
|
||||||
local a = {{}, {}, {}} -- create 4 new tables
|
|
||||||
assert(T.totalmem("table") == t + 4)
|
|
||||||
t = T.totalmem("function")
|
|
||||||
a = function () end -- create 1 new closure
|
|
||||||
assert(T.totalmem("function") == t + 1)
|
|
||||||
t = T.totalmem("thread")
|
|
||||||
a = coroutine.create(function () end) -- create 1 new coroutine
|
|
||||||
assert(T.totalmem("thread") == t + 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- create an object to be collected when state is closed
|
|
||||||
do
|
|
||||||
local setmetatable,assert,type,print,getmetatable =
|
|
||||||
setmetatable,assert,type,print,getmetatable
|
|
||||||
local tt = {}
|
|
||||||
tt.__gc = function (o)
|
|
||||||
assert(getmetatable(o) == tt)
|
|
||||||
-- create new objects during GC
|
|
||||||
local a = 'xuxu'..(10+3)..'joao', {}
|
|
||||||
___Glob = o -- ressurrect object!
|
|
||||||
setmetatable({}, tt) -- creates a new one with same metatable
|
|
||||||
print(">>> closing state " .. "<<<\n")
|
|
||||||
end
|
|
||||||
local u = setmetatable({}, tt)
|
|
||||||
___Glob = {u} -- avoid object being collected before program end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- create several objects to raise errors when collected while closing state
|
|
||||||
if T then
|
|
||||||
local error, assert, find, warn = error, assert, string.find, warn
|
|
||||||
local n = 0
|
|
||||||
local lastmsg
|
|
||||||
local mt = {__gc = function (o)
|
|
||||||
n = n + 1
|
|
||||||
assert(n == o[1])
|
|
||||||
if n == 1 then
|
|
||||||
_WARN = false
|
|
||||||
elseif n == 2 then
|
|
||||||
assert(find(_WARN, "@expected warning"))
|
|
||||||
lastmsg = _WARN -- get message from previous error (first 'o')
|
|
||||||
else
|
|
||||||
assert(lastmsg == _WARN) -- subsequent error messages are equal
|
|
||||||
end
|
|
||||||
warn("@store"); _WARN = false
|
|
||||||
error"@expected warning"
|
|
||||||
end}
|
|
||||||
for i = 10, 1, -1 do
|
|
||||||
-- create object and preserve it until the end
|
|
||||||
table.insert(___Glob, setmetatable({i}, mt))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- just to make sure
|
|
||||||
assert(collectgarbage'isrunning')
|
|
||||||
|
|
||||||
do -- check that the collector is not reentrant in incremental mode
|
|
||||||
local res = true
|
|
||||||
setmetatable({}, {__gc = function ()
|
|
||||||
res = collectgarbage()
|
|
||||||
end})
|
|
||||||
collectgarbage()
|
|
||||||
assert(not res)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
collectgarbage(oldmode)
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
@ -1,172 +0,0 @@
|
|||||||
-- $Id: testes/gengc.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing generational garbage collection')
|
|
||||||
|
|
||||||
local debug = require"debug"
|
|
||||||
|
|
||||||
assert(collectgarbage("isrunning"))
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
local oldmode = collectgarbage("generational")
|
|
||||||
|
|
||||||
|
|
||||||
-- ensure that table barrier evolves correctly
|
|
||||||
do
|
|
||||||
local U = {}
|
|
||||||
-- full collection makes 'U' old
|
|
||||||
collectgarbage()
|
|
||||||
assert(not T or T.gcage(U) == "old")
|
|
||||||
|
|
||||||
-- U refers to a new table, so it becomes 'touched1'
|
|
||||||
U[1] = {x = {234}}
|
|
||||||
assert(not T or (T.gcage(U) == "touched1" and T.gcage(U[1]) == "new"))
|
|
||||||
|
|
||||||
-- both U and the table survive one more collection
|
|
||||||
collectgarbage("step", 0)
|
|
||||||
assert(not T or (T.gcage(U) == "touched2" and T.gcage(U[1]) == "survival"))
|
|
||||||
|
|
||||||
-- both U and the table survive yet another collection
|
|
||||||
-- now everything is old
|
|
||||||
collectgarbage("step", 0)
|
|
||||||
assert(not T or (T.gcage(U) == "old" and T.gcage(U[1]) == "old1"))
|
|
||||||
|
|
||||||
-- data was not corrupted
|
|
||||||
assert(U[1].x[1] == 234)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
-- ensure that 'firstold1' is corrected when object is removed from
|
|
||||||
-- the 'allgc' list
|
|
||||||
local function foo () end
|
|
||||||
local old = {10}
|
|
||||||
collectgarbage() -- make 'old' old
|
|
||||||
assert(not T or T.gcage(old) == "old")
|
|
||||||
setmetatable(old, {}) -- new table becomes OLD0 (barrier)
|
|
||||||
assert(not T or T.gcage(getmetatable(old)) == "old0")
|
|
||||||
collectgarbage("step", 0) -- new table becomes OLD1 and firstold1
|
|
||||||
assert(not T or T.gcage(getmetatable(old)) == "old1")
|
|
||||||
setmetatable(getmetatable(old), {__gc = foo}) -- get it out of allgc list
|
|
||||||
collectgarbage("step", 0) -- should not seg. fault
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug in 5.4.0
|
|
||||||
-- When an object aged OLD1 is finalized, it is moved from the list
|
|
||||||
-- 'finobj' to the *beginning* of the list 'allgc', but that part of the
|
|
||||||
-- list was not being visited by 'markold'.
|
|
||||||
local A = {}
|
|
||||||
A[1] = false -- old anchor for object
|
|
||||||
|
|
||||||
-- obj finalizer
|
|
||||||
local function gcf (obj)
|
|
||||||
A[1] = obj -- anchor object
|
|
||||||
assert(not T or T.gcage(obj) == "old1")
|
|
||||||
obj = nil -- remove it from the stack
|
|
||||||
collectgarbage("step", 0) -- do a young collection
|
|
||||||
print(getmetatable(A[1]).x) -- metatable was collected
|
|
||||||
end
|
|
||||||
|
|
||||||
collectgarbage() -- make A old
|
|
||||||
local obj = {} -- create a new object
|
|
||||||
collectgarbage("step", 0) -- make it a survival
|
|
||||||
assert(not T or T.gcage(obj) == "survival")
|
|
||||||
setmetatable(obj, {__gc = gcf, x = "+"}) -- create its metatable
|
|
||||||
assert(not T or T.gcage(getmetatable(obj)) == "new")
|
|
||||||
obj = nil -- clear object
|
|
||||||
collectgarbage("step", 0) -- will call obj's finalizer
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- another bug in 5.4.0
|
|
||||||
local old = {10}
|
|
||||||
collectgarbage() -- make 'old' old
|
|
||||||
local co = coroutine.create(
|
|
||||||
function ()
|
|
||||||
local x = nil
|
|
||||||
local f = function ()
|
|
||||||
return x[1]
|
|
||||||
end
|
|
||||||
x = coroutine.yield(f)
|
|
||||||
coroutine.yield()
|
|
||||||
end
|
|
||||||
)
|
|
||||||
local _, f = coroutine.resume(co) -- create closure over 'x' in coroutine
|
|
||||||
collectgarbage("step", 0) -- make upvalue a survival
|
|
||||||
old[1] = {"hello"} -- 'old' go to grayagain as 'touched1'
|
|
||||||
coroutine.resume(co, {123}) -- its value will be new
|
|
||||||
co = nil
|
|
||||||
collectgarbage("step", 0) -- hit the barrier
|
|
||||||
assert(f() == 123 and old[1][1] == "hello")
|
|
||||||
collectgarbage("step", 0) -- run the collector once more
|
|
||||||
-- make sure old[1] was not collected
|
|
||||||
assert(f() == 123 and old[1][1] == "hello")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug introduced in commit 9cf3299fa
|
|
||||||
local t = setmetatable({}, {__mode = "kv"}) -- all-weak table
|
|
||||||
collectgarbage() -- full collection
|
|
||||||
assert(not T or T.gcage(t) == "old")
|
|
||||||
t[1] = {10}
|
|
||||||
assert(not T or (T.gcage(t) == "touched1" and T.gccolor(t) == "gray"))
|
|
||||||
collectgarbage("step", 0) -- minor collection
|
|
||||||
assert(not T or (T.gcage(t) == "touched2" and T.gccolor(t) == "black"))
|
|
||||||
collectgarbage("step", 0) -- minor collection
|
|
||||||
assert(not T or T.gcage(t) == "old") -- t should be black, but it was gray
|
|
||||||
t[1] = {10} -- no barrier here, so t was still old
|
|
||||||
collectgarbage("step", 0) -- minor collection
|
|
||||||
-- t, being old, is ignored by the collection, so it is not cleared
|
|
||||||
assert(t[1] == nil) -- fails with the bug
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if T == nil then
|
|
||||||
(Message or print)('\n >>> testC not active: \z
|
|
||||||
skipping some generational tests <<<\n')
|
|
||||||
print 'OK'
|
|
||||||
return
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- ensure that userdata barrier evolves correctly
|
|
||||||
do
|
|
||||||
local U = T.newuserdata(0, 1)
|
|
||||||
-- full collection makes 'U' old
|
|
||||||
collectgarbage()
|
|
||||||
assert(T.gcage(U) == "old")
|
|
||||||
|
|
||||||
-- U refers to a new table, so it becomes 'touched1'
|
|
||||||
debug.setuservalue(U, {x = {234}})
|
|
||||||
assert(T.gcage(U) == "touched1" and
|
|
||||||
T.gcage(debug.getuservalue(U)) == "new")
|
|
||||||
|
|
||||||
-- both U and the table survive one more collection
|
|
||||||
collectgarbage("step", 0)
|
|
||||||
assert(T.gcage(U) == "touched2" and
|
|
||||||
T.gcage(debug.getuservalue(U)) == "survival")
|
|
||||||
|
|
||||||
-- both U and the table survive yet another collection
|
|
||||||
-- now everything is old
|
|
||||||
collectgarbage("step", 0)
|
|
||||||
assert(T.gcage(U) == "old" and
|
|
||||||
T.gcage(debug.getuservalue(U)) == "old1")
|
|
||||||
|
|
||||||
-- data was not corrupted
|
|
||||||
assert(debug.getuservalue(U).x[1] == 234)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- just to make sure
|
|
||||||
assert(collectgarbage'isrunning')
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
-- just to make sure
|
|
||||||
assert(collectgarbage'isrunning')
|
|
||||||
|
|
||||||
collectgarbage(oldmode)
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
|
|
||||||
@ -1,271 +0,0 @@
|
|||||||
-- $Id: testes/goto.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
local function errmsg (code, m)
|
|
||||||
local st, msg = load(code)
|
|
||||||
assert(not st and string.find(msg, m))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- cannot see label inside block
|
|
||||||
errmsg([[ goto l1; do ::l1:: end ]], "label 'l1'")
|
|
||||||
errmsg([[ do ::l1:: end goto l1; ]], "label 'l1'")
|
|
||||||
|
|
||||||
-- repeated label
|
|
||||||
errmsg([[ ::l1:: ::l1:: ]], "label 'l1'")
|
|
||||||
errmsg([[ ::l1:: do ::l1:: end]], "label 'l1'")
|
|
||||||
|
|
||||||
|
|
||||||
-- undefined label
|
|
||||||
errmsg([[ goto l1; local aa ::l1:: ::l2:: print(3) ]], "local 'aa'")
|
|
||||||
|
|
||||||
-- jumping over variable definition
|
|
||||||
errmsg([[
|
|
||||||
do local bb, cc; goto l1; end
|
|
||||||
local aa
|
|
||||||
::l1:: print(3)
|
|
||||||
]], "local 'aa'")
|
|
||||||
|
|
||||||
-- jumping into a block
|
|
||||||
errmsg([[ do ::l1:: end goto l1 ]], "label 'l1'")
|
|
||||||
errmsg([[ goto l1 do ::l1:: end ]], "label 'l1'")
|
|
||||||
|
|
||||||
-- cannot continue a repeat-until with variables
|
|
||||||
errmsg([[
|
|
||||||
repeat
|
|
||||||
if x then goto cont end
|
|
||||||
local xuxu = 10
|
|
||||||
::cont::
|
|
||||||
until xuxu < x
|
|
||||||
]], "local 'xuxu'")
|
|
||||||
|
|
||||||
-- simple gotos
|
|
||||||
local x
|
|
||||||
do
|
|
||||||
local y = 12
|
|
||||||
goto l1
|
|
||||||
::l2:: x = x + 1; goto l3
|
|
||||||
::l1:: x = y; goto l2
|
|
||||||
end
|
|
||||||
::l3:: ::l3_1:: assert(x == 13)
|
|
||||||
|
|
||||||
|
|
||||||
-- long labels
|
|
||||||
do
|
|
||||||
local prog = [[
|
|
||||||
do
|
|
||||||
local a = 1
|
|
||||||
goto l%sa; a = a + 1
|
|
||||||
::l%sa:: a = a + 10
|
|
||||||
goto l%sb; a = a + 2
|
|
||||||
::l%sb:: a = a + 20
|
|
||||||
return a
|
|
||||||
end
|
|
||||||
]]
|
|
||||||
local label = string.rep("0123456789", 40)
|
|
||||||
prog = string.format(prog, label, label, label, label)
|
|
||||||
assert(assert(load(prog))() == 31)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- ok to jump over local dec. to end of block
|
|
||||||
do
|
|
||||||
goto l1
|
|
||||||
local a = 23
|
|
||||||
x = a
|
|
||||||
::l1::;
|
|
||||||
end
|
|
||||||
|
|
||||||
while true do
|
|
||||||
goto l4
|
|
||||||
goto l1 -- ok to jump over local dec. to end of block
|
|
||||||
goto l1 -- multiple uses of same label
|
|
||||||
local x = 45
|
|
||||||
::l1:: ;;;
|
|
||||||
end
|
|
||||||
::l4:: assert(x == 13)
|
|
||||||
|
|
||||||
if print then
|
|
||||||
goto l1 -- ok to jump over local dec. to end of block
|
|
||||||
error("should not be here")
|
|
||||||
goto l2 -- ok to jump over local dec. to end of block
|
|
||||||
local x
|
|
||||||
::l1:: ; ::l2:: ;;
|
|
||||||
else end
|
|
||||||
|
|
||||||
-- to repeat a label in a different function is OK
|
|
||||||
local function foo ()
|
|
||||||
local a = {}
|
|
||||||
goto l3
|
|
||||||
::l1:: a[#a + 1] = 1; goto l2;
|
|
||||||
::l2:: a[#a + 1] = 2; goto l5;
|
|
||||||
::l3::
|
|
||||||
::l3a:: a[#a + 1] = 3; goto l1;
|
|
||||||
::l4:: a[#a + 1] = 4; goto l6;
|
|
||||||
::l5:: a[#a + 1] = 5; goto l4;
|
|
||||||
::l6:: assert(a[1] == 3 and a[2] == 1 and a[3] == 2 and
|
|
||||||
a[4] == 5 and a[5] == 4)
|
|
||||||
if not a[6] then a[6] = true; goto l3a end -- do it twice
|
|
||||||
end
|
|
||||||
|
|
||||||
::l6:: foo()
|
|
||||||
|
|
||||||
|
|
||||||
do -- bug in 5.2 -> 5.3.2
|
|
||||||
local x
|
|
||||||
::L1::
|
|
||||||
local y -- cannot join this SETNIL with previous one
|
|
||||||
assert(y == nil)
|
|
||||||
y = true
|
|
||||||
if x == nil then
|
|
||||||
x = 1
|
|
||||||
goto L1
|
|
||||||
else
|
|
||||||
x = x + 1
|
|
||||||
end
|
|
||||||
assert(x == 2 and y == true)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- bug in 5.3
|
|
||||||
do
|
|
||||||
local first = true
|
|
||||||
local a = false
|
|
||||||
if true then
|
|
||||||
goto LBL
|
|
||||||
::loop::
|
|
||||||
a = true
|
|
||||||
::LBL::
|
|
||||||
if first then
|
|
||||||
first = false
|
|
||||||
goto loop
|
|
||||||
end
|
|
||||||
end
|
|
||||||
assert(a)
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- compiling infinite loops
|
|
||||||
goto escape -- do not run the infinite loops
|
|
||||||
::a:: goto a
|
|
||||||
::b:: goto c
|
|
||||||
::c:: goto b
|
|
||||||
end
|
|
||||||
::escape::
|
|
||||||
--------------------------------------------------------------------------------
|
|
||||||
-- testing closing of upvalues
|
|
||||||
|
|
||||||
local debug = require 'debug'
|
|
||||||
|
|
||||||
local function foo ()
|
|
||||||
local t = {}
|
|
||||||
do
|
|
||||||
local i = 1
|
|
||||||
local a, b, c, d
|
|
||||||
t[1] = function () return a, b, c, d end
|
|
||||||
::l1::
|
|
||||||
local b
|
|
||||||
do
|
|
||||||
local c
|
|
||||||
t[#t + 1] = function () return a, b, c, d end -- t[2], t[4], t[6]
|
|
||||||
if i > 2 then goto l2 end
|
|
||||||
do
|
|
||||||
local d
|
|
||||||
t[#t + 1] = function () return a, b, c, d end -- t[3], t[5]
|
|
||||||
i = i + 1
|
|
||||||
local a
|
|
||||||
goto l1
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
::l2:: return t
|
|
||||||
end
|
|
||||||
|
|
||||||
local a = foo()
|
|
||||||
assert(#a == 6)
|
|
||||||
|
|
||||||
-- all functions share same 'a'
|
|
||||||
for i = 2, 6 do
|
|
||||||
assert(debug.upvalueid(a[1], 1) == debug.upvalueid(a[i], 1))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- 'b' and 'c' are shared among some of them
|
|
||||||
for i = 2, 6 do
|
|
||||||
-- only a[1] uses external 'b'/'b'
|
|
||||||
assert(debug.upvalueid(a[1], 2) ~= debug.upvalueid(a[i], 2))
|
|
||||||
assert(debug.upvalueid(a[1], 3) ~= debug.upvalueid(a[i], 3))
|
|
||||||
end
|
|
||||||
|
|
||||||
for i = 3, 5, 2 do
|
|
||||||
-- inner functions share 'b'/'c' with previous ones
|
|
||||||
assert(debug.upvalueid(a[i], 2) == debug.upvalueid(a[i - 1], 2))
|
|
||||||
assert(debug.upvalueid(a[i], 3) == debug.upvalueid(a[i - 1], 3))
|
|
||||||
-- but not with next ones
|
|
||||||
assert(debug.upvalueid(a[i], 2) ~= debug.upvalueid(a[i + 1], 2))
|
|
||||||
assert(debug.upvalueid(a[i], 3) ~= debug.upvalueid(a[i + 1], 3))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- only external 'd' is shared
|
|
||||||
for i = 2, 6, 2 do
|
|
||||||
assert(debug.upvalueid(a[1], 4) == debug.upvalueid(a[i], 4))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- internal 'd's are all different
|
|
||||||
for i = 3, 5, 2 do
|
|
||||||
for j = 1, 6 do
|
|
||||||
assert((debug.upvalueid(a[i], 4) == debug.upvalueid(a[j], 4))
|
|
||||||
== (i == j))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
--------------------------------------------------------------------------------
|
|
||||||
-- testing if x goto optimizations
|
|
||||||
|
|
||||||
local function testG (a)
|
|
||||||
if a == 1 then
|
|
||||||
goto l1
|
|
||||||
error("should never be here!")
|
|
||||||
elseif a == 2 then goto l2
|
|
||||||
elseif a == 3 then goto l3
|
|
||||||
elseif a == 4 then
|
|
||||||
goto l1 -- go to inside the block
|
|
||||||
error("should never be here!")
|
|
||||||
::l1:: a = a + 1 -- must go to 'if' end
|
|
||||||
else
|
|
||||||
goto l4
|
|
||||||
::l4a:: a = a * 2; goto l4b
|
|
||||||
error("should never be here!")
|
|
||||||
::l4:: goto l4a
|
|
||||||
error("should never be here!")
|
|
||||||
::l4b::
|
|
||||||
end
|
|
||||||
do return a end
|
|
||||||
::l2:: do return "2" end
|
|
||||||
::l3:: do return "3" end
|
|
||||||
::l1:: return "1"
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(testG(1) == "1")
|
|
||||||
assert(testG(2) == "2")
|
|
||||||
assert(testG(3) == "3")
|
|
||||||
assert(testG(4) == 5)
|
|
||||||
assert(testG(5) == 10)
|
|
||||||
|
|
||||||
do
|
|
||||||
-- if x back goto out of scope of upvalue
|
|
||||||
local X
|
|
||||||
goto L1
|
|
||||||
|
|
||||||
::L2:: goto L3
|
|
||||||
|
|
||||||
::L1:: do
|
|
||||||
local a <close> = setmetatable({}, {__close = function () X = true end})
|
|
||||||
assert(X == nil)
|
|
||||||
if a then goto L2 end -- jumping back out of scope of 'a'
|
|
||||||
end
|
|
||||||
|
|
||||||
::L3:: assert(X == true) -- checks that 'a' was correctly closed
|
|
||||||
end
|
|
||||||
--------------------------------------------------------------------------------
|
|
||||||
|
|
||||||
|
|
||||||
print'OK'
|
|
||||||
@ -1,173 +0,0 @@
|
|||||||
-- $Id: heavy.lua,v 1.7 2017/12/29 15:42:15 roberto Exp $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
local function teststring ()
|
|
||||||
print("creating a string too long")
|
|
||||||
do
|
|
||||||
local a = "x"
|
|
||||||
local st, msg = pcall(function ()
|
|
||||||
while true do
|
|
||||||
a = a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
.. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
|
|
||||||
print(string.format("string with %d bytes", #a))
|
|
||||||
end
|
|
||||||
end)
|
|
||||||
assert(not st and
|
|
||||||
(string.find(msg, "string length overflow") or
|
|
||||||
string.find(msg, "not enough memory")))
|
|
||||||
print("string length overflow with " .. #a * 100)
|
|
||||||
end
|
|
||||||
print('+')
|
|
||||||
end
|
|
||||||
|
|
||||||
local function loadrep (x, what)
|
|
||||||
local p = 1<<20
|
|
||||||
local s = string.rep(x, p)
|
|
||||||
local count = 0
|
|
||||||
local function f()
|
|
||||||
count = count + p
|
|
||||||
if count % (0x80*p) == 0 then
|
|
||||||
io.stderr:write("(", count // 2^20, " M)")
|
|
||||||
end
|
|
||||||
return s
|
|
||||||
end
|
|
||||||
local st, msg = load(f, "=big")
|
|
||||||
print("\nmemory: ", collectgarbage'count' * 1024)
|
|
||||||
msg = string.match(msg, "^[^\n]+") -- get only first line
|
|
||||||
print(string.format("total: 0x%x %s ('%s')", count, what, msg))
|
|
||||||
return st, msg
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function controlstruct ()
|
|
||||||
print("control structure too long")
|
|
||||||
local lim = ((1 << 24) - 2) // 3
|
|
||||||
local s = string.rep("a = a + 1\n", lim)
|
|
||||||
s = "while true do " .. s .. "end"
|
|
||||||
assert(load(s))
|
|
||||||
print("ok with " .. lim .. " lines")
|
|
||||||
lim = lim + 3
|
|
||||||
s = string.rep("a = a + 1\n", lim)
|
|
||||||
s = "while true do " .. s .. "end"
|
|
||||||
local st, msg = load(s)
|
|
||||||
assert(not st and string.find(msg, "too long"))
|
|
||||||
print(msg)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function manylines ()
|
|
||||||
print("loading chunk with too many lines")
|
|
||||||
local st, msg = loadrep("\n", "lines")
|
|
||||||
assert(not st and string.find(msg, "too many lines"))
|
|
||||||
print('+')
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function hugeid ()
|
|
||||||
print("loading chunk with huge identifier")
|
|
||||||
local st, msg = loadrep("a", "chars")
|
|
||||||
assert(not st and
|
|
||||||
(string.find(msg, "lexical element too long") or
|
|
||||||
string.find(msg, "not enough memory")))
|
|
||||||
print('+')
|
|
||||||
end
|
|
||||||
|
|
||||||
function toomanyinst ()
|
|
||||||
print("loading chunk with too many instructions")
|
|
||||||
local st, msg = loadrep("a = 10; ", "instructions")
|
|
||||||
print('+')
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function loadrepfunc (prefix, f)
|
|
||||||
local count = -1
|
|
||||||
local function aux ()
|
|
||||||
count = count + 1
|
|
||||||
if count == 0 then
|
|
||||||
return prefix
|
|
||||||
else
|
|
||||||
if count % (0x100000) == 0 then
|
|
||||||
io.stderr:write("(", count // 2^20, " M)")
|
|
||||||
end
|
|
||||||
return f(count)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
local st, msg = load(aux, "k")
|
|
||||||
print("\nmemory: ", collectgarbage'count' * 1024)
|
|
||||||
msg = string.match(msg, "^[^\n]+") -- get only first line
|
|
||||||
print("expected error: ", msg)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function toomanyconst ()
|
|
||||||
print("loading function with too many constants")
|
|
||||||
loadrepfunc("function foo () return {0,",
|
|
||||||
function (n)
|
|
||||||
-- convert 'n' to a string in the format [["...",]],
|
|
||||||
-- where '...' is a kind of number in base 128
|
|
||||||
-- (in a range that does not include either the double quote
|
|
||||||
-- and the escape.)
|
|
||||||
return string.char(34,
|
|
||||||
((n // 128^0) & 127) + 128,
|
|
||||||
((n // 128^1) & 127) + 128,
|
|
||||||
((n // 128^2) & 127) + 128,
|
|
||||||
((n // 128^3) & 127) + 128,
|
|
||||||
((n // 128^4) & 127) + 128,
|
|
||||||
34, 44)
|
|
||||||
end)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function toomanystr ()
|
|
||||||
local a = {}
|
|
||||||
local st, msg = pcall(function ()
|
|
||||||
for i = 1, math.huge do
|
|
||||||
if i % (0x100000) == 0 then
|
|
||||||
io.stderr:write("(", i // 2^20, " M)")
|
|
||||||
end
|
|
||||||
a[i] = string.pack("I", i)
|
|
||||||
end
|
|
||||||
end)
|
|
||||||
local size = #a
|
|
||||||
a = collectgarbage'count'
|
|
||||||
print("\nmemory:", a * 1024)
|
|
||||||
print("expected error:", msg)
|
|
||||||
print("size:", size)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function toomanyidx ()
|
|
||||||
local a = {}
|
|
||||||
local st, msg = pcall(function ()
|
|
||||||
for i = 1, math.huge do
|
|
||||||
if i % (0x100000) == 0 then
|
|
||||||
io.stderr:write("(", i // 2^20, " M)")
|
|
||||||
end
|
|
||||||
a[i] = i
|
|
||||||
end
|
|
||||||
end)
|
|
||||||
print("\nmemory: ", collectgarbage'count' * 1024)
|
|
||||||
print("expected error: ", msg)
|
|
||||||
print("size:", #a)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
-- teststring()
|
|
||||||
-- controlstruct()
|
|
||||||
-- manylines()
|
|
||||||
-- hugeid()
|
|
||||||
-- toomanyinst()
|
|
||||||
-- toomanyconst()
|
|
||||||
-- toomanystr()
|
|
||||||
toomanyidx()
|
|
||||||
|
|
||||||
print "OK"
|
|
||||||
@ -1,44 +0,0 @@
|
|||||||
#include "lua.h"
|
|
||||||
#include "lauxlib.h"
|
|
||||||
|
|
||||||
static int id (lua_State *L) {
|
|
||||||
return lua_gettop(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const struct luaL_Reg funcs[] = {
|
|
||||||
{"id", id},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/* function used by lib11.c */
|
|
||||||
LUAMOD_API int lib1_export (lua_State *L) {
|
|
||||||
lua_pushstring(L, "exported");
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int onefunction (lua_State *L) {
|
|
||||||
luaL_checkversion(L);
|
|
||||||
lua_settop(L, 2);
|
|
||||||
lua_pushvalue(L, 1);
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int anotherfunc (lua_State *L) {
|
|
||||||
luaL_checkversion(L);
|
|
||||||
lua_pushfstring(L, "%d%%%d\n", (int)lua_tointeger(L, 1),
|
|
||||||
(int)lua_tointeger(L, 2));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_lib1_sub (lua_State *L) {
|
|
||||||
lua_setglobal(L, "y"); /* 2nd arg: extra value (file name) */
|
|
||||||
lua_setglobal(L, "x"); /* 1st arg: module name */
|
|
||||||
luaL_newlib(L, funcs);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,10 +0,0 @@
|
|||||||
#include "lua.h"
|
|
||||||
|
|
||||||
/* function from lib1.c */
|
|
||||||
int lib1_export (lua_State *L);
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_lib11 (lua_State *L) {
|
|
||||||
return lib1_export(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,23 +0,0 @@
|
|||||||
#include "lua.h"
|
|
||||||
#include "lauxlib.h"
|
|
||||||
|
|
||||||
static int id (lua_State *L) {
|
|
||||||
return lua_gettop(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const struct luaL_Reg funcs[] = {
|
|
||||||
{"id", id},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_lib2 (lua_State *L) {
|
|
||||||
lua_settop(L, 2);
|
|
||||||
lua_setglobal(L, "y"); /* y gets 2nd parameter */
|
|
||||||
lua_setglobal(L, "x"); /* x gets 1st parameter */
|
|
||||||
luaL_newlib(L, funcs);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,10 +0,0 @@
|
|||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
int luaopen_lib2 (lua_State *L);
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_lib21 (lua_State *L) {
|
|
||||||
return luaopen_lib2(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,25 +0,0 @@
|
|||||||
#include "lua.h"
|
|
||||||
#include "lauxlib.h"
|
|
||||||
|
|
||||||
static int id (lua_State *L) {
|
|
||||||
lua_pushboolean(L, 1);
|
|
||||||
lua_insert(L, 1);
|
|
||||||
return lua_gettop(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const struct luaL_Reg funcs[] = {
|
|
||||||
{"id", id},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_lib2 (lua_State *L) {
|
|
||||||
lua_settop(L, 2);
|
|
||||||
lua_setglobal(L, "y"); /* y gets 2nd parameter */
|
|
||||||
lua_setglobal(L, "x"); /* x gets 1st parameter */
|
|
||||||
luaL_newlib(L, funcs);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,27 +0,0 @@
|
|||||||
# change this variable to point to the directory with Lua headers
|
|
||||||
# of the version being tested
|
|
||||||
LUA_DIR = ../../
|
|
||||||
|
|
||||||
CC = gcc
|
|
||||||
|
|
||||||
# compilation should generate Dynamic-Link Libraries
|
|
||||||
CFLAGS = -Wall -std=gnu99 -O2 -I$(LUA_DIR) -fPIC -shared
|
|
||||||
|
|
||||||
# libraries used by the tests
|
|
||||||
all: lib1.so lib11.so lib2.so lib21.so lib2-v2.so
|
|
||||||
touch all
|
|
||||||
|
|
||||||
lib1.so: lib1.c $(LUA_DIR)/luaconf.h $(LUA_DIR)/lua.h
|
|
||||||
$(CC) $(CFLAGS) -o lib1.so lib1.c
|
|
||||||
|
|
||||||
lib11.so: lib11.c $(LUA_DIR)/luaconf.h $(LUA_DIR)/lua.h
|
|
||||||
$(CC) $(CFLAGS) -o lib11.so lib11.c
|
|
||||||
|
|
||||||
lib2.so: lib2.c $(LUA_DIR)/luaconf.h $(LUA_DIR)/lua.h
|
|
||||||
$(CC) $(CFLAGS) -o lib2.so lib2.c
|
|
||||||
|
|
||||||
lib21.so: lib21.c $(LUA_DIR)/luaconf.h $(LUA_DIR)/lua.h
|
|
||||||
$(CC) $(CFLAGS) -o lib21.so lib21.c
|
|
||||||
|
|
||||||
lib2-v2.so: lib21.c $(LUA_DIR)/luaconf.h $(LUA_DIR)/lua.h
|
|
||||||
$(CC) $(CFLAGS) -o lib2-v2.so lib22.c
|
|
||||||
@ -1,343 +0,0 @@
|
|||||||
-- $Id: testes/literals.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing scanner')
|
|
||||||
|
|
||||||
local debug = require "debug"
|
|
||||||
|
|
||||||
|
|
||||||
local function dostring (x) return assert(load(x), "")() end
|
|
||||||
|
|
||||||
dostring("x \v\f = \t\r 'a\0a' \v\f\f")
|
|
||||||
assert(x == 'a\0a' and string.len(x) == 3)
|
|
||||||
_G.x = nil
|
|
||||||
|
|
||||||
-- escape sequences
|
|
||||||
assert('\n\"\'\\' == [[
|
|
||||||
|
|
||||||
"'\]])
|
|
||||||
|
|
||||||
assert(string.find("\a\b\f\n\r\t\v", "^%c%c%c%c%c%c%c$"))
|
|
||||||
|
|
||||||
-- assume ASCII just for tests:
|
|
||||||
assert("\09912" == 'c12')
|
|
||||||
assert("\99ab" == 'cab')
|
|
||||||
assert("\099" == '\99')
|
|
||||||
assert("\099\n" == 'c\10')
|
|
||||||
assert('\0\0\0alo' == '\0' .. '\0\0' .. 'alo')
|
|
||||||
|
|
||||||
assert(010 .. 020 .. -030 == "1020-30")
|
|
||||||
|
|
||||||
-- hexadecimal escapes
|
|
||||||
assert("\x00\x05\x10\x1f\x3C\xfF\xe8" == "\0\5\16\31\60\255\232")
|
|
||||||
|
|
||||||
local function lexstring (x, y, n)
|
|
||||||
local f = assert(load('return ' .. x ..
|
|
||||||
', require"debug".getinfo(1).currentline', ''))
|
|
||||||
local s, l = f()
|
|
||||||
assert(s == y and l == n)
|
|
||||||
end
|
|
||||||
|
|
||||||
lexstring("'abc\\z \n efg'", "abcefg", 2)
|
|
||||||
lexstring("'abc\\z \n\n\n'", "abc", 4)
|
|
||||||
lexstring("'\\z \n\t\f\v\n'", "", 3)
|
|
||||||
lexstring("[[\nalo\nalo\n\n]]", "alo\nalo\n\n", 5)
|
|
||||||
lexstring("[[\nalo\ralo\n\n]]", "alo\nalo\n\n", 5)
|
|
||||||
lexstring("[[\nalo\ralo\r\n]]", "alo\nalo\n", 4)
|
|
||||||
lexstring("[[\ralo\n\ralo\r\n]]", "alo\nalo\n", 4)
|
|
||||||
lexstring("[[alo]\n]alo]]", "alo]\n]alo", 2)
|
|
||||||
|
|
||||||
assert("abc\z
|
|
||||||
def\z
|
|
||||||
ghi\z
|
|
||||||
" == 'abcdefghi')
|
|
||||||
|
|
||||||
|
|
||||||
-- UTF-8 sequences
|
|
||||||
assert("\u{0}\u{00000000}\x00\0" == string.char(0, 0, 0, 0))
|
|
||||||
|
|
||||||
-- limits for 1-byte sequences
|
|
||||||
assert("\u{0}\u{7F}" == "\x00\x7F")
|
|
||||||
|
|
||||||
-- limits for 2-byte sequences
|
|
||||||
assert("\u{80}\u{7FF}" == "\xC2\x80\xDF\xBF")
|
|
||||||
|
|
||||||
-- limits for 3-byte sequences
|
|
||||||
assert("\u{800}\u{FFFF}" == "\xE0\xA0\x80\xEF\xBF\xBF")
|
|
||||||
|
|
||||||
-- limits for 4-byte sequences
|
|
||||||
assert("\u{10000}\u{1FFFFF}" == "\xF0\x90\x80\x80\xF7\xBF\xBF\xBF")
|
|
||||||
|
|
||||||
-- limits for 5-byte sequences
|
|
||||||
assert("\u{200000}\u{3FFFFFF}" == "\xF8\x88\x80\x80\x80\xFB\xBF\xBF\xBF\xBF")
|
|
||||||
|
|
||||||
-- limits for 6-byte sequences
|
|
||||||
assert("\u{4000000}\u{7FFFFFFF}" ==
|
|
||||||
"\xFC\x84\x80\x80\x80\x80\xFD\xBF\xBF\xBF\xBF\xBF")
|
|
||||||
|
|
||||||
|
|
||||||
-- Error in escape sequences
|
|
||||||
local function lexerror (s, err)
|
|
||||||
local st, msg = load('return ' .. s, '')
|
|
||||||
if err ~= '<eof>' then err = err .. "'" end
|
|
||||||
assert(not st and string.find(msg, "near .-" .. err))
|
|
||||||
end
|
|
||||||
|
|
||||||
lexerror([["abc\x"]], [[\x"]])
|
|
||||||
lexerror([["abc\x]], [[\x]])
|
|
||||||
lexerror([["\x]], [[\x]])
|
|
||||||
lexerror([["\x5"]], [[\x5"]])
|
|
||||||
lexerror([["\x5]], [[\x5]])
|
|
||||||
lexerror([["\xr"]], [[\xr]])
|
|
||||||
lexerror([["\xr]], [[\xr]])
|
|
||||||
lexerror([["\x.]], [[\x.]])
|
|
||||||
lexerror([["\x8%"]], [[\x8%%]])
|
|
||||||
lexerror([["\xAG]], [[\xAG]])
|
|
||||||
lexerror([["\g"]], [[\g]])
|
|
||||||
lexerror([["\g]], [[\g]])
|
|
||||||
lexerror([["\."]], [[\%.]])
|
|
||||||
|
|
||||||
lexerror([["\999"]], [[\999"]])
|
|
||||||
lexerror([["xyz\300"]], [[\300"]])
|
|
||||||
lexerror([[" \256"]], [[\256"]])
|
|
||||||
|
|
||||||
-- errors in UTF-8 sequences
|
|
||||||
lexerror([["abc\u{100000000}"]], [[abc\u{100000000]]) -- too large
|
|
||||||
lexerror([["abc\u11r"]], [[abc\u1]]) -- missing '{'
|
|
||||||
lexerror([["abc\u"]], [[abc\u"]]) -- missing '{'
|
|
||||||
lexerror([["abc\u{11r"]], [[abc\u{11r]]) -- missing '}'
|
|
||||||
lexerror([["abc\u{11"]], [[abc\u{11"]]) -- missing '}'
|
|
||||||
lexerror([["abc\u{11]], [[abc\u{11]]) -- missing '}'
|
|
||||||
lexerror([["abc\u{r"]], [[abc\u{r]]) -- no digits
|
|
||||||
|
|
||||||
-- unfinished strings
|
|
||||||
lexerror("[=[alo]]", "<eof>")
|
|
||||||
lexerror("[=[alo]=", "<eof>")
|
|
||||||
lexerror("[=[alo]", "<eof>")
|
|
||||||
lexerror("'alo", "<eof>")
|
|
||||||
lexerror("'alo \\z \n\n", "<eof>")
|
|
||||||
lexerror("'alo \\z", "<eof>")
|
|
||||||
lexerror([['alo \98]], "<eof>")
|
|
||||||
|
|
||||||
-- valid characters in variable names
|
|
||||||
for i = 0, 255 do
|
|
||||||
local s = string.char(i)
|
|
||||||
assert(not string.find(s, "[a-zA-Z_]") == not load(s .. "=1", ""))
|
|
||||||
assert(not string.find(s, "[a-zA-Z_0-9]") ==
|
|
||||||
not load("a" .. s .. "1 = 1", ""))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- long variable names
|
|
||||||
|
|
||||||
local var1 = string.rep('a', 15000) .. '1'
|
|
||||||
local var2 = string.rep('a', 15000) .. '2'
|
|
||||||
local prog = string.format([[
|
|
||||||
%s = 5
|
|
||||||
%s = %s + 1
|
|
||||||
return function () return %s - %s end
|
|
||||||
]], var1, var2, var1, var1, var2)
|
|
||||||
local f = dostring(prog)
|
|
||||||
assert(_G[var1] == 5 and _G[var2] == 6 and f() == -1)
|
|
||||||
_G[var1], _G[var2] = nil
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
-- escapes --
|
|
||||||
assert("\n\t" == [[
|
|
||||||
|
|
||||||
]])
|
|
||||||
assert([[
|
|
||||||
|
|
||||||
$debug]] == "\n $debug")
|
|
||||||
assert([[ [ ]] ~= [[ ] ]])
|
|
||||||
-- long strings --
|
|
||||||
local b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789"
|
|
||||||
assert(string.len(b) == 960)
|
|
||||||
prog = [=[
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local a1 = [["this is a 'string' with several 'quotes'"]]
|
|
||||||
local a2 = "'quotes'"
|
|
||||||
|
|
||||||
assert(string.find(a1, a2) == 34)
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
a1 = [==[temp = [[an arbitrary value]]; ]==]
|
|
||||||
assert(load(a1))()
|
|
||||||
assert(temp == 'an arbitrary value')
|
|
||||||
_G.temp = nil
|
|
||||||
-- long strings --
|
|
||||||
local b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789"
|
|
||||||
assert(string.len(b) == 960)
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local a = [[00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
00123456789012345678901234567890123456789123456789012345678901234567890123456789
|
|
||||||
]]
|
|
||||||
assert(string.len(a) == 1863)
|
|
||||||
assert(string.sub(a, 1, 40) == string.sub(b, 1, 40))
|
|
||||||
x = 1
|
|
||||||
]=]
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
_G.x = nil
|
|
||||||
dostring(prog)
|
|
||||||
assert(x)
|
|
||||||
_G.x = nil
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
do -- reuse of long strings
|
|
||||||
|
|
||||||
-- get the address of a string
|
|
||||||
local function getadd (s) return string.format("%p", s) end
|
|
||||||
|
|
||||||
local s1 <const> = "01234567890123456789012345678901234567890123456789"
|
|
||||||
local s2 <const> = "01234567890123456789012345678901234567890123456789"
|
|
||||||
local s3 = "01234567890123456789012345678901234567890123456789"
|
|
||||||
local function foo() return s1 end
|
|
||||||
local function foo1() return s3 end
|
|
||||||
local function foo2()
|
|
||||||
return "01234567890123456789012345678901234567890123456789"
|
|
||||||
end
|
|
||||||
local a1 = getadd(s1)
|
|
||||||
assert(a1 == getadd(s2))
|
|
||||||
assert(a1 == getadd(foo()))
|
|
||||||
assert(a1 == getadd(foo1()))
|
|
||||||
assert(a1 == getadd(foo2()))
|
|
||||||
|
|
||||||
local sd = "0123456789" .. "0123456789012345678901234567890123456789"
|
|
||||||
assert(sd == s1 and getadd(sd) ~= a1)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing line ends
|
|
||||||
prog = [[
|
|
||||||
local a = 1 -- a comment
|
|
||||||
local b = 2
|
|
||||||
|
|
||||||
|
|
||||||
x = [=[
|
|
||||||
hi
|
|
||||||
]=]
|
|
||||||
y = "\
|
|
||||||
hello\r\n\
|
|
||||||
"
|
|
||||||
return require"debug".getinfo(1).currentline
|
|
||||||
]]
|
|
||||||
|
|
||||||
for _, n in pairs{"\n", "\r", "\n\r", "\r\n"} do
|
|
||||||
local prog, nn = string.gsub(prog, "\n", n)
|
|
||||||
assert(dostring(prog) == nn)
|
|
||||||
assert(_G.x == "hi\n" and _G.y == "\nhello\r\n\n")
|
|
||||||
end
|
|
||||||
_G.x, _G.y = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- testing comments and strings with long brackets
|
|
||||||
local a = [==[]=]==]
|
|
||||||
assert(a == "]=")
|
|
||||||
|
|
||||||
a = [==[[===[[=[]]=][====[]]===]===]==]
|
|
||||||
assert(a == "[===[[=[]]=][====[]]===]===")
|
|
||||||
|
|
||||||
a = [====[[===[[=[]]=][====[]]===]===]====]
|
|
||||||
assert(a == "[===[[=[]]=][====[]]===]===")
|
|
||||||
|
|
||||||
a = [=[]]]]]]]]]=]
|
|
||||||
assert(a == "]]]]]]]]")
|
|
||||||
|
|
||||||
|
|
||||||
--[===[
|
|
||||||
x y z [==[ blu foo
|
|
||||||
]==
|
|
||||||
]
|
|
||||||
]=]==]
|
|
||||||
error error]=]===]
|
|
||||||
|
|
||||||
-- generate all strings of four of these chars
|
|
||||||
local x = {"=", "[", "]", "\n"}
|
|
||||||
local len = 4
|
|
||||||
local function gen (c, n)
|
|
||||||
if n==0 then coroutine.yield(c)
|
|
||||||
else
|
|
||||||
for _, a in pairs(x) do
|
|
||||||
gen(c..a, n-1)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for s in coroutine.wrap(function () gen("", len) end) do
|
|
||||||
assert(s == load("return [====[\n"..s.."]====]", "")())
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing decimal point locale
|
|
||||||
if os.setlocale("pt_BR") or os.setlocale("ptb") then
|
|
||||||
assert(tonumber("3,4") == 3.4 and tonumber"3.4" == 3.4)
|
|
||||||
assert(tonumber(" -.4 ") == -0.4)
|
|
||||||
assert(tonumber(" +0x.41 ") == 0X0.41)
|
|
||||||
assert(not load("a = (3,4)"))
|
|
||||||
assert(assert(load("return 3.4"))() == 3.4)
|
|
||||||
assert(assert(load("return .4,3"))() == .4)
|
|
||||||
assert(assert(load("return 4."))() == 4.)
|
|
||||||
assert(assert(load("return 4.+.5"))() == 4.5)
|
|
||||||
|
|
||||||
assert(" 0x.1 " + " 0x,1" + "-0X.1\t" == 0x0.1)
|
|
||||||
|
|
||||||
assert(not tonumber"inf" and not tonumber"NAN")
|
|
||||||
|
|
||||||
assert(assert(load(string.format("return %q", 4.51)))() == 4.51)
|
|
||||||
|
|
||||||
local a,b = load("return 4.5.")
|
|
||||||
assert(string.find(b, "'4%.5%.'"))
|
|
||||||
|
|
||||||
assert(os.setlocale("C"))
|
|
||||||
else
|
|
||||||
(Message or print)(
|
|
||||||
'\n >>> pt_BR locale not available: skipping decimal point tests <<<\n')
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing %q x line ends
|
|
||||||
local s = "a string with \r and \n and \r\n and \n\r"
|
|
||||||
local c = string.format("return %q", s)
|
|
||||||
assert(assert(load(c))() == s)
|
|
||||||
|
|
||||||
-- testing errors
|
|
||||||
assert(not load"a = 'non-ending string")
|
|
||||||
assert(not load"a = 'non-ending string\n'")
|
|
||||||
assert(not load"a = '\\345'")
|
|
||||||
assert(not load"a = [=x]")
|
|
||||||
|
|
||||||
local function malformednum (n, exp)
|
|
||||||
local s, msg = load("return " .. n)
|
|
||||||
assert(not s and string.find(msg, exp))
|
|
||||||
end
|
|
||||||
|
|
||||||
malformednum("0xe-", "near <eof>")
|
|
||||||
malformednum("0xep-p", "malformed number")
|
|
||||||
malformednum("1print()", "malformed number")
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,151 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ltests.h $
|
|
||||||
** Internal Header for Debugging of the Lua Implementation
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef ltests_h
|
|
||||||
#define ltests_h
|
|
||||||
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
/* test Lua with compatibility code */
|
|
||||||
#define LUA_COMPAT_MATHLIB
|
|
||||||
#define LUA_COMPAT_LT_LE
|
|
||||||
|
|
||||||
|
|
||||||
#define LUA_DEBUG
|
|
||||||
|
|
||||||
|
|
||||||
/* turn on assertions */
|
|
||||||
#define LUAI_ASSERT
|
|
||||||
|
|
||||||
|
|
||||||
/* to avoid warnings, and to make sure value is really unused */
|
|
||||||
#define UNUSED(x) (x=0, (void)(x))
|
|
||||||
|
|
||||||
|
|
||||||
/* test for sizes in 'l_sprintf' (make sure whole buffer is available) */
|
|
||||||
#undef l_sprintf
|
|
||||||
#if !defined(LUA_USE_C89)
|
|
||||||
#define l_sprintf(s,sz,f,i) (memset(s,0xAB,sz), snprintf(s,sz,f,i))
|
|
||||||
#else
|
|
||||||
#define l_sprintf(s,sz,f,i) (memset(s,0xAB,sz), sprintf(s,f,i))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/* get a chance to test code without jump tables */
|
|
||||||
#define LUA_USE_JUMPTABLE 0
|
|
||||||
|
|
||||||
|
|
||||||
/* use 32-bit integers in random generator */
|
|
||||||
#define LUA_RAND32
|
|
||||||
|
|
||||||
|
|
||||||
/* memory-allocator control variables */
|
|
||||||
typedef struct Memcontrol {
|
|
||||||
int failnext;
|
|
||||||
unsigned long numblocks;
|
|
||||||
unsigned long total;
|
|
||||||
unsigned long maxmem;
|
|
||||||
unsigned long memlimit;
|
|
||||||
unsigned long countlimit;
|
|
||||||
unsigned long objcount[LUA_NUMTYPES];
|
|
||||||
} Memcontrol;
|
|
||||||
|
|
||||||
LUA_API Memcontrol l_memcontrol;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** generic variable for debug tricks
|
|
||||||
*/
|
|
||||||
extern void *l_Trick;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Function to traverse and check all memory used by Lua
|
|
||||||
*/
|
|
||||||
LUAI_FUNC int lua_checkmemory (lua_State *L);
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Function to print an object GC-friendly
|
|
||||||
*/
|
|
||||||
struct GCObject;
|
|
||||||
LUAI_FUNC void lua_printobj (lua_State *L, struct GCObject *o);
|
|
||||||
|
|
||||||
|
|
||||||
/* test for lock/unlock */
|
|
||||||
|
|
||||||
struct L_EXTRA { int lock; int *plock; };
|
|
||||||
#undef LUA_EXTRASPACE
|
|
||||||
#define LUA_EXTRASPACE sizeof(struct L_EXTRA)
|
|
||||||
#define getlock(l) cast(struct L_EXTRA*, lua_getextraspace(l))
|
|
||||||
#define luai_userstateopen(l) \
|
|
||||||
(getlock(l)->lock = 0, getlock(l)->plock = &(getlock(l)->lock))
|
|
||||||
#define luai_userstateclose(l) \
|
|
||||||
lua_assert(getlock(l)->lock == 1 && getlock(l)->plock == &(getlock(l)->lock))
|
|
||||||
#define luai_userstatethread(l,l1) \
|
|
||||||
lua_assert(getlock(l1)->plock == getlock(l)->plock)
|
|
||||||
#define luai_userstatefree(l,l1) \
|
|
||||||
lua_assert(getlock(l)->plock == getlock(l1)->plock)
|
|
||||||
#define lua_lock(l) lua_assert((*getlock(l)->plock)++ == 0)
|
|
||||||
#define lua_unlock(l) lua_assert(--(*getlock(l)->plock) == 0)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int luaB_opentests (lua_State *L);
|
|
||||||
|
|
||||||
LUA_API void *debug_realloc (void *ud, void *block,
|
|
||||||
size_t osize, size_t nsize);
|
|
||||||
|
|
||||||
#if defined(lua_c)
|
|
||||||
#define luaL_newstate() lua_newstate(debug_realloc, &l_memcontrol)
|
|
||||||
#define luaL_openlibs(L) \
|
|
||||||
{ (luaL_openlibs)(L); \
|
|
||||||
luaL_requiref(L, "T", luaB_opentests, 1); \
|
|
||||||
lua_pop(L, 1); }
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* change some sizes to give some bugs a chance */
|
|
||||||
|
|
||||||
#undef LUAL_BUFFERSIZE
|
|
||||||
#define LUAL_BUFFERSIZE 23
|
|
||||||
#define MINSTRTABSIZE 2
|
|
||||||
#define MAXIWTHABS 3
|
|
||||||
|
|
||||||
#define STRCACHE_N 23
|
|
||||||
#define STRCACHE_M 5
|
|
||||||
|
|
||||||
#undef LUAI_USER_ALIGNMENT_T
|
|
||||||
#define LUAI_USER_ALIGNMENT_T union { char b[sizeof(void*) * 8]; }
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** This one is not compatible with tests for opcode optimizations,
|
|
||||||
** as it blocks some optimizations
|
|
||||||
#define MAXINDEXRK 0
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/* make stack-overflow tests run faster */
|
|
||||||
#undef LUAI_MAXSTACK
|
|
||||||
#define LUAI_MAXSTACK 50000
|
|
||||||
|
|
||||||
|
|
||||||
/* test mode uses more stack space */
|
|
||||||
#undef LUAI_MAXCCALLS
|
|
||||||
#define LUAI_MAXCCALLS 180
|
|
||||||
|
|
||||||
|
|
||||||
/* force Lua to use its own implementations */
|
|
||||||
#undef lua_strx2number
|
|
||||||
#undef lua_number2strx
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,553 +0,0 @@
|
|||||||
# testing special comment on first line
|
|
||||||
-- $Id: testes/main.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
-- most (all?) tests here assume a reasonable "Unix-like" shell
|
|
||||||
if _port then return end
|
|
||||||
|
|
||||||
-- use only "double quotes" inside shell scripts (better change to
|
|
||||||
-- run on Windows)
|
|
||||||
|
|
||||||
|
|
||||||
print ("testing stand-alone interpreter")
|
|
||||||
|
|
||||||
assert(os.execute()) -- machine has a system command
|
|
||||||
|
|
||||||
local arg = arg or ARG
|
|
||||||
|
|
||||||
local prog = os.tmpname()
|
|
||||||
local otherprog = os.tmpname()
|
|
||||||
local out = os.tmpname()
|
|
||||||
|
|
||||||
local progname
|
|
||||||
do
|
|
||||||
local i = 0
|
|
||||||
while arg[i] do i=i-1 end
|
|
||||||
progname = arg[i+1]
|
|
||||||
end
|
|
||||||
print("progname: "..progname)
|
|
||||||
|
|
||||||
local prepfile = function (s, p)
|
|
||||||
p = p or prog
|
|
||||||
io.output(p)
|
|
||||||
io.write(s)
|
|
||||||
assert(io.close())
|
|
||||||
end
|
|
||||||
|
|
||||||
local function getoutput ()
|
|
||||||
io.input(out)
|
|
||||||
local t = io.read("a")
|
|
||||||
io.input():close()
|
|
||||||
assert(os.remove(out))
|
|
||||||
return t
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checkprogout (s)
|
|
||||||
-- expected result must end with new line
|
|
||||||
assert(string.sub(s, -1) == "\n")
|
|
||||||
local t = getoutput()
|
|
||||||
for line in string.gmatch(s, ".-\n") do
|
|
||||||
assert(string.find(t, line, 1, true))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function checkout (s)
|
|
||||||
local t = getoutput()
|
|
||||||
if s ~= t then print(string.format("'%s' - '%s'\n", s, t)) end
|
|
||||||
assert(s == t)
|
|
||||||
return t
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function RUN (p, ...)
|
|
||||||
p = string.gsub(p, "lua", '"'..progname..'"', 1)
|
|
||||||
local s = string.format(p, ...)
|
|
||||||
assert(os.execute(s))
|
|
||||||
end
|
|
||||||
|
|
||||||
local function NoRun (msg, p, ...)
|
|
||||||
p = string.gsub(p, "lua", '"'..progname..'"', 1)
|
|
||||||
local s = string.format(p, ...)
|
|
||||||
s = string.format("%s 2> %s", s, out) -- will send error to 'out'
|
|
||||||
assert(not os.execute(s))
|
|
||||||
assert(string.find(getoutput(), msg, 1, true)) -- check error message
|
|
||||||
end
|
|
||||||
|
|
||||||
RUN('lua -v')
|
|
||||||
|
|
||||||
print(string.format("(temporary program file used in these tests: %s)", prog))
|
|
||||||
|
|
||||||
-- running stdin as a file
|
|
||||||
prepfile""
|
|
||||||
RUN('lua - < %s > %s', prog, out)
|
|
||||||
checkout("")
|
|
||||||
|
|
||||||
prepfile[[
|
|
||||||
print(
|
|
||||||
1, a
|
|
||||||
)
|
|
||||||
]]
|
|
||||||
RUN('lua - < %s > %s', prog, out)
|
|
||||||
checkout("1\tnil\n")
|
|
||||||
|
|
||||||
RUN('echo "print(10)\nprint(2)\n" | lua > %s', out)
|
|
||||||
checkout("10\n2\n")
|
|
||||||
|
|
||||||
|
|
||||||
-- testing BOM
|
|
||||||
prepfile("\xEF\xBB\xBF")
|
|
||||||
RUN('lua %s > %s', prog, out)
|
|
||||||
checkout("")
|
|
||||||
|
|
||||||
prepfile("\xEF\xBB\xBFprint(3)")
|
|
||||||
RUN('lua %s > %s', prog, out)
|
|
||||||
checkout("3\n")
|
|
||||||
|
|
||||||
prepfile("\xEF\xBB\xBF# comment!!\nprint(3)")
|
|
||||||
RUN('lua %s > %s', prog, out)
|
|
||||||
checkout("3\n")
|
|
||||||
|
|
||||||
-- bad BOMs
|
|
||||||
prepfile("\xEF")
|
|
||||||
NoRun("unexpected symbol", 'lua %s > %s', prog, out)
|
|
||||||
|
|
||||||
prepfile("\xEF\xBB")
|
|
||||||
NoRun("unexpected symbol", 'lua %s > %s', prog, out)
|
|
||||||
|
|
||||||
prepfile("\xEFprint(3)")
|
|
||||||
NoRun("unexpected symbol", 'lua %s > %s', prog, out)
|
|
||||||
|
|
||||||
prepfile("\xEF\xBBprint(3)")
|
|
||||||
NoRun("unexpected symbol", 'lua %s > %s', prog, out)
|
|
||||||
|
|
||||||
|
|
||||||
-- test option '-'
|
|
||||||
RUN('echo "print(arg[1])" | lua - -h > %s', out)
|
|
||||||
checkout("-h\n")
|
|
||||||
|
|
||||||
-- test environment variables used by Lua
|
|
||||||
|
|
||||||
prepfile("print(package.path)")
|
|
||||||
|
|
||||||
-- test LUA_PATH
|
|
||||||
RUN('env LUA_INIT= LUA_PATH=x lua %s > %s', prog, out)
|
|
||||||
checkout("x\n")
|
|
||||||
|
|
||||||
-- test LUA_PATH_version
|
|
||||||
RUN('env LUA_INIT= LUA_PATH_5_4=y LUA_PATH=x lua %s > %s', prog, out)
|
|
||||||
checkout("y\n")
|
|
||||||
|
|
||||||
-- test LUA_CPATH
|
|
||||||
prepfile("print(package.cpath)")
|
|
||||||
RUN('env LUA_INIT= LUA_CPATH=xuxu lua %s > %s', prog, out)
|
|
||||||
checkout("xuxu\n")
|
|
||||||
|
|
||||||
-- test LUA_CPATH_version
|
|
||||||
RUN('env LUA_INIT= LUA_CPATH_5_4=yacc LUA_CPATH=x lua %s > %s', prog, out)
|
|
||||||
checkout("yacc\n")
|
|
||||||
|
|
||||||
-- test LUA_INIT (and its access to 'arg' table)
|
|
||||||
prepfile("print(X)")
|
|
||||||
RUN('env LUA_INIT="X=tonumber(arg[1])" lua %s 3.2 > %s', prog, out)
|
|
||||||
checkout("3.2\n")
|
|
||||||
|
|
||||||
-- test LUA_INIT_version
|
|
||||||
prepfile("print(X)")
|
|
||||||
RUN('env LUA_INIT_5_4="X=10" LUA_INIT="X=3" lua %s > %s', prog, out)
|
|
||||||
checkout("10\n")
|
|
||||||
|
|
||||||
-- test LUA_INIT for files
|
|
||||||
prepfile("x = x or 10; print(x); x = x + 1")
|
|
||||||
RUN('env LUA_INIT="@%s" lua %s > %s', prog, prog, out)
|
|
||||||
checkout("10\n11\n")
|
|
||||||
|
|
||||||
-- test errors in LUA_INIT
|
|
||||||
NoRun('LUA_INIT:1: msg', 'env LUA_INIT="error(\'msg\')" lua')
|
|
||||||
|
|
||||||
-- test option '-E'
|
|
||||||
local defaultpath, defaultCpath
|
|
||||||
|
|
||||||
do
|
|
||||||
prepfile("print(package.path, package.cpath)")
|
|
||||||
RUN('env LUA_INIT="error(10)" LUA_PATH=xxx LUA_CPATH=xxx lua -E %s > %s',
|
|
||||||
prog, out)
|
|
||||||
local output = getoutput()
|
|
||||||
defaultpath = string.match(output, "^(.-)\t")
|
|
||||||
defaultCpath = string.match(output, "\t(.-)$")
|
|
||||||
|
|
||||||
-- running with an empty environment
|
|
||||||
RUN('env -i lua %s > %s', prog, out)
|
|
||||||
local out = getoutput()
|
|
||||||
assert(defaultpath == string.match(output, "^(.-)\t"))
|
|
||||||
assert(defaultCpath == string.match(output, "\t(.-)$"))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- paths did not change
|
|
||||||
assert(not string.find(defaultpath, "xxx") and
|
|
||||||
string.find(defaultpath, "lua") and
|
|
||||||
not string.find(defaultCpath, "xxx") and
|
|
||||||
string.find(defaultCpath, "lua"))
|
|
||||||
|
|
||||||
|
|
||||||
-- test replacement of ';;' to default path
|
|
||||||
local function convert (p)
|
|
||||||
prepfile("print(package.path)")
|
|
||||||
RUN('env LUA_PATH="%s" lua %s > %s', p, prog, out)
|
|
||||||
local expected = getoutput()
|
|
||||||
expected = string.sub(expected, 1, -2) -- cut final end of line
|
|
||||||
if string.find(p, ";;") then
|
|
||||||
p = string.gsub(p, ";;", ";"..defaultpath..";")
|
|
||||||
p = string.gsub(p, "^;", "") -- remove ';' at the beginning
|
|
||||||
p = string.gsub(p, ";$", "") -- remove ';' at the end
|
|
||||||
end
|
|
||||||
assert(p == expected)
|
|
||||||
end
|
|
||||||
|
|
||||||
convert(";")
|
|
||||||
convert(";;")
|
|
||||||
convert("a;;b")
|
|
||||||
convert(";;b")
|
|
||||||
convert("a;;")
|
|
||||||
convert("a;b;;c")
|
|
||||||
|
|
||||||
|
|
||||||
-- test -l over multiple libraries
|
|
||||||
prepfile("print(1); a=2; return {x=15}")
|
|
||||||
prepfile(("print(a); print(_G['%s'].x)"):format(prog), otherprog)
|
|
||||||
RUN('env LUA_PATH="?;;" lua -l %s -l%s -lstring -l io %s > %s', prog, otherprog, otherprog, out)
|
|
||||||
checkout("1\n2\n15\n2\n15\n")
|
|
||||||
|
|
||||||
-- test explicit global names in -l
|
|
||||||
prepfile("print(str.upper'alo alo', m.max(10, 20))")
|
|
||||||
RUN("lua -l 'str=string' '-lm=math' -e 'print(m.sin(0))' %s > %s", prog, out)
|
|
||||||
checkout("0.0\nALO ALO\t20\n")
|
|
||||||
|
|
||||||
-- test 'arg' table
|
|
||||||
local a = [[
|
|
||||||
assert(#arg == 3 and arg[1] == 'a' and
|
|
||||||
arg[2] == 'b' and arg[3] == 'c')
|
|
||||||
assert(arg[-1] == '--' and arg[-2] == "-e " and arg[-3] == '%s')
|
|
||||||
assert(arg[4] == undef and arg[-4] == undef)
|
|
||||||
local a, b, c = ...
|
|
||||||
assert(... == 'a' and a == 'a' and b == 'b' and c == 'c')
|
|
||||||
]]
|
|
||||||
a = string.format(a, progname)
|
|
||||||
prepfile(a)
|
|
||||||
RUN('lua "-e " -- %s a b c', prog) -- "-e " runs an empty command
|
|
||||||
|
|
||||||
-- test 'arg' availability in libraries
|
|
||||||
prepfile"assert(arg)"
|
|
||||||
prepfile("assert(arg)", otherprog)
|
|
||||||
RUN('env LUA_PATH="?;;" lua -l%s - < %s', prog, otherprog)
|
|
||||||
|
|
||||||
-- test messing up the 'arg' table
|
|
||||||
RUN('echo "print(...)" | lua -e "arg[1] = 100" - > %s', out)
|
|
||||||
checkout("100\n")
|
|
||||||
NoRun("'arg' is not a table", 'echo "" | lua -e "arg = 1" -')
|
|
||||||
|
|
||||||
-- test error in 'print'
|
|
||||||
RUN('echo 10 | lua -e "print=nil" -i > /dev/null 2> %s', out)
|
|
||||||
assert(string.find(getoutput(), "error calling 'print'"))
|
|
||||||
|
|
||||||
-- test 'debug.debug'
|
|
||||||
RUN('echo "io.stderr:write(1000)\ncont" | lua -e "require\'debug\'.debug()" 2> %s', out)
|
|
||||||
checkout("lua_debug> 1000lua_debug> ")
|
|
||||||
|
|
||||||
|
|
||||||
print("testing warnings")
|
|
||||||
|
|
||||||
-- no warnings by default
|
|
||||||
RUN('echo "io.stderr:write(1); warn[[XXX]]" | lua 2> %s', out)
|
|
||||||
checkout("1")
|
|
||||||
|
|
||||||
prepfile[[
|
|
||||||
warn("@allow") -- unknown control, ignored
|
|
||||||
warn("@off", "XXX", "@off") -- these are not control messages
|
|
||||||
warn("@off") -- this one is
|
|
||||||
warn("@on", "YYY", "@on") -- not control, but warn is off
|
|
||||||
warn("@off") -- keep it off
|
|
||||||
warn("@on") -- restart warnings
|
|
||||||
warn("", "@on") -- again, no control, real warning
|
|
||||||
warn("@on") -- keep it "started"
|
|
||||||
warn("Z", "Z", "Z") -- common warning
|
|
||||||
]]
|
|
||||||
RUN('lua -W %s 2> %s', prog, out)
|
|
||||||
checkout[[
|
|
||||||
Lua warning: @offXXX@off
|
|
||||||
Lua warning: @on
|
|
||||||
Lua warning: ZZZ
|
|
||||||
]]
|
|
||||||
|
|
||||||
prepfile[[
|
|
||||||
warn("@allow")
|
|
||||||
-- create two objects to be finalized when closing state
|
|
||||||
-- the errors in the finalizers must generate warnings
|
|
||||||
u1 = setmetatable({}, {__gc = function () error("XYZ") end})
|
|
||||||
u2 = setmetatable({}, {__gc = function () error("ZYX") end})
|
|
||||||
]]
|
|
||||||
RUN('lua -W %s 2> %s', prog, out)
|
|
||||||
checkprogout("ZYX)\nXYZ)\n")
|
|
||||||
|
|
||||||
-- bug since 5.2: finalizer called when closing a state could
|
|
||||||
-- subvert finalization order
|
|
||||||
prepfile[[
|
|
||||||
-- should be called last
|
|
||||||
print("creating 1")
|
|
||||||
setmetatable({}, {__gc = function () print(1) end})
|
|
||||||
|
|
||||||
print("creating 2")
|
|
||||||
setmetatable({}, {__gc = function ()
|
|
||||||
print("2")
|
|
||||||
print("creating 3")
|
|
||||||
-- this finalizer should not be called, as object will be
|
|
||||||
-- created after 'lua_close' has been called
|
|
||||||
setmetatable({}, {__gc = function () print(3) end})
|
|
||||||
print(collectgarbage()) -- cannot call collector here
|
|
||||||
os.exit(0, true)
|
|
||||||
end})
|
|
||||||
]]
|
|
||||||
RUN('lua -W %s > %s', prog, out)
|
|
||||||
checkout[[
|
|
||||||
creating 1
|
|
||||||
creating 2
|
|
||||||
2
|
|
||||||
creating 3
|
|
||||||
nil
|
|
||||||
1
|
|
||||||
]]
|
|
||||||
|
|
||||||
|
|
||||||
-- test many arguments
|
|
||||||
prepfile[[print(({...})[30])]]
|
|
||||||
RUN('lua %s %s > %s', prog, string.rep(" a", 30), out)
|
|
||||||
checkout("a\n")
|
|
||||||
|
|
||||||
RUN([[lua "-eprint(1)" -ea=3 -e "print(a)" > %s]], out)
|
|
||||||
checkout("1\n3\n")
|
|
||||||
|
|
||||||
-- test iteractive mode
|
|
||||||
prepfile[[
|
|
||||||
(6*2-6) -- ===
|
|
||||||
a =
|
|
||||||
10
|
|
||||||
print(a)
|
|
||||||
a]]
|
|
||||||
RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)
|
|
||||||
checkprogout("6\n10\n10\n\n")
|
|
||||||
|
|
||||||
prepfile("a = [[b\nc\nd\ne]]\n=a")
|
|
||||||
RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)
|
|
||||||
checkprogout("b\nc\nd\ne\n\n")
|
|
||||||
|
|
||||||
local prompt = "alo"
|
|
||||||
prepfile[[ --
|
|
||||||
a = 2
|
|
||||||
]]
|
|
||||||
RUN([[lua "-e_PROMPT='%s'" -i < %s > %s]], prompt, prog, out)
|
|
||||||
local t = getoutput()
|
|
||||||
assert(string.find(t, prompt .. ".*" .. prompt .. ".*" .. prompt))
|
|
||||||
|
|
||||||
-- using the prompt default
|
|
||||||
prepfile[[ --
|
|
||||||
a = 2
|
|
||||||
]]
|
|
||||||
RUN([[lua -i < %s > %s]], prog, out)
|
|
||||||
local t = getoutput()
|
|
||||||
prompt = "> " -- the default
|
|
||||||
assert(string.find(t, prompt .. ".*" .. prompt .. ".*" .. prompt))
|
|
||||||
|
|
||||||
|
|
||||||
-- non-string prompt
|
|
||||||
prompt =
|
|
||||||
"local C = 0;\z
|
|
||||||
_PROMPT=setmetatable({},{__tostring = function () \z
|
|
||||||
C = C + 1; return C end})"
|
|
||||||
prepfile[[ --
|
|
||||||
a = 2
|
|
||||||
]]
|
|
||||||
RUN([[lua -e "%s" -i < %s > %s]], prompt, prog, out)
|
|
||||||
local t = getoutput()
|
|
||||||
assert(string.find(t, [[
|
|
||||||
1 --
|
|
||||||
2a = 2
|
|
||||||
3
|
|
||||||
]], 1, true))
|
|
||||||
|
|
||||||
|
|
||||||
-- test for error objects
|
|
||||||
prepfile[[
|
|
||||||
debug = require "debug"
|
|
||||||
m = {x=0}
|
|
||||||
setmetatable(m, {__tostring = function(x)
|
|
||||||
return tostring(debug.getinfo(4).currentline + x.x)
|
|
||||||
end})
|
|
||||||
error(m)
|
|
||||||
]]
|
|
||||||
NoRun(progname .. ": 6\n", [[lua %s]], prog)
|
|
||||||
|
|
||||||
prepfile("error{}")
|
|
||||||
NoRun("error object is a table value", [[lua %s]], prog)
|
|
||||||
|
|
||||||
|
|
||||||
-- chunk broken in many lines
|
|
||||||
local s = [=[ --
|
|
||||||
function f ( x )
|
|
||||||
local a = [[
|
|
||||||
xuxu
|
|
||||||
]]
|
|
||||||
local b = "\
|
|
||||||
xuxu\n"
|
|
||||||
if x == 11 then return 1 + 12 , 2 + 20 end --[[ test multiple returns ]]
|
|
||||||
return x + 1
|
|
||||||
--\\
|
|
||||||
end
|
|
||||||
return( f( 100 ) )
|
|
||||||
assert( a == b )
|
|
||||||
do return f( 11 ) end ]=]
|
|
||||||
s = string.gsub(s, ' ', '\n\n') -- change all spaces for newlines
|
|
||||||
prepfile(s)
|
|
||||||
RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)
|
|
||||||
checkprogout("101\n13\t22\n\n")
|
|
||||||
|
|
||||||
prepfile[[#comment in 1st line without \n at the end]]
|
|
||||||
RUN('lua %s', prog)
|
|
||||||
|
|
||||||
-- first-line comment with binary file
|
|
||||||
prepfile("#comment\n" .. string.dump(load("print(3)")))
|
|
||||||
RUN('lua %s > %s', prog, out)
|
|
||||||
checkout('3\n')
|
|
||||||
|
|
||||||
-- close Lua with an open file
|
|
||||||
prepfile(string.format([[io.output(%q); io.write('alo')]], out))
|
|
||||||
RUN('lua %s', prog)
|
|
||||||
checkout('alo')
|
|
||||||
|
|
||||||
-- bug in 5.2 beta (extra \0 after version line)
|
|
||||||
RUN([[lua -v -e"print'hello'" > %s]], out)
|
|
||||||
t = getoutput()
|
|
||||||
assert(string.find(t, "PUC%-Rio\nhello"))
|
|
||||||
|
|
||||||
|
|
||||||
-- testing os.exit
|
|
||||||
prepfile("os.exit(nil, true)")
|
|
||||||
RUN('lua %s', prog)
|
|
||||||
prepfile("os.exit(0, true)")
|
|
||||||
RUN('lua %s', prog)
|
|
||||||
prepfile("os.exit(true, true)")
|
|
||||||
RUN('lua %s', prog)
|
|
||||||
prepfile("os.exit(1, true)")
|
|
||||||
NoRun("", "lua %s", prog) -- no message
|
|
||||||
prepfile("os.exit(false, true)")
|
|
||||||
NoRun("", "lua %s", prog) -- no message
|
|
||||||
|
|
||||||
|
|
||||||
-- to-be-closed variables in main chunk
|
|
||||||
prepfile[[
|
|
||||||
local x <close> = setmetatable({},
|
|
||||||
{__close = function (self, err)
|
|
||||||
assert(err == nil)
|
|
||||||
print("Ok")
|
|
||||||
end})
|
|
||||||
local e1 <close> = setmetatable({}, {__close = function () print(120) end})
|
|
||||||
os.exit(true, true)
|
|
||||||
]]
|
|
||||||
RUN('lua %s > %s', prog, out)
|
|
||||||
checkprogout("120\nOk\n")
|
|
||||||
|
|
||||||
|
|
||||||
-- remove temporary files
|
|
||||||
assert(os.remove(prog))
|
|
||||||
assert(os.remove(otherprog))
|
|
||||||
assert(not os.remove(out))
|
|
||||||
|
|
||||||
-- invalid options
|
|
||||||
NoRun("unrecognized option '-h'", "lua -h")
|
|
||||||
NoRun("unrecognized option '---'", "lua ---")
|
|
||||||
NoRun("unrecognized option '-Ex'", "lua -Ex")
|
|
||||||
NoRun("unrecognized option '-vv'", "lua -vv")
|
|
||||||
NoRun("unrecognized option '-iv'", "lua -iv")
|
|
||||||
NoRun("'-e' needs argument", "lua -e")
|
|
||||||
NoRun("syntax error", "lua -e a")
|
|
||||||
NoRun("'-l' needs argument", "lua -l")
|
|
||||||
|
|
||||||
|
|
||||||
if T then -- test library?
|
|
||||||
print("testing 'not enough memory' to create a state")
|
|
||||||
NoRun("not enough memory", "env MEMLIMIT=100 lua")
|
|
||||||
|
|
||||||
-- testing 'warn'
|
|
||||||
warn("@store")
|
|
||||||
warn("@123", "456", "789")
|
|
||||||
assert(_WARN == "@123456789"); _WARN = false
|
|
||||||
|
|
||||||
warn("zip", "", " ", "zap")
|
|
||||||
assert(_WARN == "zip zap"); _WARN = false
|
|
||||||
warn("ZIP", "", " ", "ZAP")
|
|
||||||
assert(_WARN == "ZIP ZAP"); _WARN = false
|
|
||||||
warn("@normal")
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
-- 'warn' must get at least one argument
|
|
||||||
local st, msg = pcall(warn)
|
|
||||||
assert(string.find(msg, "string expected"))
|
|
||||||
|
|
||||||
-- 'warn' does not leave unfinished warning in case of errors
|
|
||||||
-- (message would appear in next warning)
|
|
||||||
st, msg = pcall(warn, "SHOULD NOT APPEAR", {})
|
|
||||||
assert(string.find(msg, "string expected"))
|
|
||||||
end
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
print('testing Ctrl C')
|
|
||||||
do
|
|
||||||
-- interrupt a script
|
|
||||||
local function kill (pid)
|
|
||||||
return os.execute(string.format('kill -INT %s 2> /dev/null', pid))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- function to run a script in background, returning its output file
|
|
||||||
-- descriptor and its pid
|
|
||||||
local function runback (luaprg)
|
|
||||||
-- shell script to run 'luaprg' in background and echo its pid
|
|
||||||
local shellprg = string.format('%s -e "%s" & echo $!', progname, luaprg)
|
|
||||||
local f = io.popen(shellprg, "r") -- run shell script
|
|
||||||
local pid = f:read() -- get pid for Lua script
|
|
||||||
print("(if test fails now, it may leave a Lua script running in \z
|
|
||||||
background, pid " .. pid .. ")")
|
|
||||||
return f, pid
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Lua script that runs protected infinite loop and then prints '42'
|
|
||||||
local f, pid = runback[[
|
|
||||||
pcall(function () print(12); while true do end end); print(42)]]
|
|
||||||
-- wait until script is inside 'pcall'
|
|
||||||
assert(f:read() == "12")
|
|
||||||
kill(pid) -- send INT signal to Lua script
|
|
||||||
-- check that 'pcall' captured the exception and script continued running
|
|
||||||
assert(f:read() == "42") -- expected output
|
|
||||||
assert(f:close())
|
|
||||||
print("done")
|
|
||||||
|
|
||||||
-- Lua script in a long unbreakable search
|
|
||||||
local f, pid = runback[[
|
|
||||||
print(15); string.find(string.rep('a', 100000), '.*b')]]
|
|
||||||
-- wait (so script can reach the loop)
|
|
||||||
assert(f:read() == "15")
|
|
||||||
assert(os.execute("sleep 1"))
|
|
||||||
-- must send at least two INT signals to stop this Lua script
|
|
||||||
local n = 100
|
|
||||||
for i = 0, 100 do -- keep sending signals
|
|
||||||
if not kill(pid) then -- until it fails
|
|
||||||
n = i -- number of non-failed kills
|
|
||||||
break
|
|
||||||
end
|
|
||||||
end
|
|
||||||
assert(f:close())
|
|
||||||
assert(n >= 2)
|
|
||||||
print(string.format("done (with %d kills)", n))
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
print("OK")
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,825 +0,0 @@
|
|||||||
-- $Id: testes/nextvar.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing tables, next, and for')
|
|
||||||
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local s, err = pcall(f, ...)
|
|
||||||
assert(not s and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function check (t, na, nh)
|
|
||||||
if not T then return end
|
|
||||||
local a, h = T.querytab(t)
|
|
||||||
if a ~= na or h ~= nh then
|
|
||||||
print(na, nh, a, h)
|
|
||||||
assert(nil)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local a = {}
|
|
||||||
|
|
||||||
-- make sure table has lots of space in hash part
|
|
||||||
for i=1,100 do a[i.."+"] = true end
|
|
||||||
for i=1,100 do a[i.."+"] = undef end
|
|
||||||
-- fill hash part with numeric indices testing size operator
|
|
||||||
for i=1,100 do
|
|
||||||
a[i] = true
|
|
||||||
assert(#a == i)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- rehash moving elements from array to hash
|
|
||||||
local a = {}
|
|
||||||
for i = 1, 100 do a[i] = i end
|
|
||||||
check(a, 128, 0)
|
|
||||||
|
|
||||||
for i = 5, 95 do a[i] = nil end
|
|
||||||
check(a, 128, 0)
|
|
||||||
|
|
||||||
a.x = 1 -- force a re-hash
|
|
||||||
check(a, 4, 8)
|
|
||||||
|
|
||||||
for i = 1, 4 do assert(a[i] == i) end
|
|
||||||
for i = 5, 95 do assert(a[i] == nil) end
|
|
||||||
for i = 96, 100 do assert(a[i] == i) end
|
|
||||||
assert(a.x == 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing ipairs
|
|
||||||
local x = 0
|
|
||||||
for k,v in ipairs{10,20,30;x=12} do
|
|
||||||
x = x + 1
|
|
||||||
assert(k == x and v == x * 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
for _ in ipairs{x=12, y=24} do assert(nil) end
|
|
||||||
|
|
||||||
-- test for 'false' x ipair
|
|
||||||
x = false
|
|
||||||
local i = 0
|
|
||||||
for k,v in ipairs{true,false,true,false} do
|
|
||||||
i = i + 1
|
|
||||||
x = not x
|
|
||||||
assert(x == v)
|
|
||||||
end
|
|
||||||
assert(i == 4)
|
|
||||||
|
|
||||||
-- iterator function is always the same
|
|
||||||
assert(type(ipairs{}) == 'function' and ipairs{} == ipairs{})
|
|
||||||
|
|
||||||
|
|
||||||
do -- overflow (must wrap-around)
|
|
||||||
local f = ipairs{}
|
|
||||||
local k, v = f({[math.mininteger] = 10}, math.maxinteger)
|
|
||||||
assert(k == math.mininteger and v == 10)
|
|
||||||
k, v = f({[math.mininteger] = 10}, k)
|
|
||||||
assert(k == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
if not T then
|
|
||||||
(Message or print)
|
|
||||||
('\n >>> testC not active: skipping tests for table sizes <<<\n')
|
|
||||||
else --[
|
|
||||||
-- testing table sizes
|
|
||||||
|
|
||||||
|
|
||||||
local function mp2 (n) -- minimum power of 2 >= n
|
|
||||||
local mp = 2^math.ceil(math.log(n, 2))
|
|
||||||
assert(n == 0 or (mp/2 < n and n <= mp))
|
|
||||||
return mp
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing C library sizes
|
|
||||||
do
|
|
||||||
local s = 0
|
|
||||||
for _ in pairs(math) do s = s + 1 end
|
|
||||||
check(math, 0, mp2(s))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing constructor sizes
|
|
||||||
local sizes = {0, 1, 2, 3, 4, 5, 7, 8, 9, 15, 16, 17,
|
|
||||||
30, 31, 32, 33, 34, 254, 255, 256, 500, 1000}
|
|
||||||
|
|
||||||
for _, sa in ipairs(sizes) do -- 'sa' is size of the array part
|
|
||||||
local arr = {"return {"}
|
|
||||||
for i = 1, sa do arr[1 + i] = "1," end -- build array part
|
|
||||||
for _, sh in ipairs(sizes) do -- 'sh' is size of the hash part
|
|
||||||
for j = 1, sh do -- build hash part
|
|
||||||
arr[1 + sa + j] = string.format('k%x=%d,', j, j)
|
|
||||||
end
|
|
||||||
arr[1 + sa + sh + 1] = "}"
|
|
||||||
local prog = table.concat(arr)
|
|
||||||
local f = assert(load(prog))
|
|
||||||
collectgarbage("stop")
|
|
||||||
f() -- call once to ensure stack space
|
|
||||||
-- make sure table is not resized after being created
|
|
||||||
if sa == 0 or sh == 0 then
|
|
||||||
T.alloccount(2); -- header + array or hash part
|
|
||||||
else
|
|
||||||
T.alloccount(3); -- header + array part + hash part
|
|
||||||
end
|
|
||||||
local t = f()
|
|
||||||
T.alloccount();
|
|
||||||
collectgarbage("restart")
|
|
||||||
assert(#t == sa)
|
|
||||||
check(t, sa, mp2(sh))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- tests with unknown number of elements
|
|
||||||
local a = {}
|
|
||||||
for i=1,sizes[#sizes] do a[i] = i end -- build auxiliary table
|
|
||||||
for k in ipairs(sizes) do
|
|
||||||
local t = {table.unpack(a,1,k)}
|
|
||||||
assert(#t == k)
|
|
||||||
check(t, k, 0)
|
|
||||||
t = {1,2,3,table.unpack(a,1,k)}
|
|
||||||
check(t, k+3, 0)
|
|
||||||
assert(#t == k + 3)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing tables dynamically built
|
|
||||||
local lim = 130
|
|
||||||
local a = {}; a[2] = 1; check(a, 0, 1)
|
|
||||||
a = {}; a[0] = 1; check(a, 0, 1); a[2] = 1; check(a, 0, 2)
|
|
||||||
a = {}; a[0] = 1; a[1] = 1; check(a, 1, 1)
|
|
||||||
a = {}
|
|
||||||
for i = 1,lim do
|
|
||||||
a[i] = 1
|
|
||||||
assert(#a == i)
|
|
||||||
check(a, mp2(i), 0)
|
|
||||||
end
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
for i = 1,lim do
|
|
||||||
a['a'..i] = 1
|
|
||||||
assert(#a == 0)
|
|
||||||
check(a, 0, mp2(i))
|
|
||||||
end
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
for i=1,16 do a[i] = i end
|
|
||||||
check(a, 16, 0)
|
|
||||||
do
|
|
||||||
for i=1,11 do a[i] = undef end
|
|
||||||
for i=30,50 do a[i] = true; a[i] = undef end -- force a rehash (?)
|
|
||||||
check(a, 0, 8) -- 5 elements in the table
|
|
||||||
a[10] = 1
|
|
||||||
for i=30,50 do a[i] = true; a[i] = undef end -- force a rehash (?)
|
|
||||||
check(a, 0, 8) -- only 6 elements in the table
|
|
||||||
for i=1,14 do a[i] = true; a[i] = undef end
|
|
||||||
for i=18,50 do a[i] = true; a[i] = undef end -- force a rehash (?)
|
|
||||||
check(a, 0, 4) -- only 2 elements ([15] and [16])
|
|
||||||
end
|
|
||||||
|
|
||||||
-- reverse filling
|
|
||||||
for i=1,lim do
|
|
||||||
local a = {}
|
|
||||||
for i=i,1,-1 do a[i] = i end -- fill in reverse
|
|
||||||
check(a, mp2(i), 0)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- size tests for vararg
|
|
||||||
lim = 35
|
|
||||||
local function foo (n, ...)
|
|
||||||
local arg = {...}
|
|
||||||
check(arg, n, 0)
|
|
||||||
assert(select('#', ...) == n)
|
|
||||||
arg[n+1] = true
|
|
||||||
check(arg, mp2(n+1), 0)
|
|
||||||
arg.x = true
|
|
||||||
check(arg, mp2(n+1), 1)
|
|
||||||
end
|
|
||||||
local a = {}
|
|
||||||
for i=1,lim do a[i] = true; foo(i, table.unpack(a)) end
|
|
||||||
|
|
||||||
|
|
||||||
-- Table length with limit smaller than maximum value at array
|
|
||||||
local a = {}
|
|
||||||
for i = 1,64 do a[i] = true end -- make its array size 64
|
|
||||||
for i = 1,64 do a[i] = nil end -- erase all elements
|
|
||||||
assert(T.querytab(a) == 64) -- array part has 64 elements
|
|
||||||
a[32] = true; a[48] = true; -- binary search will find these ones
|
|
||||||
a[51] = true -- binary search will miss this one
|
|
||||||
assert(#a == 48) -- this will set the limit
|
|
||||||
assert(select(4, T.querytab(a)) == 48) -- this is the limit now
|
|
||||||
a[50] = true -- this will set a new limit
|
|
||||||
assert(select(4, T.querytab(a)) == 50) -- this is the limit now
|
|
||||||
-- but the size is larger (and still inside the array part)
|
|
||||||
assert(#a == 51)
|
|
||||||
|
|
||||||
end --]
|
|
||||||
|
|
||||||
|
|
||||||
-- test size operation on tables with nils
|
|
||||||
assert(#{} == 0)
|
|
||||||
assert(#{nil} == 0)
|
|
||||||
assert(#{nil, nil} == 0)
|
|
||||||
assert(#{nil, nil, nil} == 0)
|
|
||||||
assert(#{nil, nil, nil, nil} == 0)
|
|
||||||
assert(#{1, 2, 3, nil, nil} == 3)
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
|
|
||||||
local nofind = {}
|
|
||||||
|
|
||||||
a,b,c = 1,2,3
|
|
||||||
a,b,c = nil
|
|
||||||
|
|
||||||
|
|
||||||
-- next uses always the same iteraction function
|
|
||||||
assert(next{} == next{})
|
|
||||||
|
|
||||||
local function find (name)
|
|
||||||
local n,v
|
|
||||||
while 1 do
|
|
||||||
n,v = next(_G, n)
|
|
||||||
if not n then return nofind end
|
|
||||||
assert(_G[n] ~= undef)
|
|
||||||
if n == name then return v end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function find1 (name)
|
|
||||||
for n,v in pairs(_G) do
|
|
||||||
if n==name then return v end
|
|
||||||
end
|
|
||||||
return nil -- not found
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
assert(print==find("print") and print == find1("print"))
|
|
||||||
assert(_G["print"]==find("print"))
|
|
||||||
assert(assert==find1("assert"))
|
|
||||||
assert(nofind==find("return"))
|
|
||||||
assert(not find1("return"))
|
|
||||||
_G["ret" .. "urn"] = undef
|
|
||||||
assert(nofind==find("return"))
|
|
||||||
_G["xxx"] = 1
|
|
||||||
assert(xxx==find("xxx"))
|
|
||||||
|
|
||||||
-- invalid key to 'next'
|
|
||||||
checkerror("invalid key", next, {10,20}, 3)
|
|
||||||
|
|
||||||
-- both 'pairs' and 'ipairs' need an argument
|
|
||||||
checkerror("bad argument", pairs)
|
|
||||||
checkerror("bad argument", ipairs)
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
for i=0,10000 do
|
|
||||||
if math.fmod(i,10) ~= 0 then
|
|
||||||
a['x'..i] = i
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
n = {n=0}
|
|
||||||
for i,v in pairs(a) do
|
|
||||||
n.n = n.n+1
|
|
||||||
assert(i and v and a[i] == v)
|
|
||||||
end
|
|
||||||
assert(n.n == 9000)
|
|
||||||
a = nil
|
|
||||||
|
|
||||||
do -- clear global table
|
|
||||||
local a = {}
|
|
||||||
for n,v in pairs(_G) do a[n]=v end
|
|
||||||
for n,v in pairs(a) do
|
|
||||||
if not package.loaded[n] and type(v) ~= "function" and
|
|
||||||
not string.find(n, "^[%u_]") then
|
|
||||||
_G[n] = undef
|
|
||||||
end
|
|
||||||
collectgarbage()
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
--
|
|
||||||
|
|
||||||
local function checknext (a)
|
|
||||||
local b = {}
|
|
||||||
do local k,v = next(a); while k do b[k] = v; k,v = next(a,k) end end
|
|
||||||
for k,v in pairs(b) do assert(a[k] == v) end
|
|
||||||
for k,v in pairs(a) do assert(b[k] == v) end
|
|
||||||
end
|
|
||||||
|
|
||||||
checknext{1,x=1,y=2,z=3}
|
|
||||||
checknext{1,2,x=1,y=2,z=3}
|
|
||||||
checknext{1,2,3,x=1,y=2,z=3}
|
|
||||||
checknext{1,2,3,4,x=1,y=2,z=3}
|
|
||||||
checknext{1,2,3,4,5,x=1,y=2,z=3}
|
|
||||||
|
|
||||||
assert(#{} == 0)
|
|
||||||
assert(#{[-1] = 2} == 0)
|
|
||||||
for i=0,40 do
|
|
||||||
local a = {}
|
|
||||||
for j=1,i do a[j]=j end
|
|
||||||
assert(#a == i)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- 'maxn' is now deprecated, but it is easily defined in Lua
|
|
||||||
function table.maxn (t)
|
|
||||||
local max = 0
|
|
||||||
for k in pairs(t) do
|
|
||||||
max = (type(k) == 'number') and math.max(max, k) or max
|
|
||||||
end
|
|
||||||
return max
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(table.maxn{} == 0)
|
|
||||||
assert(table.maxn{["1000"] = true} == 0)
|
|
||||||
assert(table.maxn{["1000"] = true, [24.5] = 3} == 24.5)
|
|
||||||
assert(table.maxn{[1000] = true} == 1000)
|
|
||||||
assert(table.maxn{[10] = true, [100*math.pi] = print} == 100*math.pi)
|
|
||||||
|
|
||||||
table.maxn = nil
|
|
||||||
|
|
||||||
-- int overflow
|
|
||||||
a = {}
|
|
||||||
for i=0,50 do a[2^i] = true end
|
|
||||||
assert(a[#a])
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
|
|
||||||
do -- testing 'next' with all kinds of keys
|
|
||||||
local a = {
|
|
||||||
[1] = 1, -- integer
|
|
||||||
[1.1] = 2, -- float
|
|
||||||
['x'] = 3, -- short string
|
|
||||||
[string.rep('x', 1000)] = 4, -- long string
|
|
||||||
[print] = 5, -- C function
|
|
||||||
[checkerror] = 6, -- Lua function
|
|
||||||
[coroutine.running()] = 7, -- thread
|
|
||||||
[true] = 8, -- boolean
|
|
||||||
[io.stdin] = 9, -- userdata
|
|
||||||
[{}] = 10, -- table
|
|
||||||
}
|
|
||||||
local b = {}; for i = 1, 10 do b[i] = true end
|
|
||||||
for k, v in pairs(a) do
|
|
||||||
assert(b[v]); b[v] = undef
|
|
||||||
end
|
|
||||||
assert(next(b) == nil) -- 'b' now is empty
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- erasing values
|
|
||||||
local t = {[{1}] = 1, [{2}] = 2, [string.rep("x ", 4)] = 3,
|
|
||||||
[100.3] = 4, [4] = 5}
|
|
||||||
|
|
||||||
local n = 0
|
|
||||||
for k, v in pairs( t ) do
|
|
||||||
n = n+1
|
|
||||||
assert(t[k] == v)
|
|
||||||
t[k] = undef
|
|
||||||
collectgarbage()
|
|
||||||
assert(t[k] == undef)
|
|
||||||
end
|
|
||||||
assert(n == 5)
|
|
||||||
|
|
||||||
|
|
||||||
do
|
|
||||||
print("testing next x GC of deleted keys")
|
|
||||||
-- bug in 5.4.1
|
|
||||||
local co = coroutine.wrap(function (t)
|
|
||||||
for k, v in pairs(t) do
|
|
||||||
local k1 = next(t) -- all previous keys were deleted
|
|
||||||
assert(k == k1) -- current key is the first in the table
|
|
||||||
t[k] = nil
|
|
||||||
local expected = (type(k) == "table" and k[1] or
|
|
||||||
type(k) == "function" and k() or
|
|
||||||
string.sub(k, 1, 1))
|
|
||||||
assert(expected == v)
|
|
||||||
coroutine.yield(v)
|
|
||||||
end
|
|
||||||
end)
|
|
||||||
local t = {}
|
|
||||||
t[{1}] = 1 -- add several unanchored, collectable keys
|
|
||||||
t[{2}] = 2
|
|
||||||
t[string.rep("a", 50)] = "a" -- long string
|
|
||||||
t[string.rep("b", 50)] = "b"
|
|
||||||
t[{3}] = 3
|
|
||||||
t[string.rep("c", 10)] = "c" -- short string
|
|
||||||
t[function () return 10 end] = 10
|
|
||||||
local count = 7
|
|
||||||
while co(t) do
|
|
||||||
collectgarbage("collect") -- collect dead keys
|
|
||||||
count = count - 1
|
|
||||||
end
|
|
||||||
assert(count == 0 and next(t) == nil) -- traversed the whole table
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function test (a)
|
|
||||||
assert(not pcall(table.insert, a, 2, 20));
|
|
||||||
table.insert(a, 10); table.insert(a, 2, 20);
|
|
||||||
table.insert(a, 1, -1); table.insert(a, 40);
|
|
||||||
table.insert(a, #a+1, 50)
|
|
||||||
table.insert(a, 2, -2)
|
|
||||||
assert(a[2] ~= undef)
|
|
||||||
assert(a["2"] == undef)
|
|
||||||
assert(not pcall(table.insert, a, 0, 20));
|
|
||||||
assert(not pcall(table.insert, a, #a + 2, 20));
|
|
||||||
assert(table.remove(a,1) == -1)
|
|
||||||
assert(table.remove(a,1) == -2)
|
|
||||||
assert(table.remove(a,1) == 10)
|
|
||||||
assert(table.remove(a,1) == 20)
|
|
||||||
assert(table.remove(a,1) == 40)
|
|
||||||
assert(table.remove(a,1) == 50)
|
|
||||||
assert(table.remove(a,1) == nil)
|
|
||||||
assert(table.remove(a) == nil)
|
|
||||||
assert(table.remove(a, #a) == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
a = {n=0, [-7] = "ban"}
|
|
||||||
test(a)
|
|
||||||
assert(a.n == 0 and a[-7] == "ban")
|
|
||||||
|
|
||||||
a = {[-7] = "ban"};
|
|
||||||
test(a)
|
|
||||||
assert(a.n == nil and #a == 0 and a[-7] == "ban")
|
|
||||||
|
|
||||||
a = {[-1] = "ban"}
|
|
||||||
test(a)
|
|
||||||
assert(#a == 0 and table.remove(a) == nil and a[-1] == "ban")
|
|
||||||
|
|
||||||
a = {[0] = "ban"}
|
|
||||||
assert(#a == 0 and table.remove(a) == "ban" and a[0] == undef)
|
|
||||||
|
|
||||||
table.insert(a, 1, 10); table.insert(a, 1, 20); table.insert(a, 1, -1)
|
|
||||||
assert(table.remove(a) == 10)
|
|
||||||
assert(table.remove(a) == 20)
|
|
||||||
assert(table.remove(a) == -1)
|
|
||||||
assert(table.remove(a) == nil)
|
|
||||||
|
|
||||||
a = {'c', 'd'}
|
|
||||||
table.insert(a, 3, 'a')
|
|
||||||
table.insert(a, 'b')
|
|
||||||
assert(table.remove(a, 1) == 'c')
|
|
||||||
assert(table.remove(a, 1) == 'd')
|
|
||||||
assert(table.remove(a, 1) == 'a')
|
|
||||||
assert(table.remove(a, 1) == 'b')
|
|
||||||
assert(table.remove(a, 1) == nil)
|
|
||||||
assert(#a == 0 and a.n == nil)
|
|
||||||
|
|
||||||
a = {10,20,30,40}
|
|
||||||
assert(table.remove(a, #a + 1) == nil)
|
|
||||||
assert(not pcall(table.remove, a, 0))
|
|
||||||
assert(a[#a] == 40)
|
|
||||||
assert(table.remove(a, #a) == 40)
|
|
||||||
assert(a[#a] == 30)
|
|
||||||
assert(table.remove(a, 2) == 20)
|
|
||||||
assert(a[#a] == 30 and #a == 2)
|
|
||||||
|
|
||||||
do -- testing table library with metamethods
|
|
||||||
local function test (proxy, t)
|
|
||||||
for i = 1, 10 do
|
|
||||||
table.insert(proxy, 1, i)
|
|
||||||
end
|
|
||||||
assert(#proxy == 10 and #t == 10 and proxy[1] ~= undef)
|
|
||||||
for i = 1, 10 do
|
|
||||||
assert(t[i] == 11 - i)
|
|
||||||
end
|
|
||||||
table.sort(proxy)
|
|
||||||
for i = 1, 10 do
|
|
||||||
assert(t[i] == i and proxy[i] == i)
|
|
||||||
end
|
|
||||||
assert(table.concat(proxy, ",") == "1,2,3,4,5,6,7,8,9,10")
|
|
||||||
for i = 1, 8 do
|
|
||||||
assert(table.remove(proxy, 1) == i)
|
|
||||||
end
|
|
||||||
assert(#proxy == 2 and #t == 2)
|
|
||||||
local a, b, c = table.unpack(proxy)
|
|
||||||
assert(a == 9 and b == 10 and c == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- all virtual
|
|
||||||
local t = {}
|
|
||||||
local proxy = setmetatable({}, {
|
|
||||||
__len = function () return #t end,
|
|
||||||
__index = t,
|
|
||||||
__newindex = t,
|
|
||||||
})
|
|
||||||
test(proxy, t)
|
|
||||||
|
|
||||||
-- only __newindex
|
|
||||||
local count = 0
|
|
||||||
t = setmetatable({}, {
|
|
||||||
__newindex = function (t,k,v) count = count + 1; rawset(t,k,v) end})
|
|
||||||
test(t, t)
|
|
||||||
assert(count == 10) -- after first 10, all other sets are not new
|
|
||||||
|
|
||||||
-- no __newindex
|
|
||||||
t = setmetatable({}, {
|
|
||||||
__index = function (_,k) return k + 1 end,
|
|
||||||
__len = function (_) return 5 end})
|
|
||||||
assert(table.concat(t, ";") == "2;3;4;5;6")
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- testing overflow in table.insert (must wrap-around)
|
|
||||||
|
|
||||||
local t = setmetatable({},
|
|
||||||
{__len = function () return math.maxinteger end})
|
|
||||||
table.insert(t, 20)
|
|
||||||
local k, v = next(t)
|
|
||||||
assert(k == math.mininteger and v == 20)
|
|
||||||
end
|
|
||||||
|
|
||||||
if not T then
|
|
||||||
(Message or print)
|
|
||||||
('\n >>> testC not active: skipping tests for table library on non-tables <<<\n')
|
|
||||||
else --[
|
|
||||||
local debug = require'debug'
|
|
||||||
local tab = {10, 20, 30}
|
|
||||||
local mt = {}
|
|
||||||
local u = T.newuserdata(0)
|
|
||||||
checkerror("table expected", table.insert, u, 40)
|
|
||||||
checkerror("table expected", table.remove, u)
|
|
||||||
debug.setmetatable(u, mt)
|
|
||||||
checkerror("table expected", table.insert, u, 40)
|
|
||||||
checkerror("table expected", table.remove, u)
|
|
||||||
mt.__index = tab
|
|
||||||
checkerror("table expected", table.insert, u, 40)
|
|
||||||
checkerror("table expected", table.remove, u)
|
|
||||||
mt.__newindex = tab
|
|
||||||
checkerror("table expected", table.insert, u, 40)
|
|
||||||
checkerror("table expected", table.remove, u)
|
|
||||||
mt.__len = function () return #tab end
|
|
||||||
table.insert(u, 40)
|
|
||||||
assert(#u == 4 and #tab == 4 and u[4] == 40 and tab[4] == 40)
|
|
||||||
assert(table.remove(u) == 40)
|
|
||||||
table.insert(u, 1, 50)
|
|
||||||
assert(#u == 4 and #tab == 4 and u[4] == 30 and tab[1] == 50)
|
|
||||||
|
|
||||||
mt.__newindex = nil
|
|
||||||
mt.__len = nil
|
|
||||||
local tab2 = {}
|
|
||||||
local u2 = T.newuserdata(0)
|
|
||||||
debug.setmetatable(u2, {__newindex = function (_, k, v) tab2[k] = v end})
|
|
||||||
table.move(u, 1, 4, 1, u2)
|
|
||||||
assert(#tab2 == 4 and tab2[1] == tab[1] and tab2[4] == tab[4])
|
|
||||||
|
|
||||||
end -- ]
|
|
||||||
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
for i=1,1000 do
|
|
||||||
a[i] = i; a[i - 1] = undef
|
|
||||||
end
|
|
||||||
assert(next(a,nil) == 1000 and next(a,1000) == nil)
|
|
||||||
|
|
||||||
assert(next({}) == nil)
|
|
||||||
assert(next({}, nil) == nil)
|
|
||||||
|
|
||||||
for a,b in pairs{} do error"not here" end
|
|
||||||
for i=1,0 do error'not here' end
|
|
||||||
for i=0,1,-1 do error'not here' end
|
|
||||||
a = nil; for i=1,1 do assert(not a); a=1 end; assert(a)
|
|
||||||
a = nil; for i=1,1,-1 do assert(not a); a=1 end; assert(a)
|
|
||||||
|
|
||||||
do
|
|
||||||
print("testing floats in numeric for")
|
|
||||||
local a
|
|
||||||
-- integer count
|
|
||||||
a = 0; for i=1, 1, 1 do a=a+1 end; assert(a==1)
|
|
||||||
a = 0; for i=10000, 1e4, -1 do a=a+1 end; assert(a==1)
|
|
||||||
a = 0; for i=1, 0.99999, 1 do a=a+1 end; assert(a==0)
|
|
||||||
a = 0; for i=9999, 1e4, -1 do a=a+1 end; assert(a==0)
|
|
||||||
a = 0; for i=1, 0.99999, -1 do a=a+1 end; assert(a==1)
|
|
||||||
|
|
||||||
-- float count
|
|
||||||
a = 0; for i=0, 0.999999999, 0.1 do a=a+1 end; assert(a==10)
|
|
||||||
a = 0; for i=1.0, 1, 1 do a=a+1 end; assert(a==1)
|
|
||||||
a = 0; for i=-1.5, -1.5, 1 do a=a+1 end; assert(a==1)
|
|
||||||
a = 0; for i=1e6, 1e6, -1 do a=a+1 end; assert(a==1)
|
|
||||||
a = 0; for i=1.0, 0.99999, 1 do a=a+1 end; assert(a==0)
|
|
||||||
a = 0; for i=99999, 1e5, -1.0 do a=a+1 end; assert(a==0)
|
|
||||||
a = 0; for i=1.0, 0.99999, -1 do a=a+1 end; assert(a==1)
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- changing the control variable
|
|
||||||
local a
|
|
||||||
a = 0; for i = 1, 10 do a = a + 1; i = "x" end; assert(a == 10)
|
|
||||||
a = 0; for i = 10.0, 1, -1 do a = a + 1; i = "x" end; assert(a == 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- conversion
|
|
||||||
a = 0; for i="10","1","-2" do a=a+1 end; assert(a==5)
|
|
||||||
|
|
||||||
do -- checking types
|
|
||||||
local c
|
|
||||||
local function checkfloat (i)
|
|
||||||
assert(math.type(i) == "float")
|
|
||||||
c = c + 1
|
|
||||||
end
|
|
||||||
|
|
||||||
c = 0; for i = 1.0, 10 do checkfloat(i) end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
c = 0; for i = -1, -10, -1.0 do checkfloat(i) end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
local function checkint (i)
|
|
||||||
assert(math.type(i) == "integer")
|
|
||||||
c = c + 1
|
|
||||||
end
|
|
||||||
|
|
||||||
local m = math.maxinteger
|
|
||||||
c = 0; for i = m, m - 10, -1 do checkint(i) end
|
|
||||||
assert(c == 11)
|
|
||||||
|
|
||||||
c = 0; for i = 1, 10.9 do checkint(i) end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
c = 0; for i = 10, 0.001, -1 do checkint(i) end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
c = 0; for i = 1, "10.8" do checkint(i) end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
c = 0; for i = 9, "3.4", -1 do checkint(i) end
|
|
||||||
assert(c == 6)
|
|
||||||
|
|
||||||
c = 0; for i = 0, " -3.4 ", -1 do checkint(i) end
|
|
||||||
assert(c == 4)
|
|
||||||
|
|
||||||
c = 0; for i = 100, "96.3", -2 do checkint(i) end
|
|
||||||
assert(c == 2)
|
|
||||||
|
|
||||||
c = 0; for i = 1, math.huge do if i > 10 then break end; checkint(i) end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
c = 0; for i = -1, -math.huge, -1 do
|
|
||||||
if i < -10 then break end; checkint(i)
|
|
||||||
end
|
|
||||||
assert(c == 10)
|
|
||||||
|
|
||||||
|
|
||||||
for i = math.mininteger, -10e100 do assert(false) end
|
|
||||||
for i = math.maxinteger, 10e100, -1 do assert(false) end
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- testing other strange cases for numeric 'for'
|
|
||||||
|
|
||||||
local function checkfor (from, to, step, t)
|
|
||||||
local c = 0
|
|
||||||
for i = from, to, step do
|
|
||||||
c = c + 1
|
|
||||||
assert(i == t[c])
|
|
||||||
end
|
|
||||||
assert(c == #t)
|
|
||||||
end
|
|
||||||
|
|
||||||
local maxi = math.maxinteger
|
|
||||||
local mini = math.mininteger
|
|
||||||
|
|
||||||
checkfor(mini, maxi, maxi, {mini, -1, maxi - 1})
|
|
||||||
|
|
||||||
checkfor(mini, math.huge, maxi, {mini, -1, maxi - 1})
|
|
||||||
|
|
||||||
checkfor(maxi, mini, mini, {maxi, -1})
|
|
||||||
|
|
||||||
checkfor(maxi, mini, -maxi, {maxi, 0, -maxi})
|
|
||||||
|
|
||||||
checkfor(maxi, -math.huge, mini, {maxi, -1})
|
|
||||||
|
|
||||||
checkfor(maxi, mini, 1, {})
|
|
||||||
checkfor(mini, maxi, -1, {})
|
|
||||||
|
|
||||||
checkfor(maxi - 6, maxi, 3, {maxi - 6, maxi - 3, maxi})
|
|
||||||
checkfor(mini + 4, mini, -2, {mini + 4, mini + 2, mini})
|
|
||||||
|
|
||||||
local step = maxi // 10
|
|
||||||
local c = mini
|
|
||||||
for i = mini, maxi, step do
|
|
||||||
assert(i == c)
|
|
||||||
c = c + step
|
|
||||||
end
|
|
||||||
|
|
||||||
c = maxi
|
|
||||||
for i = maxi, mini, -step do
|
|
||||||
assert(i == c)
|
|
||||||
c = c - step
|
|
||||||
end
|
|
||||||
|
|
||||||
checkfor(maxi, maxi, maxi, {maxi})
|
|
||||||
checkfor(maxi, maxi, mini, {maxi})
|
|
||||||
checkfor(mini, mini, maxi, {mini})
|
|
||||||
checkfor(mini, mini, mini, {mini})
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
checkerror("'for' step is zero", function ()
|
|
||||||
for i = 1, 10, 0 do end
|
|
||||||
end)
|
|
||||||
|
|
||||||
checkerror("'for' step is zero", function ()
|
|
||||||
for i = 1, -10, 0 do end
|
|
||||||
end)
|
|
||||||
|
|
||||||
checkerror("'for' step is zero", function ()
|
|
||||||
for i = 1.0, -10, 0.0 do end
|
|
||||||
end)
|
|
||||||
|
|
||||||
collectgarbage()
|
|
||||||
|
|
||||||
|
|
||||||
-- testing generic 'for'
|
|
||||||
|
|
||||||
local function f (n, p)
|
|
||||||
local t = {}; for i=1,p do t[i] = i*10 end
|
|
||||||
return function (_, n, ...)
|
|
||||||
assert(select("#", ...) == 0) -- no extra arguments
|
|
||||||
if n > 0 then
|
|
||||||
n = n-1
|
|
||||||
return n, table.unpack(t)
|
|
||||||
end
|
|
||||||
end, nil, n
|
|
||||||
end
|
|
||||||
|
|
||||||
local x = 0
|
|
||||||
for n,a,b,c,d in f(5,3) do
|
|
||||||
x = x+1
|
|
||||||
assert(a == 10 and b == 20 and c == 30 and d == nil)
|
|
||||||
end
|
|
||||||
assert(x == 5)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
-- testing __pairs and __ipairs metamethod
|
|
||||||
a = {}
|
|
||||||
do
|
|
||||||
local x,y,z = pairs(a)
|
|
||||||
assert(type(x) == 'function' and y == a and z == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
local function foo (e,i)
|
|
||||||
assert(e == a)
|
|
||||||
if i <= 10 then return i+1, i+2 end
|
|
||||||
end
|
|
||||||
|
|
||||||
local function foo1 (e,i)
|
|
||||||
i = i + 1
|
|
||||||
assert(e == a)
|
|
||||||
if i <= e.n then return i,a[i] end
|
|
||||||
end
|
|
||||||
|
|
||||||
setmetatable(a, {__pairs = function (x) return foo, x, 0 end})
|
|
||||||
|
|
||||||
local i = 0
|
|
||||||
for k,v in pairs(a) do
|
|
||||||
i = i + 1
|
|
||||||
assert(k == i and v == k+1)
|
|
||||||
end
|
|
||||||
|
|
||||||
a.n = 5
|
|
||||||
a[3] = 30
|
|
||||||
|
|
||||||
-- testing ipairs with metamethods
|
|
||||||
a = {n=10}
|
|
||||||
setmetatable(a, { __index = function (t,k)
|
|
||||||
if k <= t.n then return k * 10 end
|
|
||||||
end})
|
|
||||||
i = 0
|
|
||||||
for k,v in ipairs(a) do
|
|
||||||
i = i + 1
|
|
||||||
assert(k == i and v == i * 10)
|
|
||||||
end
|
|
||||||
assert(i == a.n)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing yield inside __pairs
|
|
||||||
do
|
|
||||||
local t = setmetatable({10, 20, 30}, {__pairs = function (t)
|
|
||||||
local inc = coroutine.yield()
|
|
||||||
return function (t, i)
|
|
||||||
if i > 1 then return i - inc, t[i - inc] else return nil end
|
|
||||||
end, t, #t + 1
|
|
||||||
end})
|
|
||||||
|
|
||||||
local res = {}
|
|
||||||
local co = coroutine.wrap(function ()
|
|
||||||
for i,p in pairs(t) do res[#res + 1] = p end
|
|
||||||
end)
|
|
||||||
|
|
||||||
co() -- start coroutine
|
|
||||||
co(1) -- continue after yield
|
|
||||||
assert(res[1] == 30 and res[2] == 20 and res[3] == 10 and #res == 3)
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
print"OK"
|
|
||||||
@ -1,423 +0,0 @@
|
|||||||
-- $Id: testes/pm.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing pattern matching')
|
|
||||||
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local s, err = pcall(f, ...)
|
|
||||||
assert(not s and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function f (s, p)
|
|
||||||
local i,e = string.find(s, p)
|
|
||||||
if i then return string.sub(s, i, e) end
|
|
||||||
end
|
|
||||||
|
|
||||||
local a,b = string.find('', '') -- empty patterns are tricky
|
|
||||||
assert(a == 1 and b == 0);
|
|
||||||
a,b = string.find('alo', '')
|
|
||||||
assert(a == 1 and b == 0)
|
|
||||||
a,b = string.find('a\0o a\0o a\0o', 'a', 1) -- first position
|
|
||||||
assert(a == 1 and b == 1)
|
|
||||||
a,b = string.find('a\0o a\0o a\0o', 'a\0o', 2) -- starts in the midle
|
|
||||||
assert(a == 5 and b == 7)
|
|
||||||
a,b = string.find('a\0o a\0o a\0o', 'a\0o', 9) -- starts in the midle
|
|
||||||
assert(a == 9 and b == 11)
|
|
||||||
a,b = string.find('a\0a\0a\0a\0\0ab', '\0ab', 2); -- finds at the end
|
|
||||||
assert(a == 9 and b == 11);
|
|
||||||
a,b = string.find('a\0a\0a\0a\0\0ab', 'b') -- last position
|
|
||||||
assert(a == 11 and b == 11)
|
|
||||||
assert(not string.find('a\0a\0a\0a\0\0ab', 'b\0')) -- check ending
|
|
||||||
assert(not string.find('', '\0'))
|
|
||||||
assert(string.find('alo123alo', '12') == 4)
|
|
||||||
assert(not string.find('alo123alo', '^12'))
|
|
||||||
|
|
||||||
assert(string.match("aaab", ".*b") == "aaab")
|
|
||||||
assert(string.match("aaa", ".*a") == "aaa")
|
|
||||||
assert(string.match("b", ".*b") == "b")
|
|
||||||
|
|
||||||
assert(string.match("aaab", ".+b") == "aaab")
|
|
||||||
assert(string.match("aaa", ".+a") == "aaa")
|
|
||||||
assert(not string.match("b", ".+b"))
|
|
||||||
|
|
||||||
assert(string.match("aaab", ".?b") == "ab")
|
|
||||||
assert(string.match("aaa", ".?a") == "aa")
|
|
||||||
assert(string.match("b", ".?b") == "b")
|
|
||||||
|
|
||||||
assert(f('aloALO', '%l*') == 'alo')
|
|
||||||
assert(f('aLo_ALO', '%a*') == 'aLo')
|
|
||||||
|
|
||||||
assert(f(" \n\r*&\n\r xuxu \n\n", "%g%g%g+") == "xuxu")
|
|
||||||
|
|
||||||
assert(f('aaab', 'a*') == 'aaa');
|
|
||||||
assert(f('aaa', '^.*$') == 'aaa');
|
|
||||||
assert(f('aaa', 'b*') == '');
|
|
||||||
assert(f('aaa', 'ab*a') == 'aa')
|
|
||||||
assert(f('aba', 'ab*a') == 'aba')
|
|
||||||
assert(f('aaab', 'a+') == 'aaa')
|
|
||||||
assert(f('aaa', '^.+$') == 'aaa')
|
|
||||||
assert(not f('aaa', 'b+'))
|
|
||||||
assert(not f('aaa', 'ab+a'))
|
|
||||||
assert(f('aba', 'ab+a') == 'aba')
|
|
||||||
assert(f('a$a', '.$') == 'a')
|
|
||||||
assert(f('a$a', '.%$') == 'a$')
|
|
||||||
assert(f('a$a', '.$.') == 'a$a')
|
|
||||||
assert(not f('a$a', '$$'))
|
|
||||||
assert(not f('a$b', 'a$'))
|
|
||||||
assert(f('a$a', '$') == '')
|
|
||||||
assert(f('', 'b*') == '')
|
|
||||||
assert(not f('aaa', 'bb*'))
|
|
||||||
assert(f('aaab', 'a-') == '')
|
|
||||||
assert(f('aaa', '^.-$') == 'aaa')
|
|
||||||
assert(f('aabaaabaaabaaaba', 'b.*b') == 'baaabaaabaaab')
|
|
||||||
assert(f('aabaaabaaabaaaba', 'b.-b') == 'baaab')
|
|
||||||
assert(f('alo xo', '.o$') == 'xo')
|
|
||||||
assert(f(' \n isto é assim', '%S%S*') == 'isto')
|
|
||||||
assert(f(' \n isto é assim', '%S*$') == 'assim')
|
|
||||||
assert(f(' \n isto é assim', '[a-z]*$') == 'assim')
|
|
||||||
assert(f('um caracter ? extra', '[^%sa-z]') == '?')
|
|
||||||
assert(f('', 'a?') == '')
|
|
||||||
assert(f('á', 'á?') == 'á')
|
|
||||||
assert(f('ábl', 'á?b?l?') == 'ábl')
|
|
||||||
assert(f(' ábl', 'á?b?l?') == '')
|
|
||||||
assert(f('aa', '^aa?a?a') == 'aa')
|
|
||||||
assert(f(']]]áb', '[^]]') == 'á')
|
|
||||||
assert(f("0alo alo", "%x*") == "0a")
|
|
||||||
assert(f("alo alo", "%C+") == "alo alo")
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
|
|
||||||
local function f1 (s, p)
|
|
||||||
p = string.gsub(p, "%%([0-9])", function (s)
|
|
||||||
return "%" .. (tonumber(s)+1)
|
|
||||||
end)
|
|
||||||
p = string.gsub(p, "^(^?)", "%1()", 1)
|
|
||||||
p = string.gsub(p, "($?)$", "()%1", 1)
|
|
||||||
local t = {string.match(s, p)}
|
|
||||||
return string.sub(s, t[1], t[#t] - 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(f1('alo alx 123 b\0o b\0o', '(..*) %1') == "b\0o b\0o")
|
|
||||||
assert(f1('axz123= 4= 4 34', '(.+)=(.*)=%2 %1') == '3= 4= 4 3')
|
|
||||||
assert(f1('=======', '^(=*)=%1$') == '=======')
|
|
||||||
assert(not string.match('==========', '^([=]*)=%1$'))
|
|
||||||
|
|
||||||
local function range (i, j)
|
|
||||||
if i <= j then
|
|
||||||
return i, range(i+1, j)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local abc = string.char(range(0, 127)) .. string.char(range(128, 255));
|
|
||||||
|
|
||||||
assert(string.len(abc) == 256)
|
|
||||||
|
|
||||||
local function strset (p)
|
|
||||||
local res = {s=''}
|
|
||||||
string.gsub(abc, p, function (c) res.s = res.s .. c end)
|
|
||||||
return res.s
|
|
||||||
end;
|
|
||||||
|
|
||||||
assert(string.len(strset('[\200-\210]')) == 11)
|
|
||||||
|
|
||||||
assert(strset('[a-z]') == "abcdefghijklmnopqrstuvwxyz")
|
|
||||||
assert(strset('[a-z%d]') == strset('[%da-uu-z]'))
|
|
||||||
assert(strset('[a-]') == "-a")
|
|
||||||
assert(strset('[^%W]') == strset('[%w]'))
|
|
||||||
assert(strset('[]%%]') == '%]')
|
|
||||||
assert(strset('[a%-z]') == '-az')
|
|
||||||
assert(strset('[%^%[%-a%]%-b]') == '-[]^ab')
|
|
||||||
assert(strset('%Z') == strset('[\1-\255]'))
|
|
||||||
assert(strset('.') == strset('[\1-\255%z]'))
|
|
||||||
print('+');
|
|
||||||
|
|
||||||
assert(string.match("alo xyzK", "(%w+)K") == "xyz")
|
|
||||||
assert(string.match("254 K", "(%d*)K") == "")
|
|
||||||
assert(string.match("alo ", "(%w*)$") == "")
|
|
||||||
assert(not string.match("alo ", "(%w+)$"))
|
|
||||||
assert(string.find("(álo)", "%(á") == 1)
|
|
||||||
local a, b, c, d, e = string.match("âlo alo", "^(((.).).* (%w*))$")
|
|
||||||
assert(a == 'âlo alo' and b == 'âl' and c == 'â' and d == 'alo' and e == nil)
|
|
||||||
a, b, c, d = string.match('0123456789', '(.+(.?)())')
|
|
||||||
assert(a == '0123456789' and b == '' and c == 11 and d == nil)
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
assert(string.gsub('ülo ülo', 'ü', 'x') == 'xlo xlo')
|
|
||||||
assert(string.gsub('alo úlo ', ' +$', '') == 'alo úlo') -- trim
|
|
||||||
assert(string.gsub(' alo alo ', '^%s*(.-)%s*$', '%1') == 'alo alo') -- double trim
|
|
||||||
assert(string.gsub('alo alo \n 123\n ', '%s+', ' ') == 'alo alo 123 ')
|
|
||||||
local t = "abç d"
|
|
||||||
a, b = string.gsub(t, '(.)', '%1@')
|
|
||||||
assert('@'..a == string.gsub(t, '', '@') and b == 5)
|
|
||||||
a, b = string.gsub('abçd', '(.)', '%0@', 2)
|
|
||||||
assert(a == 'a@b@çd' and b == 2)
|
|
||||||
assert(string.gsub('alo alo', '()[al]', '%1') == '12o 56o')
|
|
||||||
assert(string.gsub("abc=xyz", "(%w*)(%p)(%w+)", "%3%2%1-%0") ==
|
|
||||||
"xyz=abc-abc=xyz")
|
|
||||||
assert(string.gsub("abc", "%w", "%1%0") == "aabbcc")
|
|
||||||
assert(string.gsub("abc", "%w+", "%0%1") == "abcabc")
|
|
||||||
assert(string.gsub('áéí', '$', '\0óú') == 'áéí\0óú')
|
|
||||||
assert(string.gsub('', '^', 'r') == 'r')
|
|
||||||
assert(string.gsub('', '$', 'r') == 'r')
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
|
|
||||||
do -- new (5.3.3) semantics for empty matches
|
|
||||||
assert(string.gsub("a b cd", " *", "-") == "-a-b-c-d-")
|
|
||||||
|
|
||||||
local res = ""
|
|
||||||
local sub = "a \nbc\t\td"
|
|
||||||
local i = 1
|
|
||||||
for p, e in string.gmatch(sub, "()%s*()") do
|
|
||||||
res = res .. string.sub(sub, i, p - 1) .. "-"
|
|
||||||
i = e
|
|
||||||
end
|
|
||||||
assert(res == "-a-b-c-d-")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
assert(string.gsub("um (dois) tres (quatro)", "(%(%w+%))", string.upper) ==
|
|
||||||
"um (DOIS) tres (QUATRO)")
|
|
||||||
|
|
||||||
do
|
|
||||||
local function setglobal (n,v) rawset(_G, n, v) end
|
|
||||||
string.gsub("a=roberto,roberto=a", "(%w+)=(%w%w*)", setglobal)
|
|
||||||
assert(_G.a=="roberto" and _G.roberto=="a")
|
|
||||||
_G.a = nil; _G.roberto = nil
|
|
||||||
end
|
|
||||||
|
|
||||||
function f(a,b) return string.gsub(a,'.',b) end
|
|
||||||
assert(string.gsub("trocar tudo em |teste|b| é |beleza|al|", "|([^|]*)|([^|]*)|", f) ==
|
|
||||||
"trocar tudo em bbbbb é alalalalalal")
|
|
||||||
|
|
||||||
local function dostring (s) return load(s, "")() or "" end
|
|
||||||
assert(string.gsub("alo $a='x'$ novamente $return a$",
|
|
||||||
"$([^$]*)%$",
|
|
||||||
dostring) == "alo novamente x")
|
|
||||||
|
|
||||||
local x = string.gsub("$x=string.gsub('alo', '.', string.upper)$ assim vai para $return x$",
|
|
||||||
"$([^$]*)%$", dostring)
|
|
||||||
assert(x == ' assim vai para ALO')
|
|
||||||
_G.a, _G.x = nil
|
|
||||||
|
|
||||||
local t = {}
|
|
||||||
local s = 'a alo jose joao'
|
|
||||||
local r = string.gsub(s, '()(%w+)()', function (a,w,b)
|
|
||||||
assert(string.len(w) == b-a);
|
|
||||||
t[a] = b-a;
|
|
||||||
end)
|
|
||||||
assert(s == r and t[1] == 1 and t[3] == 3 and t[7] == 4 and t[13] == 4)
|
|
||||||
|
|
||||||
|
|
||||||
local function isbalanced (s)
|
|
||||||
return not string.find(string.gsub(s, "%b()", ""), "[()]")
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(isbalanced("(9 ((8))(\0) 7) \0\0 a b ()(c)() a"))
|
|
||||||
assert(not isbalanced("(9 ((8) 7) a b (\0 c) a"))
|
|
||||||
assert(string.gsub("alo 'oi' alo", "%b''", '"') == 'alo " alo')
|
|
||||||
|
|
||||||
|
|
||||||
local t = {"apple", "orange", "lime"; n=0}
|
|
||||||
assert(string.gsub("x and x and x", "x", function () t.n=t.n+1; return t[t.n] end)
|
|
||||||
== "apple and orange and lime")
|
|
||||||
|
|
||||||
t = {n=0}
|
|
||||||
string.gsub("first second word", "%w%w*", function (w) t.n=t.n+1; t[t.n] = w end)
|
|
||||||
assert(t[1] == "first" and t[2] == "second" and t[3] == "word" and t.n == 3)
|
|
||||||
|
|
||||||
t = {n=0}
|
|
||||||
assert(string.gsub("first second word", "%w+",
|
|
||||||
function (w) t.n=t.n+1; t[t.n] = w end, 2) == "first second word")
|
|
||||||
assert(t[1] == "first" and t[2] == "second" and t[3] == undef)
|
|
||||||
|
|
||||||
checkerror("invalid replacement value %(a table%)",
|
|
||||||
string.gsub, "alo", ".", {a = {}})
|
|
||||||
checkerror("invalid capture index %%2", string.gsub, "alo", ".", "%2")
|
|
||||||
checkerror("invalid capture index %%0", string.gsub, "alo", "(%0)", "a")
|
|
||||||
checkerror("invalid capture index %%1", string.gsub, "alo", "(%1)", "a")
|
|
||||||
checkerror("invalid use of '%%'", string.gsub, "alo", ".", "%x")
|
|
||||||
|
|
||||||
|
|
||||||
if not _soft then
|
|
||||||
print("big strings")
|
|
||||||
local a = string.rep('a', 300000)
|
|
||||||
assert(string.find(a, '^a*.?$'))
|
|
||||||
assert(not string.find(a, '^a*.?b$'))
|
|
||||||
assert(string.find(a, '^a-.?$'))
|
|
||||||
|
|
||||||
-- bug in 5.1.2
|
|
||||||
a = string.rep('a', 10000) .. string.rep('b', 10000)
|
|
||||||
assert(not pcall(string.gsub, a, 'b'))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- recursive nest of gsubs
|
|
||||||
local function rev (s)
|
|
||||||
return string.gsub(s, "(.)(.+)", function (c,s1) return rev(s1)..c end)
|
|
||||||
end
|
|
||||||
|
|
||||||
local x = "abcdef"
|
|
||||||
assert(rev(rev(x)) == x)
|
|
||||||
|
|
||||||
|
|
||||||
-- gsub with tables
|
|
||||||
assert(string.gsub("alo alo", ".", {}) == "alo alo")
|
|
||||||
assert(string.gsub("alo alo", "(.)", {a="AA", l=""}) == "AAo AAo")
|
|
||||||
assert(string.gsub("alo alo", "(.).", {a="AA", l="K"}) == "AAo AAo")
|
|
||||||
assert(string.gsub("alo alo", "((.)(.?))", {al="AA", o=false}) == "AAo AAo")
|
|
||||||
|
|
||||||
assert(string.gsub("alo alo", "().", {'x','yy','zzz'}) == "xyyzzz alo")
|
|
||||||
|
|
||||||
t = {}; setmetatable(t, {__index = function (t,s) return string.upper(s) end})
|
|
||||||
assert(string.gsub("a alo b hi", "%w%w+", t) == "a ALO b HI")
|
|
||||||
|
|
||||||
|
|
||||||
-- tests for gmatch
|
|
||||||
local a = 0
|
|
||||||
for i in string.gmatch('abcde', '()') do assert(i == a+1); a=i end
|
|
||||||
assert(a==6)
|
|
||||||
|
|
||||||
t = {n=0}
|
|
||||||
for w in string.gmatch("first second word", "%w+") do
|
|
||||||
t.n=t.n+1; t[t.n] = w
|
|
||||||
end
|
|
||||||
assert(t[1] == "first" and t[2] == "second" and t[3] == "word")
|
|
||||||
|
|
||||||
t = {3, 6, 9}
|
|
||||||
for i in string.gmatch ("xuxx uu ppar r", "()(.)%2") do
|
|
||||||
assert(i == table.remove(t, 1))
|
|
||||||
end
|
|
||||||
assert(#t == 0)
|
|
||||||
|
|
||||||
t = {}
|
|
||||||
for i,j in string.gmatch("13 14 10 = 11, 15= 16, 22=23", "(%d+)%s*=%s*(%d+)") do
|
|
||||||
t[tonumber(i)] = tonumber(j)
|
|
||||||
end
|
|
||||||
a = 0
|
|
||||||
for k,v in pairs(t) do assert(k+1 == v+0); a=a+1 end
|
|
||||||
assert(a == 3)
|
|
||||||
|
|
||||||
|
|
||||||
do -- init parameter in gmatch
|
|
||||||
local s = 0
|
|
||||||
for k in string.gmatch("10 20 30", "%d+", 3) do
|
|
||||||
s = s + tonumber(k)
|
|
||||||
end
|
|
||||||
assert(s == 50)
|
|
||||||
|
|
||||||
s = 0
|
|
||||||
for k in string.gmatch("11 21 31", "%d+", -4) do
|
|
||||||
s = s + tonumber(k)
|
|
||||||
end
|
|
||||||
assert(s == 32)
|
|
||||||
|
|
||||||
-- there is an empty string at the end of the subject
|
|
||||||
s = 0
|
|
||||||
for k in string.gmatch("11 21 31", "%w*", 9) do
|
|
||||||
s = s + 1
|
|
||||||
end
|
|
||||||
assert(s == 1)
|
|
||||||
|
|
||||||
-- there are no empty strings after the end of the subject
|
|
||||||
s = 0
|
|
||||||
for k in string.gmatch("11 21 31", "%w*", 10) do
|
|
||||||
s = s + 1
|
|
||||||
end
|
|
||||||
assert(s == 0)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- tests for `%f' (`frontiers')
|
|
||||||
|
|
||||||
assert(string.gsub("aaa aa a aaa a", "%f[%w]a", "x") == "xaa xa x xaa x")
|
|
||||||
assert(string.gsub("[[]] [][] [[[[", "%f[[].", "x") == "x[]] x]x] x[[[")
|
|
||||||
assert(string.gsub("01abc45de3", "%f[%d]", ".") == ".01abc.45de.3")
|
|
||||||
assert(string.gsub("01abc45 de3x", "%f[%D]%w", ".") == "01.bc45 de3.")
|
|
||||||
assert(string.gsub("function", "%f[\1-\255]%w", ".") == ".unction")
|
|
||||||
assert(string.gsub("function", "%f[^\1-\255]", ".") == "function.")
|
|
||||||
|
|
||||||
assert(string.find("a", "%f[a]") == 1)
|
|
||||||
assert(string.find("a", "%f[^%z]") == 1)
|
|
||||||
assert(string.find("a", "%f[^%l]") == 2)
|
|
||||||
assert(string.find("aba", "%f[a%z]") == 3)
|
|
||||||
assert(string.find("aba", "%f[%z]") == 4)
|
|
||||||
assert(not string.find("aba", "%f[%l%z]"))
|
|
||||||
assert(not string.find("aba", "%f[^%l%z]"))
|
|
||||||
|
|
||||||
local i, e = string.find(" alo aalo allo", "%f[%S].-%f[%s].-%f[%S]")
|
|
||||||
assert(i == 2 and e == 5)
|
|
||||||
local k = string.match(" alo aalo allo", "%f[%S](.-%f[%s].-%f[%S])")
|
|
||||||
assert(k == 'alo ')
|
|
||||||
|
|
||||||
local a = {1, 5, 9, 14, 17,}
|
|
||||||
for k in string.gmatch("alo alo th02 is 1hat", "()%f[%w%d]") do
|
|
||||||
assert(table.remove(a, 1) == k)
|
|
||||||
end
|
|
||||||
assert(#a == 0)
|
|
||||||
|
|
||||||
|
|
||||||
-- malformed patterns
|
|
||||||
local function malform (p, m)
|
|
||||||
m = m or "malformed"
|
|
||||||
local r, msg = pcall(string.find, "a", p)
|
|
||||||
assert(not r and string.find(msg, m))
|
|
||||||
end
|
|
||||||
|
|
||||||
malform("(.", "unfinished capture")
|
|
||||||
malform(".)", "invalid pattern capture")
|
|
||||||
malform("[a")
|
|
||||||
malform("[]")
|
|
||||||
malform("[^]")
|
|
||||||
malform("[a%]")
|
|
||||||
malform("[a%")
|
|
||||||
malform("%b")
|
|
||||||
malform("%ba")
|
|
||||||
malform("%")
|
|
||||||
malform("%f", "missing")
|
|
||||||
|
|
||||||
-- \0 in patterns
|
|
||||||
assert(string.match("ab\0\1\2c", "[\0-\2]+") == "\0\1\2")
|
|
||||||
assert(string.match("ab\0\1\2c", "[\0-\0]+") == "\0")
|
|
||||||
assert(string.find("b$a", "$\0?") == 2)
|
|
||||||
assert(string.find("abc\0efg", "%\0") == 4)
|
|
||||||
assert(string.match("abc\0efg\0\1e\1g", "%b\0\1") == "\0efg\0\1e\1")
|
|
||||||
assert(string.match("abc\0\0\0", "%\0+") == "\0\0\0")
|
|
||||||
assert(string.match("abc\0\0\0", "%\0%\0?") == "\0\0")
|
|
||||||
|
|
||||||
-- magic char after \0
|
|
||||||
assert(string.find("abc\0\0","\0.") == 4)
|
|
||||||
assert(string.find("abcx\0\0abc\0abc","x\0\0abc\0a.") == 4)
|
|
||||||
|
|
||||||
|
|
||||||
do -- test reuse of original string in gsub
|
|
||||||
local s = string.rep("a", 100)
|
|
||||||
local r = string.gsub(s, "b", "c") -- no match
|
|
||||||
assert(string.format("%p", s) == string.format("%p", r))
|
|
||||||
|
|
||||||
r = string.gsub(s, ".", {x = "y"}) -- no substitutions
|
|
||||||
assert(string.format("%p", s) == string.format("%p", r))
|
|
||||||
|
|
||||||
local count = 0
|
|
||||||
r = string.gsub(s, ".", function (x)
|
|
||||||
assert(x == "a")
|
|
||||||
count = count + 1
|
|
||||||
return nil -- no substitution
|
|
||||||
end)
|
|
||||||
r = string.gsub(r, ".", {b = 'x'}) -- "a" is not a key; no subst.
|
|
||||||
assert(count == 100)
|
|
||||||
assert(string.format("%p", s) == string.format("%p", r))
|
|
||||||
|
|
||||||
count = 0
|
|
||||||
r = string.gsub(s, ".", function (x)
|
|
||||||
assert(x == "a")
|
|
||||||
count = count + 1
|
|
||||||
return x -- substitution...
|
|
||||||
end)
|
|
||||||
assert(count == 100)
|
|
||||||
-- no reuse in this case
|
|
||||||
assert(r == s and string.format("%p", s) ~= string.format("%p", r))
|
|
||||||
end
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
|
|
||||||
@ -1,311 +0,0 @@
|
|||||||
-- $Id: testes/sort.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print "testing (parts of) table library"
|
|
||||||
|
|
||||||
print "testing unpack"
|
|
||||||
|
|
||||||
local unpack = table.unpack
|
|
||||||
|
|
||||||
local maxI = math.maxinteger
|
|
||||||
local minI = math.mininteger
|
|
||||||
|
|
||||||
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local s, err = pcall(f, ...)
|
|
||||||
assert(not s and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
checkerror("wrong number of arguments", table.insert, {}, 2, 3, 4)
|
|
||||||
|
|
||||||
local x,y,z,a,n
|
|
||||||
a = {}; local lim = _soft and 200 or 2000
|
|
||||||
for i=1, lim do a[i]=i end
|
|
||||||
assert(select(lim, unpack(a)) == lim and select('#', unpack(a)) == lim)
|
|
||||||
x = unpack(a)
|
|
||||||
assert(x == 1)
|
|
||||||
x = {unpack(a)}
|
|
||||||
assert(#x == lim and x[1] == 1 and x[lim] == lim)
|
|
||||||
x = {unpack(a, lim-2)}
|
|
||||||
assert(#x == 3 and x[1] == lim-2 and x[3] == lim)
|
|
||||||
x = {unpack(a, 10, 6)}
|
|
||||||
assert(next(x) == nil) -- no elements
|
|
||||||
x = {unpack(a, 11, 10)}
|
|
||||||
assert(next(x) == nil) -- no elements
|
|
||||||
x,y = unpack(a, 10, 10)
|
|
||||||
assert(x == 10 and y == nil)
|
|
||||||
x,y,z = unpack(a, 10, 11)
|
|
||||||
assert(x == 10 and y == 11 and z == nil)
|
|
||||||
a,x = unpack{1}
|
|
||||||
assert(a==1 and x==nil)
|
|
||||||
a,x = unpack({1,2}, 1, 1)
|
|
||||||
assert(a==1 and x==nil)
|
|
||||||
|
|
||||||
do
|
|
||||||
local maxi = (1 << 31) - 1 -- maximum value for an int (usually)
|
|
||||||
local mini = -(1 << 31) -- minimum value for an int (usually)
|
|
||||||
checkerror("too many results", unpack, {}, 0, maxi)
|
|
||||||
checkerror("too many results", unpack, {}, 1, maxi)
|
|
||||||
checkerror("too many results", unpack, {}, 0, maxI)
|
|
||||||
checkerror("too many results", unpack, {}, 1, maxI)
|
|
||||||
checkerror("too many results", unpack, {}, mini, maxi)
|
|
||||||
checkerror("too many results", unpack, {}, -maxi, maxi)
|
|
||||||
checkerror("too many results", unpack, {}, minI, maxI)
|
|
||||||
unpack({}, maxi, 0)
|
|
||||||
unpack({}, maxi, 1)
|
|
||||||
unpack({}, maxI, minI)
|
|
||||||
pcall(unpack, {}, 1, maxi + 1)
|
|
||||||
local a, b = unpack({[maxi] = 20}, maxi, maxi)
|
|
||||||
assert(a == 20 and b == nil)
|
|
||||||
a, b = unpack({[maxi] = 20}, maxi - 1, maxi)
|
|
||||||
assert(a == nil and b == 20)
|
|
||||||
local t = {[maxI - 1] = 12, [maxI] = 23}
|
|
||||||
a, b = unpack(t, maxI - 1, maxI); assert(a == 12 and b == 23)
|
|
||||||
a, b = unpack(t, maxI, maxI); assert(a == 23 and b == nil)
|
|
||||||
a, b = unpack(t, maxI, maxI - 1); assert(a == nil and b == nil)
|
|
||||||
t = {[minI] = 12.3, [minI + 1] = 23.5}
|
|
||||||
a, b = unpack(t, minI, minI + 1); assert(a == 12.3 and b == 23.5)
|
|
||||||
a, b = unpack(t, minI, minI); assert(a == 12.3 and b == nil)
|
|
||||||
a, b = unpack(t, minI + 1, minI); assert(a == nil and b == nil)
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- length is not an integer
|
|
||||||
local t = setmetatable({}, {__len = function () return 'abc' end})
|
|
||||||
assert(#t == 'abc')
|
|
||||||
checkerror("object length is not an integer", table.insert, t, 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
print "testing pack"
|
|
||||||
|
|
||||||
a = table.pack()
|
|
||||||
assert(a[1] == undef and a.n == 0)
|
|
||||||
|
|
||||||
a = table.pack(table)
|
|
||||||
assert(a[1] == table and a.n == 1)
|
|
||||||
|
|
||||||
a = table.pack(nil, nil, nil, nil)
|
|
||||||
assert(a[1] == nil and a.n == 4)
|
|
||||||
|
|
||||||
|
|
||||||
-- testing move
|
|
||||||
do
|
|
||||||
|
|
||||||
checkerror("table expected", table.move, 1, 2, 3, 4)
|
|
||||||
|
|
||||||
local function eqT (a, b)
|
|
||||||
for k, v in pairs(a) do assert(b[k] == v) end
|
|
||||||
for k, v in pairs(b) do assert(a[k] == v) end
|
|
||||||
end
|
|
||||||
|
|
||||||
local a = table.move({10,20,30}, 1, 3, 2) -- move forward
|
|
||||||
eqT(a, {10,10,20,30})
|
|
||||||
|
|
||||||
-- move forward with overlap of 1
|
|
||||||
a = table.move({10, 20, 30}, 1, 3, 3)
|
|
||||||
eqT(a, {10, 20, 10, 20, 30})
|
|
||||||
|
|
||||||
-- moving to the same table (not being explicit about it)
|
|
||||||
a = {10, 20, 30, 40}
|
|
||||||
table.move(a, 1, 4, 2, a)
|
|
||||||
eqT(a, {10, 10, 20, 30, 40})
|
|
||||||
|
|
||||||
a = table.move({10,20,30}, 2, 3, 1) -- move backward
|
|
||||||
eqT(a, {20,30,30})
|
|
||||||
|
|
||||||
a = {} -- move to new table
|
|
||||||
assert(table.move({10,20,30}, 1, 3, 1, a) == a)
|
|
||||||
eqT(a, {10,20,30})
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
assert(table.move({10,20,30}, 1, 0, 3, a) == a) -- empty move (no move)
|
|
||||||
eqT(a, {})
|
|
||||||
|
|
||||||
a = table.move({10,20,30}, 1, 10, 1) -- move to the same place
|
|
||||||
eqT(a, {10,20,30})
|
|
||||||
|
|
||||||
-- moving on the fringes
|
|
||||||
a = table.move({[maxI - 2] = 1, [maxI - 1] = 2, [maxI] = 3},
|
|
||||||
maxI - 2, maxI, -10, {})
|
|
||||||
eqT(a, {[-10] = 1, [-9] = 2, [-8] = 3})
|
|
||||||
|
|
||||||
a = table.move({[minI] = 1, [minI + 1] = 2, [minI + 2] = 3},
|
|
||||||
minI, minI + 2, -10, {})
|
|
||||||
eqT(a, {[-10] = 1, [-9] = 2, [-8] = 3})
|
|
||||||
|
|
||||||
a = table.move({45}, 1, 1, maxI)
|
|
||||||
eqT(a, {45, [maxI] = 45})
|
|
||||||
|
|
||||||
a = table.move({[maxI] = 100}, maxI, maxI, minI)
|
|
||||||
eqT(a, {[minI] = 100, [maxI] = 100})
|
|
||||||
|
|
||||||
a = table.move({[minI] = 100}, minI, minI, maxI)
|
|
||||||
eqT(a, {[minI] = 100, [maxI] = 100})
|
|
||||||
|
|
||||||
a = setmetatable({}, {
|
|
||||||
__index = function (_,k) return k * 10 end,
|
|
||||||
__newindex = error})
|
|
||||||
local b = table.move(a, 1, 10, 3, {})
|
|
||||||
eqT(a, {})
|
|
||||||
eqT(b, {nil,nil,10,20,30,40,50,60,70,80,90,100})
|
|
||||||
|
|
||||||
b = setmetatable({""}, {
|
|
||||||
__index = error,
|
|
||||||
__newindex = function (t,k,v)
|
|
||||||
t[1] = string.format("%s(%d,%d)", t[1], k, v)
|
|
||||||
end})
|
|
||||||
table.move(a, 10, 13, 3, b)
|
|
||||||
assert(b[1] == "(3,100)(4,110)(5,120)(6,130)")
|
|
||||||
local stat, msg = pcall(table.move, b, 10, 13, 3, b)
|
|
||||||
assert(not stat and msg == b)
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
-- for very long moves, just check initial accesses and interrupt
|
|
||||||
-- move with an error
|
|
||||||
local function checkmove (f, e, t, x, y)
|
|
||||||
local pos1, pos2
|
|
||||||
local a = setmetatable({}, {
|
|
||||||
__index = function (_,k) pos1 = k end,
|
|
||||||
__newindex = function (_,k) pos2 = k; error() end, })
|
|
||||||
local st, msg = pcall(table.move, a, f, e, t)
|
|
||||||
assert(not st and not msg and pos1 == x and pos2 == y)
|
|
||||||
end
|
|
||||||
checkmove(1, maxI, 0, 1, 0)
|
|
||||||
checkmove(0, maxI - 1, 1, maxI - 1, maxI)
|
|
||||||
checkmove(minI, -2, -5, -2, maxI - 6)
|
|
||||||
checkmove(minI + 1, -1, -2, -1, maxI - 3)
|
|
||||||
checkmove(minI, -2, 0, minI, 0) -- non overlapping
|
|
||||||
checkmove(minI + 1, -1, 1, minI + 1, 1) -- non overlapping
|
|
||||||
end
|
|
||||||
|
|
||||||
checkerror("too many", table.move, {}, 0, maxI, 1)
|
|
||||||
checkerror("too many", table.move, {}, -1, maxI - 1, 1)
|
|
||||||
checkerror("too many", table.move, {}, minI, -1, 1)
|
|
||||||
checkerror("too many", table.move, {}, minI, maxI, 1)
|
|
||||||
checkerror("wrap around", table.move, {}, 1, maxI, 2)
|
|
||||||
checkerror("wrap around", table.move, {}, 1, 2, maxI)
|
|
||||||
checkerror("wrap around", table.move, {}, minI, -2, 2)
|
|
||||||
|
|
||||||
|
|
||||||
print"testing sort"
|
|
||||||
|
|
||||||
|
|
||||||
-- strange lengths
|
|
||||||
local a = setmetatable({}, {__len = function () return -1 end})
|
|
||||||
assert(#a == -1)
|
|
||||||
table.sort(a, error) -- should not compare anything
|
|
||||||
a = setmetatable({}, {__len = function () return maxI end})
|
|
||||||
checkerror("too big", table.sort, a)
|
|
||||||
|
|
||||||
-- test checks for invalid order functions
|
|
||||||
local function check (t)
|
|
||||||
local function f(a, b) assert(a and b); return true end
|
|
||||||
checkerror("invalid order function", table.sort, t, f)
|
|
||||||
end
|
|
||||||
|
|
||||||
check{1,2,3,4}
|
|
||||||
check{1,2,3,4,5}
|
|
||||||
check{1,2,3,4,5,6}
|
|
||||||
|
|
||||||
|
|
||||||
function check (a, f)
|
|
||||||
f = f or function (x,y) return x<y end;
|
|
||||||
for n = #a, 2, -1 do
|
|
||||||
assert(not f(a[n], a[n-1]))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
a = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
|
|
||||||
"Oct", "Nov", "Dec"}
|
|
||||||
|
|
||||||
table.sort(a)
|
|
||||||
check(a)
|
|
||||||
|
|
||||||
local function perm (s, n)
|
|
||||||
n = n or #s
|
|
||||||
if n == 1 then
|
|
||||||
local t = {unpack(s)}
|
|
||||||
table.sort(t)
|
|
||||||
check(t)
|
|
||||||
else
|
|
||||||
for i = 1, n do
|
|
||||||
s[i], s[n] = s[n], s[i]
|
|
||||||
perm(s, n - 1)
|
|
||||||
s[i], s[n] = s[n], s[i]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
perm{}
|
|
||||||
perm{1}
|
|
||||||
perm{1,2}
|
|
||||||
perm{1,2,3}
|
|
||||||
perm{1,2,3,4}
|
|
||||||
perm{2,2,3,4}
|
|
||||||
perm{1,2,3,4,5}
|
|
||||||
perm{1,2,3,3,5}
|
|
||||||
perm{1,2,3,4,5,6}
|
|
||||||
perm{2,2,3,3,5,6}
|
|
||||||
|
|
||||||
local function timesort (a, n, func, msg, pre)
|
|
||||||
local x = os.clock()
|
|
||||||
table.sort(a, func)
|
|
||||||
x = (os.clock() - x) * 1000
|
|
||||||
pre = pre or ""
|
|
||||||
print(string.format("%ssorting %d %s elements in %.2f msec.", pre, n, msg, x))
|
|
||||||
check(a, func)
|
|
||||||
end
|
|
||||||
|
|
||||||
local limit = 50000
|
|
||||||
if _soft then limit = 5000 end
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
for i=1,limit do
|
|
||||||
a[i] = math.random()
|
|
||||||
end
|
|
||||||
|
|
||||||
timesort(a, limit, nil, "random")
|
|
||||||
|
|
||||||
timesort(a, limit, nil, "sorted", "re-")
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
for i=1,limit do
|
|
||||||
a[i] = math.random()
|
|
||||||
end
|
|
||||||
|
|
||||||
local x = os.clock(); local i = 0
|
|
||||||
table.sort(a, function(x,y) i=i+1; return y<x end)
|
|
||||||
x = (os.clock() - x) * 1000
|
|
||||||
print(string.format("Invert-sorting other %d elements in %.2f msec., with %i comparisons",
|
|
||||||
limit, x, i))
|
|
||||||
check(a, function(x,y) return y<x end)
|
|
||||||
|
|
||||||
|
|
||||||
table.sort{} -- empty array
|
|
||||||
|
|
||||||
for i=1,limit do a[i] = false end
|
|
||||||
timesort(a, limit, function(x,y) return nil end, "equal")
|
|
||||||
|
|
||||||
for i,v in pairs(a) do assert(v == false) end
|
|
||||||
|
|
||||||
AA = {"álo", "\0first :-)", "alo", "then this one", "45", "and a new"}
|
|
||||||
table.sort(AA)
|
|
||||||
check(AA)
|
|
||||||
|
|
||||||
table.sort(AA, function (x, y)
|
|
||||||
load(string.format("AA[%q] = ''", x), "")()
|
|
||||||
collectgarbage()
|
|
||||||
return x<y
|
|
||||||
end)
|
|
||||||
|
|
||||||
_G.AA = nil
|
|
||||||
|
|
||||||
local tt = {__lt = function (a,b) return a.val < b.val end}
|
|
||||||
a = {}
|
|
||||||
for i=1,10 do a[i] = {val=math.random(100)}; setmetatable(a[i], tt); end
|
|
||||||
table.sort(a)
|
|
||||||
check(a, tt.__lt)
|
|
||||||
check(a)
|
|
||||||
|
|
||||||
print"OK"
|
|
||||||
@ -1,523 +0,0 @@
|
|||||||
-- $Id: testes/strings.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing strings and string library')
|
|
||||||
|
|
||||||
local maxi <const> = math.maxinteger
|
|
||||||
local mini <const> = math.mininteger
|
|
||||||
|
|
||||||
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local s, err = pcall(f, ...)
|
|
||||||
assert(not s and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing string comparisons
|
|
||||||
assert('alo' < 'alo1')
|
|
||||||
assert('' < 'a')
|
|
||||||
assert('alo\0alo' < 'alo\0b')
|
|
||||||
assert('alo\0alo\0\0' > 'alo\0alo\0')
|
|
||||||
assert('alo' < 'alo\0')
|
|
||||||
assert('alo\0' > 'alo')
|
|
||||||
assert('\0' < '\1')
|
|
||||||
assert('\0\0' < '\0\1')
|
|
||||||
assert('\1\0a\0a' <= '\1\0a\0a')
|
|
||||||
assert(not ('\1\0a\0b' <= '\1\0a\0a'))
|
|
||||||
assert('\0\0\0' < '\0\0\0\0')
|
|
||||||
assert(not('\0\0\0\0' < '\0\0\0'))
|
|
||||||
assert('\0\0\0' <= '\0\0\0\0')
|
|
||||||
assert(not('\0\0\0\0' <= '\0\0\0'))
|
|
||||||
assert('\0\0\0' <= '\0\0\0')
|
|
||||||
assert('\0\0\0' >= '\0\0\0')
|
|
||||||
assert(not ('\0\0b' < '\0\0a\0'))
|
|
||||||
|
|
||||||
-- testing string.sub
|
|
||||||
assert(string.sub("123456789",2,4) == "234")
|
|
||||||
assert(string.sub("123456789",7) == "789")
|
|
||||||
assert(string.sub("123456789",7,6) == "")
|
|
||||||
assert(string.sub("123456789",7,7) == "7")
|
|
||||||
assert(string.sub("123456789",0,0) == "")
|
|
||||||
assert(string.sub("123456789",-10,10) == "123456789")
|
|
||||||
assert(string.sub("123456789",1,9) == "123456789")
|
|
||||||
assert(string.sub("123456789",-10,-20) == "")
|
|
||||||
assert(string.sub("123456789",-1) == "9")
|
|
||||||
assert(string.sub("123456789",-4) == "6789")
|
|
||||||
assert(string.sub("123456789",-6, -4) == "456")
|
|
||||||
assert(string.sub("123456789", mini, -4) == "123456")
|
|
||||||
assert(string.sub("123456789", mini, maxi) == "123456789")
|
|
||||||
assert(string.sub("123456789", mini, mini) == "")
|
|
||||||
assert(string.sub("\000123456789",3,5) == "234")
|
|
||||||
assert(("\000123456789"):sub(8) == "789")
|
|
||||||
|
|
||||||
-- testing string.find
|
|
||||||
assert(string.find("123456789", "345") == 3)
|
|
||||||
local a,b = string.find("123456789", "345")
|
|
||||||
assert(string.sub("123456789", a, b) == "345")
|
|
||||||
assert(string.find("1234567890123456789", "345", 3) == 3)
|
|
||||||
assert(string.find("1234567890123456789", "345", 4) == 13)
|
|
||||||
assert(not string.find("1234567890123456789", "346", 4))
|
|
||||||
assert(string.find("1234567890123456789", ".45", -9) == 13)
|
|
||||||
assert(not string.find("abcdefg", "\0", 5, 1))
|
|
||||||
assert(string.find("", "") == 1)
|
|
||||||
assert(string.find("", "", 1) == 1)
|
|
||||||
assert(not string.find("", "", 2))
|
|
||||||
assert(not string.find('', 'aaa', 1))
|
|
||||||
assert(('alo(.)alo'):find('(.)', 1, 1) == 4)
|
|
||||||
|
|
||||||
assert(string.len("") == 0)
|
|
||||||
assert(string.len("\0\0\0") == 3)
|
|
||||||
assert(string.len("1234567890") == 10)
|
|
||||||
|
|
||||||
assert(#"" == 0)
|
|
||||||
assert(#"\0\0\0" == 3)
|
|
||||||
assert(#"1234567890" == 10)
|
|
||||||
|
|
||||||
-- testing string.byte/string.char
|
|
||||||
assert(string.byte("a") == 97)
|
|
||||||
assert(string.byte("\xe4") > 127)
|
|
||||||
assert(string.byte(string.char(255)) == 255)
|
|
||||||
assert(string.byte(string.char(0)) == 0)
|
|
||||||
assert(string.byte("\0") == 0)
|
|
||||||
assert(string.byte("\0\0alo\0x", -1) == string.byte('x'))
|
|
||||||
assert(string.byte("ba", 2) == 97)
|
|
||||||
assert(string.byte("\n\n", 2, -1) == 10)
|
|
||||||
assert(string.byte("\n\n", 2, 2) == 10)
|
|
||||||
assert(string.byte("") == nil)
|
|
||||||
assert(string.byte("hi", -3) == nil)
|
|
||||||
assert(string.byte("hi", 3) == nil)
|
|
||||||
assert(string.byte("hi", 9, 10) == nil)
|
|
||||||
assert(string.byte("hi", 2, 1) == nil)
|
|
||||||
assert(string.char() == "")
|
|
||||||
assert(string.char(0, 255, 0) == "\0\255\0")
|
|
||||||
assert(string.char(0, string.byte("\xe4"), 0) == "\0\xe4\0")
|
|
||||||
assert(string.char(string.byte("\xe4l\0óu", 1, -1)) == "\xe4l\0óu")
|
|
||||||
assert(string.char(string.byte("\xe4l\0óu", 1, 0)) == "")
|
|
||||||
assert(string.char(string.byte("\xe4l\0óu", -10, 100)) == "\xe4l\0óu")
|
|
||||||
|
|
||||||
checkerror("out of range", string.char, 256)
|
|
||||||
checkerror("out of range", string.char, -1)
|
|
||||||
checkerror("out of range", string.char, math.maxinteger)
|
|
||||||
checkerror("out of range", string.char, math.mininteger)
|
|
||||||
|
|
||||||
assert(string.upper("ab\0c") == "AB\0C")
|
|
||||||
assert(string.lower("\0ABCc%$") == "\0abcc%$")
|
|
||||||
assert(string.rep('teste', 0) == '')
|
|
||||||
assert(string.rep('tés\00tê', 2) == 'tés\0têtés\000tê')
|
|
||||||
assert(string.rep('', 10) == '')
|
|
||||||
|
|
||||||
if string.packsize("i") == 4 then
|
|
||||||
-- result length would be 2^31 (int overflow)
|
|
||||||
checkerror("too large", string.rep, 'aa', (1 << 30))
|
|
||||||
checkerror("too large", string.rep, 'a', (1 << 30), ',')
|
|
||||||
end
|
|
||||||
|
|
||||||
-- repetitions with separator
|
|
||||||
assert(string.rep('teste', 0, 'xuxu') == '')
|
|
||||||
assert(string.rep('teste', 1, 'xuxu') == 'teste')
|
|
||||||
assert(string.rep('\1\0\1', 2, '\0\0') == '\1\0\1\0\0\1\0\1')
|
|
||||||
assert(string.rep('', 10, '.') == string.rep('.', 9))
|
|
||||||
assert(not pcall(string.rep, "aa", maxi // 2 + 10))
|
|
||||||
assert(not pcall(string.rep, "", maxi // 2 + 10, "aa"))
|
|
||||||
|
|
||||||
assert(string.reverse"" == "")
|
|
||||||
assert(string.reverse"\0\1\2\3" == "\3\2\1\0")
|
|
||||||
assert(string.reverse"\0001234" == "4321\0")
|
|
||||||
|
|
||||||
for i=0,30 do assert(string.len(string.rep('a', i)) == i) end
|
|
||||||
|
|
||||||
assert(type(tostring(nil)) == 'string')
|
|
||||||
assert(type(tostring(12)) == 'string')
|
|
||||||
assert(string.find(tostring{}, 'table:'))
|
|
||||||
assert(string.find(tostring(print), 'function:'))
|
|
||||||
assert(#tostring('\0') == 1)
|
|
||||||
assert(tostring(true) == "true")
|
|
||||||
assert(tostring(false) == "false")
|
|
||||||
assert(tostring(-1203) == "-1203")
|
|
||||||
assert(tostring(1203.125) == "1203.125")
|
|
||||||
assert(tostring(-0.5) == "-0.5")
|
|
||||||
assert(tostring(-32767) == "-32767")
|
|
||||||
if math.tointeger(2147483647) then -- no overflow? (32 bits)
|
|
||||||
assert(tostring(-2147483647) == "-2147483647")
|
|
||||||
end
|
|
||||||
if math.tointeger(4611686018427387904) then -- no overflow? (64 bits)
|
|
||||||
assert(tostring(4611686018427387904) == "4611686018427387904")
|
|
||||||
assert(tostring(-4611686018427387904) == "-4611686018427387904")
|
|
||||||
end
|
|
||||||
|
|
||||||
if tostring(0.0) == "0.0" then -- "standard" coercion float->string
|
|
||||||
assert('' .. 12 == '12' and 12.0 .. '' == '12.0')
|
|
||||||
assert(tostring(-1203 + 0.0) == "-1203.0")
|
|
||||||
else -- compatible coercion
|
|
||||||
assert(tostring(0.0) == "0")
|
|
||||||
assert('' .. 12 == '12' and 12.0 .. '' == '12')
|
|
||||||
assert(tostring(-1203 + 0.0) == "-1203")
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- tests for '%p' format
|
|
||||||
-- not much to test, as C does not specify what '%p' does.
|
|
||||||
-- ("The value of the pointer is converted to a sequence of printing
|
|
||||||
-- characters, in an implementation-defined manner.")
|
|
||||||
local null = "(null)" -- nulls are formatted by Lua
|
|
||||||
assert(string.format("%p", 4) == null)
|
|
||||||
assert(string.format("%p", true) == null)
|
|
||||||
assert(string.format("%p", nil) == null)
|
|
||||||
assert(string.format("%p", {}) ~= null)
|
|
||||||
assert(string.format("%p", print) ~= null)
|
|
||||||
assert(string.format("%p", coroutine.running()) ~= null)
|
|
||||||
assert(string.format("%p", io.stdin) ~= null)
|
|
||||||
assert(string.format("%p", io.stdin) == string.format("%p", io.stdin))
|
|
||||||
assert(string.format("%p", print) == string.format("%p", print))
|
|
||||||
assert(string.format("%p", print) ~= string.format("%p", assert))
|
|
||||||
|
|
||||||
assert(#string.format("%90p", {}) == 90)
|
|
||||||
assert(#string.format("%-60p", {}) == 60)
|
|
||||||
assert(string.format("%10p", false) == string.rep(" ", 10 - #null) .. null)
|
|
||||||
assert(string.format("%-12p", 1.5) == null .. string.rep(" ", 12 - #null))
|
|
||||||
|
|
||||||
do
|
|
||||||
local t1 = {}; local t2 = {}
|
|
||||||
assert(string.format("%p", t1) ~= string.format("%p", t2))
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- short strings are internalized
|
|
||||||
local s1 = string.rep("a", 10)
|
|
||||||
local s2 = string.rep("aa", 5)
|
|
||||||
assert(string.format("%p", s1) == string.format("%p", s2))
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- long strings aren't internalized
|
|
||||||
local s1 = string.rep("a", 300); local s2 = string.rep("a", 300)
|
|
||||||
assert(string.format("%p", s1) ~= string.format("%p", s2))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
local x = '"ílo"\n\\'
|
|
||||||
assert(string.format('%q%s', x, x) == '"\\"ílo\\"\\\n\\\\""ílo"\n\\')
|
|
||||||
assert(string.format('%q', "\0") == [["\0"]])
|
|
||||||
assert(load(string.format('return %q', x))() == x)
|
|
||||||
x = "\0\1\0023\5\0009"
|
|
||||||
assert(load(string.format('return %q', x))() == x)
|
|
||||||
assert(string.format("\0%c\0%c%x\0", string.byte("\xe4"), string.byte("b"), 140) ==
|
|
||||||
"\0\xe4\0b8c\0")
|
|
||||||
assert(string.format('') == "")
|
|
||||||
assert(string.format("%c",34)..string.format("%c",48)..string.format("%c",90)..string.format("%c",100) ==
|
|
||||||
string.format("%1c%-c%-1c%c", 34, 48, 90, 100))
|
|
||||||
assert(string.format("%s\0 is not \0%s", 'not be', 'be') == 'not be\0 is not \0be')
|
|
||||||
assert(string.format("%%%d %010d", 10, 23) == "%10 0000000023")
|
|
||||||
assert(tonumber(string.format("%f", 10.3)) == 10.3)
|
|
||||||
assert(string.format('"%-50s"', 'a') == '"a' .. string.rep(' ', 49) .. '"')
|
|
||||||
|
|
||||||
assert(string.format("-%.20s.20s", string.rep("%", 2000)) ==
|
|
||||||
"-"..string.rep("%", 20)..".20s")
|
|
||||||
assert(string.format('"-%20s.20s"', string.rep("%", 2000)) ==
|
|
||||||
string.format("%q", "-"..string.rep("%", 2000)..".20s"))
|
|
||||||
|
|
||||||
do
|
|
||||||
local function checkQ (v)
|
|
||||||
local s = string.format("%q", v)
|
|
||||||
local nv = load("return " .. s)()
|
|
||||||
assert(v == nv and math.type(v) == math.type(nv))
|
|
||||||
end
|
|
||||||
checkQ("\0\0\1\255\u{234}")
|
|
||||||
checkQ(math.maxinteger)
|
|
||||||
checkQ(math.mininteger)
|
|
||||||
checkQ(math.pi)
|
|
||||||
checkQ(0.1)
|
|
||||||
checkQ(true)
|
|
||||||
checkQ(nil)
|
|
||||||
checkQ(false)
|
|
||||||
checkQ(math.huge)
|
|
||||||
checkQ(-math.huge)
|
|
||||||
assert(string.format("%q", 0/0) == "(0/0)") -- NaN
|
|
||||||
checkerror("no literal", string.format, "%q", {})
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(string.format("\0%s\0", "\0\0\1") == "\0\0\0\1\0")
|
|
||||||
checkerror("contains zeros", string.format, "%10s", "\0")
|
|
||||||
|
|
||||||
-- format x tostring
|
|
||||||
assert(string.format("%s %s", nil, true) == "nil true")
|
|
||||||
assert(string.format("%s %.4s", false, true) == "false true")
|
|
||||||
assert(string.format("%.3s %.3s", false, true) == "fal tru")
|
|
||||||
local m = setmetatable({}, {__tostring = function () return "hello" end,
|
|
||||||
__name = "hi"})
|
|
||||||
assert(string.format("%s %.10s", m, m) == "hello hello")
|
|
||||||
getmetatable(m).__tostring = nil -- will use '__name' from now on
|
|
||||||
assert(string.format("%.4s", m) == "hi: ")
|
|
||||||
|
|
||||||
getmetatable(m).__tostring = function () return {} end
|
|
||||||
checkerror("'__tostring' must return a string", tostring, m)
|
|
||||||
|
|
||||||
|
|
||||||
assert(string.format("%x", 0.0) == "0")
|
|
||||||
assert(string.format("%02x", 0.0) == "00")
|
|
||||||
assert(string.format("%08X", 0xFFFFFFFF) == "FFFFFFFF")
|
|
||||||
assert(string.format("%+08d", 31501) == "+0031501")
|
|
||||||
assert(string.format("%+08d", -30927) == "-0030927")
|
|
||||||
|
|
||||||
|
|
||||||
do -- longest number that can be formatted
|
|
||||||
local i = 1
|
|
||||||
local j = 10000
|
|
||||||
while i + 1 < j do -- binary search for maximum finite float
|
|
||||||
local m = (i + j) // 2
|
|
||||||
if 10^m < math.huge then i = m else j = m end
|
|
||||||
end
|
|
||||||
assert(10^i < math.huge and 10^j == math.huge)
|
|
||||||
local s = string.format('%.99f', -(10^i))
|
|
||||||
assert(string.len(s) >= i + 101)
|
|
||||||
assert(tonumber(s) == -(10^i))
|
|
||||||
|
|
||||||
-- limit for floats
|
|
||||||
assert(10^38 < math.huge)
|
|
||||||
local s = string.format('%.99f', -(10^38))
|
|
||||||
assert(string.len(s) >= 38 + 101)
|
|
||||||
assert(tonumber(s) == -(10^38))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing large numbers for format
|
|
||||||
do -- assume at least 32 bits
|
|
||||||
local max, min = 0x7fffffff, -0x80000000 -- "large" for 32 bits
|
|
||||||
assert(string.sub(string.format("%8x", -1), -8) == "ffffffff")
|
|
||||||
assert(string.format("%x", max) == "7fffffff")
|
|
||||||
assert(string.sub(string.format("%x", min), -8) == "80000000")
|
|
||||||
assert(string.format("%d", max) == "2147483647")
|
|
||||||
assert(string.format("%d", min) == "-2147483648")
|
|
||||||
assert(string.format("%u", 0xffffffff) == "4294967295")
|
|
||||||
assert(string.format("%o", 0xABCD) == "125715")
|
|
||||||
|
|
||||||
max, min = 0x7fffffffffffffff, -0x8000000000000000
|
|
||||||
if max > 2.0^53 then -- only for 64 bits
|
|
||||||
assert(string.format("%x", (2^52 | 0) - 1) == "fffffffffffff")
|
|
||||||
assert(string.format("0x%8X", 0x8f000003) == "0x8F000003")
|
|
||||||
assert(string.format("%d", 2^53) == "9007199254740992")
|
|
||||||
assert(string.format("%i", -2^53) == "-9007199254740992")
|
|
||||||
assert(string.format("%x", max) == "7fffffffffffffff")
|
|
||||||
assert(string.format("%x", min) == "8000000000000000")
|
|
||||||
assert(string.format("%d", max) == "9223372036854775807")
|
|
||||||
assert(string.format("%d", min) == "-9223372036854775808")
|
|
||||||
assert(string.format("%u", ~(-1 << 64)) == "18446744073709551615")
|
|
||||||
assert(tostring(1234567890123) == '1234567890123')
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do print("testing 'format %a %A'")
|
|
||||||
local function matchhexa (n)
|
|
||||||
local s = string.format("%a", n)
|
|
||||||
-- result matches ISO C requirements
|
|
||||||
assert(string.find(s, "^%-?0x[1-9a-f]%.?[0-9a-f]*p[-+]?%d+$"))
|
|
||||||
assert(tonumber(s) == n) -- and has full precision
|
|
||||||
s = string.format("%A", n)
|
|
||||||
assert(string.find(s, "^%-?0X[1-9A-F]%.?[0-9A-F]*P[-+]?%d+$"))
|
|
||||||
assert(tonumber(s) == n)
|
|
||||||
end
|
|
||||||
for _, n in ipairs{0.1, -0.1, 1/3, -1/3, 1e30, -1e30,
|
|
||||||
-45/247, 1, -1, 2, -2, 3e-20, -3e-20} do
|
|
||||||
matchhexa(n)
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(string.find(string.format("%A", 0.0), "^0X0%.?0*P%+?0$"))
|
|
||||||
assert(string.find(string.format("%a", -0.0), "^%-0x0%.?0*p%+?0$"))
|
|
||||||
|
|
||||||
if not _port then -- test inf, -inf, NaN, and -0.0
|
|
||||||
assert(string.find(string.format("%a", 1/0), "^inf"))
|
|
||||||
assert(string.find(string.format("%A", -1/0), "^%-INF"))
|
|
||||||
assert(string.find(string.format("%a", 0/0), "^%-?nan"))
|
|
||||||
assert(string.find(string.format("%a", -0.0), "^%-0x0"))
|
|
||||||
end
|
|
||||||
|
|
||||||
if not pcall(string.format, "%.3a", 0) then
|
|
||||||
(Message or print)("\n >>> modifiers for format '%a' not available <<<\n")
|
|
||||||
else
|
|
||||||
assert(string.find(string.format("%+.2A", 12), "^%+0X%x%.%x0P%+?%d$"))
|
|
||||||
assert(string.find(string.format("%.4A", -12), "^%-0X%x%.%x000P%+?%d$"))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing some flags (all these results are required by ISO C)
|
|
||||||
assert(string.format("%#12o", 10) == " 012")
|
|
||||||
assert(string.format("%#10x", 100) == " 0x64")
|
|
||||||
assert(string.format("%#-17X", 100) == "0X64 ")
|
|
||||||
assert(string.format("%013i", -100) == "-000000000100")
|
|
||||||
assert(string.format("%2.5d", -100) == "-00100")
|
|
||||||
assert(string.format("%.u", 0) == "")
|
|
||||||
assert(string.format("%+#014.0f", 100) == "+000000000100.")
|
|
||||||
assert(string.format("%-16c", 97) == "a ")
|
|
||||||
assert(string.format("%+.3G", 1.5) == "+1.5")
|
|
||||||
assert(string.format("%.0s", "alo") == "")
|
|
||||||
assert(string.format("%.s", "alo") == "")
|
|
||||||
|
|
||||||
-- ISO C89 says that "The exponent always contains at least two digits",
|
|
||||||
-- but unlike ISO C99 it does not ensure that it contains "only as many
|
|
||||||
-- more digits as necessary".
|
|
||||||
assert(string.match(string.format("% 1.0E", 100), "^ 1E%+0+2$"))
|
|
||||||
assert(string.match(string.format("% .1g", 2^10), "^ 1e%+0+3$"))
|
|
||||||
|
|
||||||
|
|
||||||
-- errors in format
|
|
||||||
|
|
||||||
local function check (fmt, msg)
|
|
||||||
checkerror(msg, string.format, fmt, 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
local aux = string.rep('0', 600)
|
|
||||||
check("%100.3d", "invalid conversion")
|
|
||||||
check("%1"..aux..".3d", "too long")
|
|
||||||
check("%1.100d", "invalid conversion")
|
|
||||||
check("%10.1"..aux.."004d", "too long")
|
|
||||||
check("%t", "invalid conversion")
|
|
||||||
check("%"..aux.."d", "too long")
|
|
||||||
check("%d %d", "no value")
|
|
||||||
check("%010c", "invalid conversion")
|
|
||||||
check("%.10c", "invalid conversion")
|
|
||||||
check("%0.34s", "invalid conversion")
|
|
||||||
check("%#i", "invalid conversion")
|
|
||||||
check("%3.1p", "invalid conversion")
|
|
||||||
check("%0.s", "invalid conversion")
|
|
||||||
check("%10q", "cannot have modifiers")
|
|
||||||
check("%F", "invalid conversion") -- useless and not in C89
|
|
||||||
|
|
||||||
|
|
||||||
assert(load("return 1\n--comment without ending EOL")() == 1)
|
|
||||||
|
|
||||||
|
|
||||||
checkerror("table expected", table.concat, 3)
|
|
||||||
checkerror("at index " .. maxi, table.concat, {}, " ", maxi, maxi)
|
|
||||||
-- '%' escapes following minus signal
|
|
||||||
checkerror("at index %" .. mini, table.concat, {}, " ", mini, mini)
|
|
||||||
assert(table.concat{} == "")
|
|
||||||
assert(table.concat({}, 'x') == "")
|
|
||||||
assert(table.concat({'\0', '\0\1', '\0\1\2'}, '.\0.') == "\0.\0.\0\1.\0.\0\1\2")
|
|
||||||
local a = {}; for i=1,300 do a[i] = "xuxu" end
|
|
||||||
assert(table.concat(a, "123").."123" == string.rep("xuxu123", 300))
|
|
||||||
assert(table.concat(a, "b", 20, 20) == "xuxu")
|
|
||||||
assert(table.concat(a, "", 20, 21) == "xuxuxuxu")
|
|
||||||
assert(table.concat(a, "x", 22, 21) == "")
|
|
||||||
assert(table.concat(a, "3", 299) == "xuxu3xuxu")
|
|
||||||
assert(table.concat({}, "x", maxi, maxi - 1) == "")
|
|
||||||
assert(table.concat({}, "x", mini + 1, mini) == "")
|
|
||||||
assert(table.concat({}, "x", maxi, mini) == "")
|
|
||||||
assert(table.concat({[maxi] = "alo"}, "x", maxi, maxi) == "alo")
|
|
||||||
assert(table.concat({[maxi] = "alo", [maxi - 1] = "y"}, "-", maxi - 1, maxi)
|
|
||||||
== "y-alo")
|
|
||||||
|
|
||||||
assert(not pcall(table.concat, {"a", "b", {}}))
|
|
||||||
|
|
||||||
a = {"a","b","c"}
|
|
||||||
assert(table.concat(a, ",", 1, 0) == "")
|
|
||||||
assert(table.concat(a, ",", 1, 1) == "a")
|
|
||||||
assert(table.concat(a, ",", 1, 2) == "a,b")
|
|
||||||
assert(table.concat(a, ",", 2) == "b,c")
|
|
||||||
assert(table.concat(a, ",", 3) == "c")
|
|
||||||
assert(table.concat(a, ",", 4) == "")
|
|
||||||
|
|
||||||
if not _port then
|
|
||||||
|
|
||||||
local locales = { "ptb", "pt_BR.iso88591", "ISO-8859-1" }
|
|
||||||
local function trylocale (w)
|
|
||||||
for i = 1, #locales do
|
|
||||||
if os.setlocale(locales[i], w) then
|
|
||||||
print(string.format("'%s' locale set to '%s'", w, locales[i]))
|
|
||||||
return locales[i]
|
|
||||||
end
|
|
||||||
end
|
|
||||||
print(string.format("'%s' locale not found", w))
|
|
||||||
return false
|
|
||||||
end
|
|
||||||
|
|
||||||
if trylocale("collate") then
|
|
||||||
assert("alo" < "álo" and "álo" < "amo")
|
|
||||||
end
|
|
||||||
|
|
||||||
if trylocale("ctype") then
|
|
||||||
assert(string.gsub("áéíóú", "%a", "x") == "xxxxx")
|
|
||||||
assert(string.gsub("áÁéÉ", "%l", "x") == "xÁxÉ")
|
|
||||||
assert(string.gsub("áÁéÉ", "%u", "x") == "áxéx")
|
|
||||||
assert(string.upper"áÁé{xuxu}ção" == "ÁÁÉ{XUXU}ÇÃO")
|
|
||||||
end
|
|
||||||
|
|
||||||
os.setlocale("C")
|
|
||||||
assert(os.setlocale() == 'C')
|
|
||||||
assert(os.setlocale(nil, "numeric") == 'C')
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- bug in Lua 5.3.2
|
|
||||||
-- 'gmatch' iterator does not work across coroutines
|
|
||||||
do
|
|
||||||
local f = string.gmatch("1 2 3 4 5", "%d+")
|
|
||||||
assert(f() == "1")
|
|
||||||
local co = coroutine.wrap(f)
|
|
||||||
assert(co() == "2")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
if T==nil then
|
|
||||||
(Message or print)
|
|
||||||
("\n >>> testC not active: skipping 'pushfstring' tests <<<\n")
|
|
||||||
else
|
|
||||||
|
|
||||||
print"testing 'pushfstring'"
|
|
||||||
|
|
||||||
-- formats %U, %f, %I already tested elsewhere
|
|
||||||
|
|
||||||
local blen = 200 -- internal buffer length in 'luaO_pushfstring'
|
|
||||||
|
|
||||||
local function callpfs (op, fmt, n)
|
|
||||||
local x = {T.testC("pushfstring" .. op .. "; return *", fmt, n)}
|
|
||||||
-- stack has code, 'fmt', 'n', and result from operation
|
|
||||||
assert(#x == 4) -- make sure nothing else was left in the stack
|
|
||||||
return x[4]
|
|
||||||
end
|
|
||||||
|
|
||||||
local function testpfs (op, fmt, n)
|
|
||||||
assert(callpfs(op, fmt, n) == string.format(fmt, n))
|
|
||||||
end
|
|
||||||
|
|
||||||
testpfs("I", "", 0)
|
|
||||||
testpfs("I", string.rep("a", blen - 1), 0)
|
|
||||||
testpfs("I", string.rep("a", blen), 0)
|
|
||||||
testpfs("I", string.rep("a", blen + 1), 0)
|
|
||||||
|
|
||||||
local str = string.rep("ab", blen) .. "%d" .. string.rep("d", blen / 2)
|
|
||||||
testpfs("I", str, 2^14)
|
|
||||||
testpfs("I", str, -2^15)
|
|
||||||
|
|
||||||
str = "%d" .. string.rep("cd", blen)
|
|
||||||
testpfs("I", str, 2^14)
|
|
||||||
testpfs("I", str, -2^15)
|
|
||||||
|
|
||||||
str = string.rep("c", blen - 2) .. "%d"
|
|
||||||
testpfs("I", str, 2^14)
|
|
||||||
testpfs("I", str, -2^15)
|
|
||||||
|
|
||||||
for l = 12, 14 do
|
|
||||||
local str1 = string.rep("a", l)
|
|
||||||
for i = 0, 500, 13 do
|
|
||||||
for j = 0, 500, 13 do
|
|
||||||
str = string.rep("a", i) .. "%s" .. string.rep("d", j)
|
|
||||||
testpfs("S", str, str1)
|
|
||||||
testpfs("S", str, str)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
str = "abc %c def"
|
|
||||||
testpfs("I", str, string.byte("A"))
|
|
||||||
testpfs("I", str, 255)
|
|
||||||
|
|
||||||
str = string.rep("a", blen - 1) .. "%p" .. string.rep("cd", blen)
|
|
||||||
testpfs("P", str, {})
|
|
||||||
|
|
||||||
str = string.rep("%%", 3 * blen) .. "%p" .. string.rep("%%", 2 * blen)
|
|
||||||
testpfs("P", str, {})
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
print('OK')
|
|
||||||
|
|
||||||
@ -1,322 +0,0 @@
|
|||||||
-- $Id: testes/tpack.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
local pack = string.pack
|
|
||||||
local packsize = string.packsize
|
|
||||||
local unpack = string.unpack
|
|
||||||
|
|
||||||
print "testing pack/unpack"
|
|
||||||
|
|
||||||
-- maximum size for integers
|
|
||||||
local NB = 16
|
|
||||||
|
|
||||||
local sizeshort = packsize("h")
|
|
||||||
local sizeint = packsize("i")
|
|
||||||
local sizelong = packsize("l")
|
|
||||||
local sizesize_t = packsize("T")
|
|
||||||
local sizeLI = packsize("j")
|
|
||||||
local sizefloat = packsize("f")
|
|
||||||
local sizedouble = packsize("d")
|
|
||||||
local sizenumber = packsize("n")
|
|
||||||
local little = (pack("i2", 1) == "\1\0")
|
|
||||||
local align = packsize("!xXi16")
|
|
||||||
|
|
||||||
assert(1 <= sizeshort and sizeshort <= sizeint and sizeint <= sizelong and
|
|
||||||
sizefloat <= sizedouble)
|
|
||||||
|
|
||||||
print("platform:")
|
|
||||||
print(string.format(
|
|
||||||
"\tshort %d, int %d, long %d, size_t %d, float %d, double %d,\n\z
|
|
||||||
\tlua Integer %d, lua Number %d",
|
|
||||||
sizeshort, sizeint, sizelong, sizesize_t, sizefloat, sizedouble,
|
|
||||||
sizeLI, sizenumber))
|
|
||||||
print("\t" .. (little and "little" or "big") .. " endian")
|
|
||||||
print("\talignment: " .. align)
|
|
||||||
|
|
||||||
|
|
||||||
-- check errors in arguments
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local status, err = pcall(f, ...)
|
|
||||||
-- print(status, err, msg)
|
|
||||||
assert(not status and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- minimum behavior for integer formats
|
|
||||||
assert(unpack("B", pack("B", 0xff)) == 0xff)
|
|
||||||
assert(unpack("b", pack("b", 0x7f)) == 0x7f)
|
|
||||||
assert(unpack("b", pack("b", -0x80)) == -0x80)
|
|
||||||
|
|
||||||
assert(unpack("H", pack("H", 0xffff)) == 0xffff)
|
|
||||||
assert(unpack("h", pack("h", 0x7fff)) == 0x7fff)
|
|
||||||
assert(unpack("h", pack("h", -0x8000)) == -0x8000)
|
|
||||||
|
|
||||||
assert(unpack("L", pack("L", 0xffffffff)) == 0xffffffff)
|
|
||||||
assert(unpack("l", pack("l", 0x7fffffff)) == 0x7fffffff)
|
|
||||||
assert(unpack("l", pack("l", -0x80000000)) == -0x80000000)
|
|
||||||
|
|
||||||
|
|
||||||
for i = 1, NB do
|
|
||||||
-- small numbers with signal extension ("\xFF...")
|
|
||||||
local s = string.rep("\xff", i)
|
|
||||||
assert(pack("i" .. i, -1) == s)
|
|
||||||
assert(packsize("i" .. i) == #s)
|
|
||||||
assert(unpack("i" .. i, s) == -1)
|
|
||||||
|
|
||||||
-- small unsigned number ("\0...\xAA")
|
|
||||||
s = "\xAA" .. string.rep("\0", i - 1)
|
|
||||||
assert(pack("<I" .. i, 0xAA) == s)
|
|
||||||
assert(unpack("<I" .. i, s) == 0xAA)
|
|
||||||
assert(pack(">I" .. i, 0xAA) == s:reverse())
|
|
||||||
assert(unpack(">I" .. i, s:reverse()) == 0xAA)
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local lnum = 0x13121110090807060504030201
|
|
||||||
local s = pack("<j", lnum)
|
|
||||||
assert(unpack("<j", s) == lnum)
|
|
||||||
assert(unpack("<i" .. sizeLI + 1, s .. "\0") == lnum)
|
|
||||||
assert(unpack("<i" .. sizeLI + 1, s .. "\0") == lnum)
|
|
||||||
|
|
||||||
for i = sizeLI + 1, NB do
|
|
||||||
local s = pack("<j", -lnum)
|
|
||||||
assert(unpack("<j", s) == -lnum)
|
|
||||||
-- strings with (correct) extra bytes
|
|
||||||
assert(unpack("<i" .. i, s .. ("\xFF"):rep(i - sizeLI)) == -lnum)
|
|
||||||
assert(unpack(">i" .. i, ("\xFF"):rep(i - sizeLI) .. s:reverse()) == -lnum)
|
|
||||||
assert(unpack("<I" .. i, s .. ("\0"):rep(i - sizeLI)) == -lnum)
|
|
||||||
|
|
||||||
-- overflows
|
|
||||||
checkerror("does not fit", unpack, "<I" .. i, ("\x00"):rep(i - 1) .. "\1")
|
|
||||||
checkerror("does not fit", unpack, ">i" .. i, "\1" .. ("\x00"):rep(i - 1))
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
for i = 1, sizeLI do
|
|
||||||
local lstr = "\1\2\3\4\5\6\7\8\9\10\11\12\13"
|
|
||||||
local lnum = 0x13121110090807060504030201
|
|
||||||
local n = lnum & (~(-1 << (i * 8)))
|
|
||||||
local s = string.sub(lstr, 1, i)
|
|
||||||
assert(pack("<i" .. i, n) == s)
|
|
||||||
assert(pack(">i" .. i, n) == s:reverse())
|
|
||||||
assert(unpack(">i" .. i, s:reverse()) == n)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- sign extension
|
|
||||||
do
|
|
||||||
local u = 0xf0
|
|
||||||
for i = 1, sizeLI - 1 do
|
|
||||||
assert(unpack("<i"..i, "\xf0"..("\xff"):rep(i - 1)) == -16)
|
|
||||||
assert(unpack(">I"..i, "\xf0"..("\xff"):rep(i - 1)) == u)
|
|
||||||
u = u * 256 + 0xff
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
-- mixed endianness
|
|
||||||
do
|
|
||||||
assert(pack(">i2 <i2", 10, 20) == "\0\10\20\0")
|
|
||||||
local a, b = unpack("<i2 >i2", "\10\0\0\20")
|
|
||||||
assert(a == 10 and b == 20)
|
|
||||||
assert(pack("=i4", 2001) == pack("i4", 2001))
|
|
||||||
end
|
|
||||||
|
|
||||||
print("testing invalid formats")
|
|
||||||
|
|
||||||
checkerror("out of limits", pack, "i0", 0)
|
|
||||||
checkerror("out of limits", pack, "i" .. NB + 1, 0)
|
|
||||||
checkerror("out of limits", pack, "!" .. NB + 1, 0)
|
|
||||||
checkerror("%(17%) out of limits %[1,16%]", pack, "Xi" .. NB + 1)
|
|
||||||
checkerror("invalid format option 'r'", pack, "i3r", 0)
|
|
||||||
checkerror("16%-byte integer", unpack, "i16", string.rep('\3', 16))
|
|
||||||
checkerror("not power of 2", pack, "!4i3", 0);
|
|
||||||
checkerror("missing size", pack, "c", "")
|
|
||||||
checkerror("variable%-length format", packsize, "s")
|
|
||||||
checkerror("variable%-length format", packsize, "z")
|
|
||||||
|
|
||||||
-- overflow in option size (error will be in digit after limit)
|
|
||||||
checkerror("invalid format", packsize, "c1" .. string.rep("0", 40))
|
|
||||||
|
|
||||||
if packsize("i") == 4 then
|
|
||||||
-- result would be 2^31 (2^3 repetitions of 2^28 strings)
|
|
||||||
local s = string.rep("c268435456", 2^3)
|
|
||||||
checkerror("too large", packsize, s)
|
|
||||||
-- one less is OK
|
|
||||||
s = string.rep("c268435456", 2^3 - 1) .. "c268435455"
|
|
||||||
assert(packsize(s) == 0x7fffffff)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- overflow in packing
|
|
||||||
for i = 1, sizeLI - 1 do
|
|
||||||
local umax = (1 << (i * 8)) - 1
|
|
||||||
local max = umax >> 1
|
|
||||||
local min = ~max
|
|
||||||
checkerror("overflow", pack, "<I" .. i, -1)
|
|
||||||
checkerror("overflow", pack, "<I" .. i, min)
|
|
||||||
checkerror("overflow", pack, ">I" .. i, umax + 1)
|
|
||||||
|
|
||||||
checkerror("overflow", pack, ">i" .. i, umax)
|
|
||||||
checkerror("overflow", pack, ">i" .. i, max + 1)
|
|
||||||
checkerror("overflow", pack, "<i" .. i, min - 1)
|
|
||||||
|
|
||||||
assert(unpack(">i" .. i, pack(">i" .. i, max)) == max)
|
|
||||||
assert(unpack("<i" .. i, pack("<i" .. i, min)) == min)
|
|
||||||
assert(unpack(">I" .. i, pack(">I" .. i, umax)) == umax)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- Lua integer size
|
|
||||||
assert(unpack(">j", pack(">j", math.maxinteger)) == math.maxinteger)
|
|
||||||
assert(unpack("<j", pack("<j", math.mininteger)) == math.mininteger)
|
|
||||||
assert(unpack("<J", pack("<j", -1)) == -1) -- maximum unsigned integer
|
|
||||||
|
|
||||||
if little then
|
|
||||||
assert(pack("f", 24) == pack("<f", 24))
|
|
||||||
else
|
|
||||||
assert(pack("f", 24) == pack(">f", 24))
|
|
||||||
end
|
|
||||||
|
|
||||||
print "testing pack/unpack of floating-point numbers"
|
|
||||||
|
|
||||||
for _, n in ipairs{0, -1.1, 1.9, 1/0, -1/0, 1e20, -1e20, 0.1, 2000.7} do
|
|
||||||
assert(unpack("n", pack("n", n)) == n)
|
|
||||||
assert(unpack("<n", pack("<n", n)) == n)
|
|
||||||
assert(unpack(">n", pack(">n", n)) == n)
|
|
||||||
assert(pack("<f", n) == pack(">f", n):reverse())
|
|
||||||
assert(pack(">d", n) == pack("<d", n):reverse())
|
|
||||||
end
|
|
||||||
|
|
||||||
-- for non-native precisions, test only with "round" numbers
|
|
||||||
for _, n in ipairs{0, -1.5, 1/0, -1/0, 1e10, -1e9, 0.5, 2000.25} do
|
|
||||||
assert(unpack("<f", pack("<f", n)) == n)
|
|
||||||
assert(unpack(">f", pack(">f", n)) == n)
|
|
||||||
assert(unpack("<d", pack("<d", n)) == n)
|
|
||||||
assert(unpack(">d", pack(">d", n)) == n)
|
|
||||||
end
|
|
||||||
|
|
||||||
print "testing pack/unpack of strings"
|
|
||||||
do
|
|
||||||
local s = string.rep("abc", 1000)
|
|
||||||
assert(pack("zB", s, 247) == s .. "\0\xF7")
|
|
||||||
local s1, b = unpack("zB", s .. "\0\xF9")
|
|
||||||
assert(b == 249 and s1 == s)
|
|
||||||
s1 = pack("s", s)
|
|
||||||
assert(unpack("s", s1) == s)
|
|
||||||
|
|
||||||
checkerror("does not fit", pack, "s1", s)
|
|
||||||
|
|
||||||
checkerror("contains zeros", pack, "z", "alo\0");
|
|
||||||
|
|
||||||
checkerror("unfinished string", unpack, "zc10000000", "alo")
|
|
||||||
|
|
||||||
for i = 2, NB do
|
|
||||||
local s1 = pack("s" .. i, s)
|
|
||||||
assert(unpack("s" .. i, s1) == s and #s1 == #s + i)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
local x = pack("s", "alo")
|
|
||||||
checkerror("too short", unpack, "s", x:sub(1, -2))
|
|
||||||
checkerror("too short", unpack, "c5", "abcd")
|
|
||||||
checkerror("out of limits", pack, "s100", "alo")
|
|
||||||
end
|
|
||||||
|
|
||||||
do
|
|
||||||
assert(pack("c0", "") == "")
|
|
||||||
assert(packsize("c0") == 0)
|
|
||||||
assert(unpack("c0", "") == "")
|
|
||||||
assert(pack("<! c3", "abc") == "abc")
|
|
||||||
assert(packsize("<! c3") == 3)
|
|
||||||
assert(pack(">!4 c6", "abcdef") == "abcdef")
|
|
||||||
assert(pack("c3", "123") == "123")
|
|
||||||
assert(pack("c0", "") == "")
|
|
||||||
assert(pack("c8", "123456") == "123456\0\0")
|
|
||||||
assert(pack("c88", "") == string.rep("\0", 88))
|
|
||||||
assert(pack("c188", "ab") == "ab" .. string.rep("\0", 188 - 2))
|
|
||||||
local a, b, c = unpack("!4 z c3", "abcdefghi\0xyz")
|
|
||||||
assert(a == "abcdefghi" and b == "xyz" and c == 14)
|
|
||||||
checkerror("longer than", pack, "c3", "1234")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
-- testing multiple types and sequence
|
|
||||||
do
|
|
||||||
local x = pack("<b h b f d f n i", 1, 2, 3, 4, 5, 6, 7, 8)
|
|
||||||
assert(#x == packsize("<b h b f d f n i"))
|
|
||||||
local a, b, c, d, e, f, g, h = unpack("<b h b f d f n i", x)
|
|
||||||
assert(a == 1 and b == 2 and c == 3 and d == 4 and e == 5 and f == 6 and
|
|
||||||
g == 7 and h == 8)
|
|
||||||
end
|
|
||||||
|
|
||||||
print "testing alignment"
|
|
||||||
do
|
|
||||||
assert(pack(" < i1 i2 ", 2, 3) == "\2\3\0") -- no alignment by default
|
|
||||||
local x = pack(">!8 b Xh i4 i8 c1 Xi8", -12, 100, 200, "\xEC")
|
|
||||||
assert(#x == packsize(">!8 b Xh i4 i8 c1 Xi8"))
|
|
||||||
assert(x == "\xf4" .. "\0\0\0" ..
|
|
||||||
"\0\0\0\100" ..
|
|
||||||
"\0\0\0\0\0\0\0\xC8" ..
|
|
||||||
"\xEC" .. "\0\0\0\0\0\0\0")
|
|
||||||
local a, b, c, d, pos = unpack(">!8 c1 Xh i4 i8 b Xi8 XI XH", x)
|
|
||||||
assert(a == "\xF4" and b == 100 and c == 200 and d == -20 and (pos - 1) == #x)
|
|
||||||
|
|
||||||
x = pack(">!4 c3 c4 c2 z i4 c5 c2 Xi4",
|
|
||||||
"abc", "abcd", "xz", "hello", 5, "world", "xy")
|
|
||||||
assert(x == "abcabcdxzhello\0\0\0\0\0\5worldxy\0")
|
|
||||||
local a, b, c, d, e, f, g, pos = unpack(">!4 c3 c4 c2 z i4 c5 c2 Xh Xi4", x)
|
|
||||||
assert(a == "abc" and b == "abcd" and c == "xz" and d == "hello" and
|
|
||||||
e == 5 and f == "world" and g == "xy" and (pos - 1) % 4 == 0)
|
|
||||||
|
|
||||||
x = pack(" b b Xd b Xb x", 1, 2, 3)
|
|
||||||
assert(packsize(" b b Xd b Xb x") == 4)
|
|
||||||
assert(x == "\1\2\3\0")
|
|
||||||
a, b, c, pos = unpack("bbXdb", x)
|
|
||||||
assert(a == 1 and b == 2 and c == 3 and pos == #x)
|
|
||||||
|
|
||||||
-- only alignment
|
|
||||||
assert(packsize("!8 xXi8") == 8)
|
|
||||||
local pos = unpack("!8 xXi8", "0123456701234567"); assert(pos == 9)
|
|
||||||
assert(packsize("!8 xXi2") == 2)
|
|
||||||
local pos = unpack("!8 xXi2", "0123456701234567"); assert(pos == 3)
|
|
||||||
assert(packsize("!2 xXi2") == 2)
|
|
||||||
local pos = unpack("!2 xXi2", "0123456701234567"); assert(pos == 3)
|
|
||||||
assert(packsize("!2 xXi8") == 2)
|
|
||||||
local pos = unpack("!2 xXi8", "0123456701234567"); assert(pos == 3)
|
|
||||||
assert(packsize("!16 xXi16") == 16)
|
|
||||||
local pos = unpack("!16 xXi16", "0123456701234567"); assert(pos == 17)
|
|
||||||
|
|
||||||
checkerror("invalid next option", pack, "X")
|
|
||||||
checkerror("invalid next option", unpack, "XXi", "")
|
|
||||||
checkerror("invalid next option", unpack, "X i", "")
|
|
||||||
checkerror("invalid next option", pack, "Xc1")
|
|
||||||
end
|
|
||||||
|
|
||||||
do -- testing initial position
|
|
||||||
local x = pack("i4i4i4i4", 1, 2, 3, 4)
|
|
||||||
for pos = 1, 16, 4 do
|
|
||||||
local i, p = unpack("i4", x, pos)
|
|
||||||
assert(i == pos//4 + 1 and p == pos + 4)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- with alignment
|
|
||||||
for pos = 0, 12 do -- will always round position to power of 2
|
|
||||||
local i, p = unpack("!4 i4", x, pos + 1)
|
|
||||||
assert(i == (pos + 3)//4 + 1 and p == i*4 + 1)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- negative indices
|
|
||||||
local i, p = unpack("!4 i4", x, -4)
|
|
||||||
assert(i == 4 and p == 17)
|
|
||||||
local i, p = unpack("!4 i4", x, -7)
|
|
||||||
assert(i == 4 and p == 17)
|
|
||||||
local i, p = unpack("!4 i4", x, -#x)
|
|
||||||
assert(i == 1 and p == 5)
|
|
||||||
|
|
||||||
-- limits
|
|
||||||
for i = 1, #x + 1 do
|
|
||||||
assert(unpack("c0", x, i) == "")
|
|
||||||
end
|
|
||||||
checkerror("out of string", unpack, "c0", x, #x + 2)
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
print "OK"
|
|
||||||
|
|
||||||
@ -1,40 +0,0 @@
|
|||||||
-- track collections
|
|
||||||
|
|
||||||
local M = {}
|
|
||||||
|
|
||||||
-- import list
|
|
||||||
local setmetatable, stderr, collectgarbage =
|
|
||||||
setmetatable, io.stderr, collectgarbage
|
|
||||||
|
|
||||||
_ENV = nil
|
|
||||||
|
|
||||||
local active = false
|
|
||||||
|
|
||||||
|
|
||||||
-- each time a table is collected, remark it for finalization on next
|
|
||||||
-- cycle
|
|
||||||
local mt = {}
|
|
||||||
function mt.__gc (o)
|
|
||||||
stderr:write'.' -- mark progress
|
|
||||||
if active then
|
|
||||||
setmetatable(o, mt) -- remark object for finalization
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function M.start ()
|
|
||||||
if not active then
|
|
||||||
active = true
|
|
||||||
setmetatable({}, mt) -- create initial object
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
function M.stop ()
|
|
||||||
if active then
|
|
||||||
active = false
|
|
||||||
collectgarbage() -- call finalizer for the last time
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
return M
|
|
||||||
@ -1,257 +0,0 @@
|
|||||||
-- $Id: testes/utf8.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print "testing UTF-8 library"
|
|
||||||
|
|
||||||
local utf8 = require'utf8'
|
|
||||||
|
|
||||||
|
|
||||||
local function checkerror (msg, f, ...)
|
|
||||||
local s, err = pcall(f, ...)
|
|
||||||
assert(not s and string.find(err, msg))
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local function len (s)
|
|
||||||
return #string.gsub(s, "[\x80-\xBF]", "")
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
local justone = "^" .. utf8.charpattern .. "$"
|
|
||||||
|
|
||||||
-- 't' is the list of codepoints of 's'
|
|
||||||
local function checksyntax (s, t)
|
|
||||||
-- creates a string "return '\u{t[1]}...\u{t[n]}'"
|
|
||||||
local ts = {"return '"}
|
|
||||||
for i = 1, #t do ts[i + 1] = string.format("\\u{%x}", t[i]) end
|
|
||||||
ts[#t + 2] = "'"
|
|
||||||
ts = table.concat(ts)
|
|
||||||
-- its execution should result in 's'
|
|
||||||
assert(assert(load(ts))() == s)
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(not utf8.offset("alo", 5))
|
|
||||||
assert(not utf8.offset("alo", -4))
|
|
||||||
|
|
||||||
-- 'check' makes several tests over the validity of string 's'.
|
|
||||||
-- 't' is the list of codepoints of 's'.
|
|
||||||
local function check (s, t, nonstrict)
|
|
||||||
local l = utf8.len(s, 1, -1, nonstrict)
|
|
||||||
assert(#t == l and len(s) == l)
|
|
||||||
assert(utf8.char(table.unpack(t)) == s) -- 't' and 's' are equivalent
|
|
||||||
|
|
||||||
assert(utf8.offset(s, 0) == 1)
|
|
||||||
|
|
||||||
checksyntax(s, t)
|
|
||||||
|
|
||||||
-- creates new table with all codepoints of 's'
|
|
||||||
local t1 = {utf8.codepoint(s, 1, -1, nonstrict)}
|
|
||||||
assert(#t == #t1)
|
|
||||||
for i = 1, #t do assert(t[i] == t1[i]) end -- 't' is equal to 't1'
|
|
||||||
|
|
||||||
for i = 1, l do -- for all codepoints
|
|
||||||
local pi = utf8.offset(s, i) -- position of i-th char
|
|
||||||
local pi1 = utf8.offset(s, 2, pi) -- position of next char
|
|
||||||
assert(string.find(string.sub(s, pi, pi1 - 1), justone))
|
|
||||||
assert(utf8.offset(s, -1, pi1) == pi)
|
|
||||||
assert(utf8.offset(s, i - l - 1) == pi)
|
|
||||||
assert(pi1 - pi == #utf8.char(utf8.codepoint(s, pi, pi, nonstrict)))
|
|
||||||
for j = pi, pi1 - 1 do
|
|
||||||
assert(utf8.offset(s, 0, j) == pi)
|
|
||||||
end
|
|
||||||
for j = pi + 1, pi1 - 1 do
|
|
||||||
assert(not utf8.len(s, j))
|
|
||||||
end
|
|
||||||
assert(utf8.len(s, pi, pi, nonstrict) == 1)
|
|
||||||
assert(utf8.len(s, pi, pi1 - 1, nonstrict) == 1)
|
|
||||||
assert(utf8.len(s, pi, -1, nonstrict) == l - i + 1)
|
|
||||||
assert(utf8.len(s, pi1, -1, nonstrict) == l - i)
|
|
||||||
assert(utf8.len(s, 1, pi, nonstrict) == i)
|
|
||||||
end
|
|
||||||
|
|
||||||
local i = 0
|
|
||||||
for p, c in utf8.codes(s, nonstrict) do
|
|
||||||
i = i + 1
|
|
||||||
assert(c == t[i] and p == utf8.offset(s, i))
|
|
||||||
assert(utf8.codepoint(s, p, p, nonstrict) == c)
|
|
||||||
end
|
|
||||||
assert(i == #t)
|
|
||||||
|
|
||||||
i = 0
|
|
||||||
for c in string.gmatch(s, utf8.charpattern) do
|
|
||||||
i = i + 1
|
|
||||||
assert(c == utf8.char(t[i]))
|
|
||||||
end
|
|
||||||
assert(i == #t)
|
|
||||||
|
|
||||||
for i = 1, l do
|
|
||||||
assert(utf8.offset(s, i) == utf8.offset(s, i - l - 1, #s + 1))
|
|
||||||
end
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
do -- error indication in utf8.len
|
|
||||||
local function check (s, p)
|
|
||||||
local a, b = utf8.len(s)
|
|
||||||
assert(not a and b == p)
|
|
||||||
end
|
|
||||||
check("abc\xE3def", 4)
|
|
||||||
check("\xF4\x9F\xBF", 1)
|
|
||||||
check("\xF4\x9F\xBF\xBF", 1)
|
|
||||||
-- spurious continuation bytes
|
|
||||||
check("汉字\x80", #("汉字") + 1)
|
|
||||||
check("\x80hello", 1)
|
|
||||||
check("hel\x80lo", 4)
|
|
||||||
check("汉字\xBF", #("汉字") + 1)
|
|
||||||
check("\xBFhello", 1)
|
|
||||||
check("hel\xBFlo", 4)
|
|
||||||
end
|
|
||||||
|
|
||||||
-- errors in utf8.codes
|
|
||||||
do
|
|
||||||
local function errorcodes (s)
|
|
||||||
checkerror("invalid UTF%-8 code",
|
|
||||||
function ()
|
|
||||||
for c in utf8.codes(s) do assert(c) end
|
|
||||||
end)
|
|
||||||
end
|
|
||||||
errorcodes("ab\xff")
|
|
||||||
errorcodes("\u{110000}")
|
|
||||||
errorcodes("in\x80valid")
|
|
||||||
errorcodes("\xbfinvalid")
|
|
||||||
errorcodes("αλφ\xBFα")
|
|
||||||
|
|
||||||
-- calling interation function with invalid arguments
|
|
||||||
local f = utf8.codes("")
|
|
||||||
assert(f("", 2) == nil)
|
|
||||||
assert(f("", -1) == nil)
|
|
||||||
assert(f("", math.mininteger) == nil)
|
|
||||||
|
|
||||||
end
|
|
||||||
|
|
||||||
-- error in initial position for offset
|
|
||||||
checkerror("position out of bounds", utf8.offset, "abc", 1, 5)
|
|
||||||
checkerror("position out of bounds", utf8.offset, "abc", 1, -4)
|
|
||||||
checkerror("position out of bounds", utf8.offset, "", 1, 2)
|
|
||||||
checkerror("position out of bounds", utf8.offset, "", 1, -1)
|
|
||||||
checkerror("continuation byte", utf8.offset, "𦧺", 1, 2)
|
|
||||||
checkerror("continuation byte", utf8.offset, "𦧺", 1, 2)
|
|
||||||
checkerror("continuation byte", utf8.offset, "\x80", 1)
|
|
||||||
|
|
||||||
-- error in indices for len
|
|
||||||
checkerror("out of bounds", utf8.len, "abc", 0, 2)
|
|
||||||
checkerror("out of bounds", utf8.len, "abc", 1, 4)
|
|
||||||
|
|
||||||
|
|
||||||
local s = "hello World"
|
|
||||||
local t = {string.byte(s, 1, -1)}
|
|
||||||
for i = 1, utf8.len(s) do assert(t[i] == string.byte(s, i)) end
|
|
||||||
check(s, t)
|
|
||||||
|
|
||||||
check("汉字/漢字", {27721, 23383, 47, 28450, 23383,})
|
|
||||||
|
|
||||||
do
|
|
||||||
local s = "áéí\128"
|
|
||||||
local t = {utf8.codepoint(s,1,#s - 1)}
|
|
||||||
assert(#t == 3 and t[1] == 225 and t[2] == 233 and t[3] == 237)
|
|
||||||
checkerror("invalid UTF%-8 code", utf8.codepoint, s, 1, #s)
|
|
||||||
checkerror("out of bounds", utf8.codepoint, s, #s + 1)
|
|
||||||
t = {utf8.codepoint(s, 4, 3)}
|
|
||||||
assert(#t == 0)
|
|
||||||
checkerror("out of bounds", utf8.codepoint, s, -(#s + 1), 1)
|
|
||||||
checkerror("out of bounds", utf8.codepoint, s, 1, #s + 1)
|
|
||||||
-- surrogates
|
|
||||||
assert(utf8.codepoint("\u{D7FF}") == 0xD800 - 1)
|
|
||||||
assert(utf8.codepoint("\u{E000}") == 0xDFFF + 1)
|
|
||||||
assert(utf8.codepoint("\u{D800}", 1, 1, true) == 0xD800)
|
|
||||||
assert(utf8.codepoint("\u{DFFF}", 1, 1, true) == 0xDFFF)
|
|
||||||
assert(utf8.codepoint("\u{7FFFFFFF}", 1, 1, true) == 0x7FFFFFFF)
|
|
||||||
end
|
|
||||||
|
|
||||||
assert(utf8.char() == "")
|
|
||||||
assert(utf8.char(0, 97, 98, 99, 1) == "\0abc\1")
|
|
||||||
|
|
||||||
assert(utf8.codepoint(utf8.char(0x10FFFF)) == 0x10FFFF)
|
|
||||||
assert(utf8.codepoint(utf8.char(0x7FFFFFFF), 1, 1, true) == (1<<31) - 1)
|
|
||||||
|
|
||||||
checkerror("value out of range", utf8.char, 0x7FFFFFFF + 1)
|
|
||||||
checkerror("value out of range", utf8.char, -1)
|
|
||||||
|
|
||||||
local function invalid (s)
|
|
||||||
checkerror("invalid UTF%-8 code", utf8.codepoint, s)
|
|
||||||
assert(not utf8.len(s))
|
|
||||||
end
|
|
||||||
|
|
||||||
-- UTF-8 representation for 0x11ffff (value out of valid range)
|
|
||||||
invalid("\xF4\x9F\xBF\xBF")
|
|
||||||
|
|
||||||
-- surrogates
|
|
||||||
invalid("\u{D800}")
|
|
||||||
invalid("\u{DFFF}")
|
|
||||||
|
|
||||||
-- overlong sequences
|
|
||||||
invalid("\xC0\x80") -- zero
|
|
||||||
invalid("\xC1\xBF") -- 0x7F (should be coded in 1 byte)
|
|
||||||
invalid("\xE0\x9F\xBF") -- 0x7FF (should be coded in 2 bytes)
|
|
||||||
invalid("\xF0\x8F\xBF\xBF") -- 0xFFFF (should be coded in 3 bytes)
|
|
||||||
|
|
||||||
|
|
||||||
-- invalid bytes
|
|
||||||
invalid("\x80") -- continuation byte
|
|
||||||
invalid("\xBF") -- continuation byte
|
|
||||||
invalid("\xFE") -- invalid byte
|
|
||||||
invalid("\xFF") -- invalid byte
|
|
||||||
|
|
||||||
|
|
||||||
-- empty string
|
|
||||||
check("", {})
|
|
||||||
|
|
||||||
-- minimum and maximum values for each sequence size
|
|
||||||
s = "\0 \x7F\z
|
|
||||||
\xC2\x80 \xDF\xBF\z
|
|
||||||
\xE0\xA0\x80 \xEF\xBF\xBF\z
|
|
||||||
\xF0\x90\x80\x80 \xF4\x8F\xBF\xBF"
|
|
||||||
s = string.gsub(s, " ", "")
|
|
||||||
check(s, {0,0x7F, 0x80,0x7FF, 0x800,0xFFFF, 0x10000,0x10FFFF})
|
|
||||||
|
|
||||||
do
|
|
||||||
-- original UTF-8 values
|
|
||||||
local s = "\u{4000000}\u{7FFFFFFF}"
|
|
||||||
assert(#s == 12)
|
|
||||||
check(s, {0x4000000, 0x7FFFFFFF}, true)
|
|
||||||
|
|
||||||
s = "\u{200000}\u{3FFFFFF}"
|
|
||||||
assert(#s == 10)
|
|
||||||
check(s, {0x200000, 0x3FFFFFF}, true)
|
|
||||||
|
|
||||||
s = "\u{10000}\u{1fffff}"
|
|
||||||
assert(#s == 8)
|
|
||||||
check(s, {0x10000, 0x1FFFFF}, true)
|
|
||||||
end
|
|
||||||
|
|
||||||
local x = "日本語a-4\0éó"
|
|
||||||
check(x, {26085, 26412, 35486, 97, 45, 52, 0, 233, 243})
|
|
||||||
|
|
||||||
|
|
||||||
-- Supplementary Characters
|
|
||||||
check("𣲷𠜎𠱓𡁻𠵼ab𠺢",
|
|
||||||
{0x23CB7, 0x2070E, 0x20C53, 0x2107B, 0x20D7C, 0x61, 0x62, 0x20EA2,})
|
|
||||||
|
|
||||||
check("𨳊𩶘𦧺𨳒𥄫𤓓\xF4\x8F\xBF\xBF",
|
|
||||||
{0x28CCA, 0x29D98, 0x269FA, 0x28CD2, 0x2512B, 0x244D3, 0x10ffff})
|
|
||||||
|
|
||||||
|
|
||||||
local i = 0
|
|
||||||
for p, c in string.gmatch(x, "()(" .. utf8.charpattern .. ")") do
|
|
||||||
i = i + 1
|
|
||||||
assert(utf8.offset(x, i) == p)
|
|
||||||
assert(utf8.len(x, p) == utf8.len(x) - i + 1)
|
|
||||||
assert(utf8.len(c) == 1)
|
|
||||||
for j = 1, #c - 1 do
|
|
||||||
assert(utf8.offset(x, 0, p + j - 1) == p)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
print'ok'
|
|
||||||
|
|
||||||
@ -1,151 +0,0 @@
|
|||||||
-- $Id: testes/vararg.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print('testing vararg')
|
|
||||||
|
|
||||||
local function f (a, ...)
|
|
||||||
local x = {n = select('#', ...), ...}
|
|
||||||
for i = 1, x.n do assert(a[i] == x[i]) end
|
|
||||||
return x.n
|
|
||||||
end
|
|
||||||
|
|
||||||
local function c12 (...)
|
|
||||||
assert(arg == _G.arg) -- no local 'arg'
|
|
||||||
local x = {...}; x.n = #x
|
|
||||||
local res = (x.n==2 and x[1] == 1 and x[2] == 2)
|
|
||||||
if res then res = 55 end
|
|
||||||
return res, 2
|
|
||||||
end
|
|
||||||
|
|
||||||
local function vararg (...) return {n = select('#', ...), ...} end
|
|
||||||
|
|
||||||
local call = function (f, args) return f(table.unpack(args, 1, args.n)) end
|
|
||||||
|
|
||||||
assert(f() == 0)
|
|
||||||
assert(f({1,2,3}, 1, 2, 3) == 3)
|
|
||||||
assert(f({"alo", nil, 45, f, nil}, "alo", nil, 45, f, nil) == 5)
|
|
||||||
|
|
||||||
assert(vararg().n == 0)
|
|
||||||
assert(vararg(nil, nil).n == 2)
|
|
||||||
|
|
||||||
assert(c12(1,2)==55)
|
|
||||||
local a,b = assert(call(c12, {1,2}))
|
|
||||||
assert(a == 55 and b == 2)
|
|
||||||
a = call(c12, {1,2;n=2})
|
|
||||||
assert(a == 55 and b == 2)
|
|
||||||
a = call(c12, {1,2;n=1})
|
|
||||||
assert(not a)
|
|
||||||
assert(c12(1,2,3) == false)
|
|
||||||
local a = vararg(call(next, {_G,nil;n=2}))
|
|
||||||
local b,c = next(_G)
|
|
||||||
assert(a[1] == b and a[2] == c and a.n == 2)
|
|
||||||
a = vararg(call(call, {c12, {1,2}}))
|
|
||||||
assert(a.n == 2 and a[1] == 55 and a[2] == 2)
|
|
||||||
a = call(print, {'+'})
|
|
||||||
assert(a == nil)
|
|
||||||
|
|
||||||
local t = {1, 10}
|
|
||||||
function t:f (...) local arg = {...}; return self[...]+#arg end
|
|
||||||
assert(t:f(1,4) == 3 and t:f(2) == 11)
|
|
||||||
print('+')
|
|
||||||
|
|
||||||
local lim = 20
|
|
||||||
local i, a = 1, {}
|
|
||||||
while i <= lim do a[i] = i+0.3; i=i+1 end
|
|
||||||
|
|
||||||
function f(a, b, c, d, ...)
|
|
||||||
local more = {...}
|
|
||||||
assert(a == 1.3 and more[1] == 5.3 and
|
|
||||||
more[lim-4] == lim+0.3 and not more[lim-3])
|
|
||||||
end
|
|
||||||
|
|
||||||
local function g (a,b,c)
|
|
||||||
assert(a == 1.3 and b == 2.3 and c == 3.3)
|
|
||||||
end
|
|
||||||
|
|
||||||
call(f, a)
|
|
||||||
call(g, a)
|
|
||||||
|
|
||||||
a = {}
|
|
||||||
i = 1
|
|
||||||
while i <= lim do a[i] = i; i=i+1 end
|
|
||||||
assert(call(math.max, a) == lim)
|
|
||||||
|
|
||||||
print("+")
|
|
||||||
|
|
||||||
|
|
||||||
-- new-style varargs
|
|
||||||
|
|
||||||
local function oneless (a, ...) return ... end
|
|
||||||
|
|
||||||
function f (n, a, ...)
|
|
||||||
local b
|
|
||||||
assert(arg == _G.arg) -- no local 'arg'
|
|
||||||
if n == 0 then
|
|
||||||
local b, c, d = ...
|
|
||||||
return a, b, c, d, oneless(oneless(oneless(...)))
|
|
||||||
else
|
|
||||||
n, b, a = n-1, ..., a
|
|
||||||
assert(b == ...)
|
|
||||||
return f(n, a, ...)
|
|
||||||
end
|
|
||||||
end
|
|
||||||
|
|
||||||
a,b,c,d,e = assert(f(10,5,4,3,2,1))
|
|
||||||
assert(a==5 and b==4 and c==3 and d==2 and e==1)
|
|
||||||
|
|
||||||
a,b,c,d,e = f(4)
|
|
||||||
assert(a==nil and b==nil and c==nil and d==nil and e==nil)
|
|
||||||
|
|
||||||
|
|
||||||
-- varargs for main chunks
|
|
||||||
local f = load[[ return {...} ]]
|
|
||||||
local x = f(2,3)
|
|
||||||
assert(x[1] == 2 and x[2] == 3 and x[3] == undef)
|
|
||||||
|
|
||||||
|
|
||||||
f = load[[
|
|
||||||
local x = {...}
|
|
||||||
for i=1,select('#', ...) do assert(x[i] == select(i, ...)) end
|
|
||||||
assert(x[select('#', ...)+1] == undef)
|
|
||||||
return true
|
|
||||||
]]
|
|
||||||
|
|
||||||
assert(f("a", "b", nil, {}, assert))
|
|
||||||
assert(f())
|
|
||||||
|
|
||||||
a = {select(3, table.unpack{10,20,30,40})}
|
|
||||||
assert(#a == 2 and a[1] == 30 and a[2] == 40)
|
|
||||||
a = {select(1)}
|
|
||||||
assert(next(a) == nil)
|
|
||||||
a = {select(-1, 3, 5, 7)}
|
|
||||||
assert(a[1] == 7 and a[2] == undef)
|
|
||||||
a = {select(-2, 3, 5, 7)}
|
|
||||||
assert(a[1] == 5 and a[2] == 7 and a[3] == undef)
|
|
||||||
pcall(select, 10000)
|
|
||||||
pcall(select, -10000)
|
|
||||||
|
|
||||||
|
|
||||||
-- bug in 5.2.2
|
|
||||||
|
|
||||||
function f(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
|
|
||||||
p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
|
|
||||||
p21, p22, p23, p24, p25, p26, p27, p28, p29, p30,
|
|
||||||
p31, p32, p33, p34, p35, p36, p37, p38, p39, p40,
|
|
||||||
p41, p42, p43, p44, p45, p46, p48, p49, p50, ...)
|
|
||||||
local a1,a2,a3,a4,a5,a6,a7
|
|
||||||
local a8,a9,a10,a11,a12,a13,a14
|
|
||||||
end
|
|
||||||
|
|
||||||
-- assertion fail here
|
|
||||||
f()
|
|
||||||
|
|
||||||
-- missing arguments in tail call
|
|
||||||
do
|
|
||||||
local function f(a,b,c) return c, b end
|
|
||||||
local function g() return f(1,2) end
|
|
||||||
local a, b = g()
|
|
||||||
assert(a == nil and b == 2)
|
|
||||||
end
|
|
||||||
print('OK')
|
|
||||||
|
|
||||||
@ -1,152 +0,0 @@
|
|||||||
-- $Id: testes/verybig.lua $
|
|
||||||
-- See Copyright Notice in file all.lua
|
|
||||||
|
|
||||||
print "testing RK"
|
|
||||||
|
|
||||||
-- testing opcodes with RK arguments larger than K limit
|
|
||||||
local function foo ()
|
|
||||||
local dummy = {
|
|
||||||
-- fill first 256 entries in table of constants
|
|
||||||
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
|
|
||||||
17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
|
|
||||||
33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
|
|
||||||
49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
|
|
||||||
65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
|
|
||||||
81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
|
|
||||||
97, 98, 99, 100, 101, 102, 103, 104,
|
|
||||||
105, 106, 107, 108, 109, 110, 111, 112,
|
|
||||||
113, 114, 115, 116, 117, 118, 119, 120,
|
|
||||||
121, 122, 123, 124, 125, 126, 127, 128,
|
|
||||||
129, 130, 131, 132, 133, 134, 135, 136,
|
|
||||||
137, 138, 139, 140, 141, 142, 143, 144,
|
|
||||||
145, 146, 147, 148, 149, 150, 151, 152,
|
|
||||||
153, 154, 155, 156, 157, 158, 159, 160,
|
|
||||||
161, 162, 163, 164, 165, 166, 167, 168,
|
|
||||||
169, 170, 171, 172, 173, 174, 175, 176,
|
|
||||||
177, 178, 179, 180, 181, 182, 183, 184,
|
|
||||||
185, 186, 187, 188, 189, 190, 191, 192,
|
|
||||||
193, 194, 195, 196, 197, 198, 199, 200,
|
|
||||||
201, 202, 203, 204, 205, 206, 207, 208,
|
|
||||||
209, 210, 211, 212, 213, 214, 215, 216,
|
|
||||||
217, 218, 219, 220, 221, 222, 223, 224,
|
|
||||||
225, 226, 227, 228, 229, 230, 231, 232,
|
|
||||||
233, 234, 235, 236, 237, 238, 239, 240,
|
|
||||||
241, 242, 243, 244, 245, 246, 247, 248,
|
|
||||||
249, 250, 251, 252, 253, 254, 255, 256,
|
|
||||||
}
|
|
||||||
assert(24.5 + 0.6 == 25.1)
|
|
||||||
local t = {foo = function (self, x) return x + self.x end, x = 10}
|
|
||||||
t.t = t
|
|
||||||
assert(t:foo(1.5) == 11.5)
|
|
||||||
assert(t.t:foo(0.5) == 10.5) -- bug in 5.2 alpha
|
|
||||||
assert(24.3 == 24.3)
|
|
||||||
assert((function () return t.x end)() == 10)
|
|
||||||
end
|
|
||||||
|
|
||||||
|
|
||||||
foo()
|
|
||||||
foo = nil
|
|
||||||
|
|
||||||
if _soft then return 10 end
|
|
||||||
|
|
||||||
print "testing large programs (>64k)"
|
|
||||||
|
|
||||||
-- template to create a very big test file
|
|
||||||
local prog = [[$
|
|
||||||
|
|
||||||
local a,b
|
|
||||||
|
|
||||||
b = {$1$
|
|
||||||
b30009 = 65534,
|
|
||||||
b30010 = 65535,
|
|
||||||
b30011 = 65536,
|
|
||||||
b30012 = 65537,
|
|
||||||
b30013 = 16777214,
|
|
||||||
b30014 = 16777215,
|
|
||||||
b30015 = 16777216,
|
|
||||||
b30016 = 16777217,
|
|
||||||
b30017 = 0x7fffff,
|
|
||||||
b30018 = -0x7fffff,
|
|
||||||
b30019 = 0x1ffffff,
|
|
||||||
b30020 = -0x1ffffd,
|
|
||||||
b30021 = -65534,
|
|
||||||
b30022 = -65535,
|
|
||||||
b30023 = -65536,
|
|
||||||
b30024 = -0xffffff,
|
|
||||||
b30025 = 15012.5,
|
|
||||||
$2$
|
|
||||||
};
|
|
||||||
|
|
||||||
assert(b.a50008 == 25004 and b["a11"] == -5.5)
|
|
||||||
assert(b.a33007 == -16503.5 and b.a50009 == -25004.5)
|
|
||||||
assert(b["b"..30024] == -0xffffff)
|
|
||||||
|
|
||||||
function b:xxx (a,b) return a+b end
|
|
||||||
assert(b:xxx(10, 12) == 22) -- pushself with non-constant index
|
|
||||||
b["xxx"] = undef
|
|
||||||
|
|
||||||
local s = 0; local n=0
|
|
||||||
for a,b in pairs(b) do s=s+b; n=n+1 end
|
|
||||||
-- with 32-bit floats, exact value of 's' depends on summation order
|
|
||||||
assert(81800000.0 < s and s < 81860000 and n == 70001)
|
|
||||||
|
|
||||||
a = nil; b = nil
|
|
||||||
print'+'
|
|
||||||
|
|
||||||
local function f(x) b=x end
|
|
||||||
|
|
||||||
a = f{$3$} or 10
|
|
||||||
|
|
||||||
assert(a==10)
|
|
||||||
assert(b[1] == "a10" and b[2] == 5 and b[#b-1] == "a50009")
|
|
||||||
|
|
||||||
|
|
||||||
function xxxx (x) return b[x] end
|
|
||||||
|
|
||||||
assert(xxxx(3) == "a11")
|
|
||||||
|
|
||||||
a = nil; b=nil
|
|
||||||
xxxx = nil
|
|
||||||
|
|
||||||
return 10
|
|
||||||
|
|
||||||
]]
|
|
||||||
|
|
||||||
-- functions to fill in the $n$
|
|
||||||
|
|
||||||
local function sig (x)
|
|
||||||
return (x % 2 == 0) and '' or '-'
|
|
||||||
end
|
|
||||||
|
|
||||||
local F = {
|
|
||||||
function () -- $1$
|
|
||||||
for i=10,50009 do
|
|
||||||
io.write('a', i, ' = ', sig(i), 5+((i-10)/2), ',\n')
|
|
||||||
end
|
|
||||||
end,
|
|
||||||
|
|
||||||
function () -- $2$
|
|
||||||
for i=30026,50009 do
|
|
||||||
io.write('b', i, ' = ', sig(i), 15013+((i-30026)/2), ',\n')
|
|
||||||
end
|
|
||||||
end,
|
|
||||||
|
|
||||||
function () -- $3$
|
|
||||||
for i=10,50009 do
|
|
||||||
io.write('"a', i, '", ', sig(i), 5+((i-10)/2), ',\n')
|
|
||||||
end
|
|
||||||
end,
|
|
||||||
}
|
|
||||||
|
|
||||||
local file = os.tmpname()
|
|
||||||
io.output(file)
|
|
||||||
for s in string.gmatch(prog, "$([^$]+)") do
|
|
||||||
local n = tonumber(s)
|
|
||||||
if not n then io.write(s) else F[n]() end
|
|
||||||
end
|
|
||||||
io.close()
|
|
||||||
local result = dofile(file)
|
|
||||||
assert(os.remove(file))
|
|
||||||
print'OK'
|
|
||||||
return result
|
|
||||||
|
|
||||||
@ -1,171 +0,0 @@
|
|||||||
set(LUA_LIB_SRCS
|
|
||||||
"src/lapi.c"
|
|
||||||
"src/lcode.c"
|
|
||||||
"src/lctype.c"
|
|
||||||
"src/ldebug.c"
|
|
||||||
"src/ldo.c"
|
|
||||||
"src/ldump.c"
|
|
||||||
"src/lfunc.c"
|
|
||||||
"src/lgc.c"
|
|
||||||
"src/llex.c"
|
|
||||||
"src/lmem.c"
|
|
||||||
"src/lobject.c"
|
|
||||||
"src/lopcodes.c"
|
|
||||||
"src/lparser.c"
|
|
||||||
"src/lstate.c"
|
|
||||||
"src/lstring.c"
|
|
||||||
"src/ltable.c"
|
|
||||||
"src/ltm.c"
|
|
||||||
"src/lundump.c"
|
|
||||||
"src/lvm.c"
|
|
||||||
"src/lzio.c"
|
|
||||||
"src/lauxlib.c"
|
|
||||||
"src/lbaselib.c"
|
|
||||||
"src/lcorolib.c"
|
|
||||||
"src/ldblib.c"
|
|
||||||
"src/liolib.c"
|
|
||||||
"src/lmathlib.c"
|
|
||||||
"src/loadlib.c"
|
|
||||||
"src/loslib.c"
|
|
||||||
"src/lstrlib.c"
|
|
||||||
"src/ltablib.c"
|
|
||||||
"src/lutf8lib.c"
|
|
||||||
"src/linit.c"
|
|
||||||
)
|
|
||||||
|
|
||||||
set(TARGETS_TO_INSTALL lua_internal lua_include)
|
|
||||||
|
|
||||||
set(LUA_LINKED_LIBRARIES)
|
|
||||||
|
|
||||||
if(LUA_BUILD_AS_CXX)
|
|
||||||
set_source_files_properties(${LUA_LIB_SRCS} "src/lua.c" "src/luac.c" PROPERTIES LANGUAGE CXX )
|
|
||||||
endif()
|
|
||||||
|
|
||||||
add_library(lua_internal INTERFACE)
|
|
||||||
|
|
||||||
add_library(lua_include INTERFACE)
|
|
||||||
|
|
||||||
target_include_directories(lua_include INTERFACE
|
|
||||||
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
|
|
||||||
$<INSTALL_INTERFACE:include>
|
|
||||||
)
|
|
||||||
|
|
||||||
target_link_libraries(lua_internal INTERFACE lua_include)
|
|
||||||
|
|
||||||
if(LUA_ENABLE_SHARED)
|
|
||||||
add_library(lua_shared SHARED ${LUA_LIB_SRCS})
|
|
||||||
target_link_libraries(lua_shared PRIVATE lua_internal PUBLIC lua_include)
|
|
||||||
set_target_properties(lua_shared PROPERTIES
|
|
||||||
VERSION "${PACKAGE_VERSION}"
|
|
||||||
)
|
|
||||||
if(WIN32)
|
|
||||||
target_compile_definitions(lua_shared PRIVATE LUA_BUILD_AS_DLL)
|
|
||||||
endif()
|
|
||||||
list(APPEND TARGETS_TO_INSTALL lua_shared)
|
|
||||||
if(BUILD_SHARED_LIBS)
|
|
||||||
add_library(Lua::Library ALIAS lua_shared)
|
|
||||||
elseif(NOT TOP_LEVEL)
|
|
||||||
set_target_properties(lua_shared PROPERTIES
|
|
||||||
EXCLUDE_FROM_ALL ON
|
|
||||||
)
|
|
||||||
endif()
|
|
||||||
endif()
|
|
||||||
|
|
||||||
add_library(lua_static STATIC ${LUA_LIB_SRCS})
|
|
||||||
target_link_libraries(lua_static PRIVATE lua_internal PUBLIC lua_include)
|
|
||||||
set_target_properties(lua_static PROPERTIES
|
|
||||||
VERSION "${PACKAGE_VERSION}"
|
|
||||||
)
|
|
||||||
list(APPEND TARGETS_TO_INSTALL lua_static)
|
|
||||||
if(NOT BUILD_SHARED_LIBS OR NOT LUA_ENABLE_SHARED)
|
|
||||||
add_library(Lua::Library ALIAS lua_static)
|
|
||||||
endif()
|
|
||||||
|
|
||||||
|
|
||||||
if(UNIX)
|
|
||||||
if(NOT EMSCRIPTEN)
|
|
||||||
find_library(LIBM m)
|
|
||||||
#TODO: Redo this with find_package
|
|
||||||
if(NOT LIBM)
|
|
||||||
message(FATAL_ERROR "libm not found and is required by lua")
|
|
||||||
endif()
|
|
||||||
target_compile_definitions(lua_internal INTERFACE "LUA_USE_POSIX")
|
|
||||||
target_link_libraries(lua_internal INTERFACE m)
|
|
||||||
list(APPEND LUA_LINKED_LIBRARIES m)
|
|
||||||
if(LUA_SUPPORT_DL)
|
|
||||||
find_library(LIBDL "${CMAKE_DL_LIBS}")
|
|
||||||
if(NOT LIBDL)
|
|
||||||
message(FATAL_ERROR "libdl not found and is required by lua")
|
|
||||||
endif()
|
|
||||||
target_compile_definitions(lua_internal INTERFACE "LUA_USE_DLOPEN")
|
|
||||||
target_link_libraries(lua_internal INTERFACE "${CMAKE_DL_LIBS}")
|
|
||||||
list(APPEND LUA_LINKED_LIBRARIES "${CMAKE_DL_LIBS}")
|
|
||||||
endif()
|
|
||||||
endif()
|
|
||||||
|
|
||||||
target_compile_options(lua_internal
|
|
||||||
INTERFACE "-Wall" "-Wextra"
|
|
||||||
)
|
|
||||||
elseif(Win32)
|
|
||||||
target_compile_options(lua_internal
|
|
||||||
INTERFACE "/Wall"
|
|
||||||
)
|
|
||||||
endif()
|
|
||||||
|
|
||||||
if(LUA_BUILD_BINARY)
|
|
||||||
include(CheckIncludeFile)
|
|
||||||
CHECK_INCLUDE_FILE("readline/readline.h" HAVE_READLINE_READLINE_H)
|
|
||||||
|
|
||||||
add_executable(lua "src/lua.c")
|
|
||||||
# Can not use lua_shared because some symbols are not exported
|
|
||||||
target_link_libraries(lua PRIVATE lua_static)
|
|
||||||
set_target_properties(lua PROPERTIES
|
|
||||||
RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}
|
|
||||||
)
|
|
||||||
if (HAVE_READLINE_READLINE_H)
|
|
||||||
target_compile_definitions(lua PRIVATE "LUA_USE_READLINE")
|
|
||||||
target_link_libraries(lua PUBLIC readline)
|
|
||||||
endif()
|
|
||||||
list(APPEND TARGETS_TO_INSTALL lua)
|
|
||||||
endif()
|
|
||||||
|
|
||||||
if(LUA_BUILD_COMPILER)
|
|
||||||
add_executable(luac "src/luac.c")
|
|
||||||
target_link_libraries(luac PRIVATE lua_static)
|
|
||||||
set_target_properties(luac PROPERTIES
|
|
||||||
RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}
|
|
||||||
)
|
|
||||||
list(APPEND TARGETS_TO_INSTALL luac)
|
|
||||||
endif()
|
|
||||||
|
|
||||||
install(TARGETS ${TARGETS_TO_INSTALL}
|
|
||||||
EXPORT LuaTargets
|
|
||||||
)
|
|
||||||
|
|
||||||
install(DIRECTORY include/ TYPE INCLUDE)
|
|
||||||
|
|
||||||
include(CMakePackageConfigHelpers)
|
|
||||||
|
|
||||||
get_target_property(LUA_EXPORT_LIBRARY Lua::Library ALIASED_TARGET)
|
|
||||||
write_basic_package_version_file(
|
|
||||||
LuaConfigVersion.cmake
|
|
||||||
VERSION ${PACKAGE_VERSION}
|
|
||||||
COMPATIBILITY SameMajorVersion
|
|
||||||
)
|
|
||||||
|
|
||||||
install(EXPORT LuaTargets
|
|
||||||
FILE LuaTargets.cmake
|
|
||||||
DESTINATION "share/cmake/Lua"
|
|
||||||
NAMESPACE Lua::
|
|
||||||
)
|
|
||||||
|
|
||||||
configure_package_config_file(
|
|
||||||
LuaConfig.cmake.in
|
|
||||||
"${CMAKE_CURRENT_BINARY_DIR}/LuaConfig.cmake"
|
|
||||||
INSTALL_DESTINATION "share/cmake/Lua"
|
|
||||||
)
|
|
||||||
|
|
||||||
install(FILES "${CMAKE_CURRENT_BINARY_DIR}/LuaConfig.cmake"
|
|
||||||
"${CMAKE_CURRENT_BINARY_DIR}/LuaConfigVersion.cmake"
|
|
||||||
DESTINATION "share/cmake/Lua"
|
|
||||||
)
|
|
||||||
@ -1,23 +0,0 @@
|
|||||||
@PACKAGE_INIT@
|
|
||||||
|
|
||||||
include("${CMAKE_CURRENT_LIST_DIR}/LuaTargets.cmake")
|
|
||||||
|
|
||||||
set_and_check(LUA_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/include")
|
|
||||||
add_library(Lua::Library ALIAS "Lua::@LUA_EXPORT_LIBRARY@")
|
|
||||||
get_target_property(LUA_CONFIG "Lua::@LUA_EXPORT_LIBRARY@" IMPORTED_CONFIGURATIONS)
|
|
||||||
get_target_property(LUA_LIBRARY "Lua::@LUA_EXPORT_LIBRARY@" "IMPORTED_LOCATION_${LUA_CONFIG}")
|
|
||||||
set(LUA_LIBRARIES "${LUA_LIBRARY}")
|
|
||||||
add_library(LUA_INCLUDE_LIB INTERFACE)
|
|
||||||
target_include_directories(LUA_INCLUDE_LIB INTERFACE "${LUA_INCLUDE_DIR}")
|
|
||||||
list(APPEND LUA_LIBRARIES LUA_INCLUDE_LIB)
|
|
||||||
|
|
||||||
foreach(LIB_NAME @LUA_LINKED_LIBRARIES@)
|
|
||||||
find_library(LIB_LOCATION "${LIB_NAME}")
|
|
||||||
if(NOT LIB_LOCATION)
|
|
||||||
message(FATAL_ERROR "lib${LIB_NAME} not found and is required by lua")
|
|
||||||
else()
|
|
||||||
list(APPEND LUA_LIBRARIES "${LIB_LOCATION}")
|
|
||||||
endif()
|
|
||||||
endforeach()
|
|
||||||
|
|
||||||
check_required_components(Lua)
|
|
||||||
@ -1,106 +0,0 @@
|
|||||||
# Makefile for installing Lua
|
|
||||||
# See doc/readme.html for installation and customization instructions.
|
|
||||||
|
|
||||||
# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
|
|
||||||
|
|
||||||
# Your platform. See PLATS for possible values.
|
|
||||||
PLAT= guess
|
|
||||||
|
|
||||||
# Where to install. The installation starts in the src and doc directories,
|
|
||||||
# so take care if INSTALL_TOP is not an absolute path. See the local target.
|
|
||||||
# You may want to make INSTALL_LMOD and INSTALL_CMOD consistent with
|
|
||||||
# LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h.
|
|
||||||
INSTALL_TOP= /usr/local
|
|
||||||
INSTALL_BIN= $(INSTALL_TOP)/bin
|
|
||||||
INSTALL_INC= $(INSTALL_TOP)/include
|
|
||||||
INSTALL_LIB= $(INSTALL_TOP)/lib
|
|
||||||
INSTALL_MAN= $(INSTALL_TOP)/man/man1
|
|
||||||
INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V
|
|
||||||
INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V
|
|
||||||
|
|
||||||
# How to install. If your install program does not support "-p", then
|
|
||||||
# you may have to run ranlib on the installed liblua.a.
|
|
||||||
INSTALL= install -p
|
|
||||||
INSTALL_EXEC= $(INSTALL) -m 0755
|
|
||||||
INSTALL_DATA= $(INSTALL) -m 0644
|
|
||||||
#
|
|
||||||
# If you don't have "install" you can use "cp" instead.
|
|
||||||
# INSTALL= cp -p
|
|
||||||
# INSTALL_EXEC= $(INSTALL)
|
|
||||||
# INSTALL_DATA= $(INSTALL)
|
|
||||||
|
|
||||||
# Other utilities.
|
|
||||||
MKDIR= mkdir -p
|
|
||||||
RM= rm -f
|
|
||||||
|
|
||||||
# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
|
|
||||||
|
|
||||||
# Convenience platforms targets.
|
|
||||||
PLATS= guess aix bsd c89 freebsd generic ios linux linux-readline macosx mingw posix solaris
|
|
||||||
|
|
||||||
# What to install.
|
|
||||||
TO_BIN= lua luac
|
|
||||||
TO_INC= lua.h luaconf.h lualib.h lauxlib.h lua.hpp
|
|
||||||
TO_LIB= liblua.a
|
|
||||||
TO_MAN= lua.1 luac.1
|
|
||||||
|
|
||||||
# Lua version and release.
|
|
||||||
V= 5.4
|
|
||||||
R= $V.5
|
|
||||||
|
|
||||||
# Targets start here.
|
|
||||||
all: $(PLAT)
|
|
||||||
|
|
||||||
$(PLATS) help test clean:
|
|
||||||
@cd src && $(MAKE) $@
|
|
||||||
|
|
||||||
install: dummy
|
|
||||||
cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)
|
|
||||||
cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
|
|
||||||
cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
|
|
||||||
cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
|
|
||||||
cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
|
|
||||||
|
|
||||||
uninstall:
|
|
||||||
cd src && cd $(INSTALL_BIN) && $(RM) $(TO_BIN)
|
|
||||||
cd src && cd $(INSTALL_INC) && $(RM) $(TO_INC)
|
|
||||||
cd src && cd $(INSTALL_LIB) && $(RM) $(TO_LIB)
|
|
||||||
cd doc && cd $(INSTALL_MAN) && $(RM) $(TO_MAN)
|
|
||||||
|
|
||||||
local:
|
|
||||||
$(MAKE) install INSTALL_TOP=../install
|
|
||||||
|
|
||||||
# make may get confused with install/ if it does not support .PHONY.
|
|
||||||
dummy:
|
|
||||||
|
|
||||||
# Echo config parameters.
|
|
||||||
echo:
|
|
||||||
@cd src && $(MAKE) -s echo
|
|
||||||
@echo "PLAT= $(PLAT)"
|
|
||||||
@echo "V= $V"
|
|
||||||
@echo "R= $R"
|
|
||||||
@echo "TO_BIN= $(TO_BIN)"
|
|
||||||
@echo "TO_INC= $(TO_INC)"
|
|
||||||
@echo "TO_LIB= $(TO_LIB)"
|
|
||||||
@echo "TO_MAN= $(TO_MAN)"
|
|
||||||
@echo "INSTALL_TOP= $(INSTALL_TOP)"
|
|
||||||
@echo "INSTALL_BIN= $(INSTALL_BIN)"
|
|
||||||
@echo "INSTALL_INC= $(INSTALL_INC)"
|
|
||||||
@echo "INSTALL_LIB= $(INSTALL_LIB)"
|
|
||||||
@echo "INSTALL_MAN= $(INSTALL_MAN)"
|
|
||||||
@echo "INSTALL_LMOD= $(INSTALL_LMOD)"
|
|
||||||
@echo "INSTALL_CMOD= $(INSTALL_CMOD)"
|
|
||||||
@echo "INSTALL_EXEC= $(INSTALL_EXEC)"
|
|
||||||
@echo "INSTALL_DATA= $(INSTALL_DATA)"
|
|
||||||
|
|
||||||
# Echo pkg-config data.
|
|
||||||
pc:
|
|
||||||
@echo "version=$R"
|
|
||||||
@echo "prefix=$(INSTALL_TOP)"
|
|
||||||
@echo "libdir=$(INSTALL_LIB)"
|
|
||||||
@echo "includedir=$(INSTALL_INC)"
|
|
||||||
|
|
||||||
# Targets that do not create files (not all makes understand .PHONY).
|
|
||||||
.PHONY: all $(PLATS) help test clean install uninstall local dummy echo pc
|
|
||||||
|
|
||||||
# (end of Makefile)
|
|
||||||
@ -1,6 +0,0 @@
|
|||||||
|
|
||||||
This is Lua 5.4.5, released on 18 Apr 2023.
|
|
||||||
|
|
||||||
For installation instructions, license details, and
|
|
||||||
further information about Lua, see doc/readme.html.
|
|
||||||
|
|
||||||
@ -1,678 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
<HTML>
|
|
||||||
<HEAD>
|
|
||||||
<TITLE>Lua 5.4 Reference Manual - contents</TITLE>
|
|
||||||
<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
|
|
||||||
<LINK REL="stylesheet" TYPE="text/css" HREF="index.css">
|
|
||||||
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
|
|
||||||
</HEAD>
|
|
||||||
|
|
||||||
<BODY>
|
|
||||||
|
|
||||||
<H1>
|
|
||||||
<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua"></A>
|
|
||||||
Lua 5.4 Reference Manual
|
|
||||||
</H1>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
The reference manual is the official definition of the Lua language.
|
|
||||||
<BR>
|
|
||||||
For a complete introduction to Lua programming, see the book
|
|
||||||
<A HREF="http://www.lua.org/pil/">Programming in Lua</A>.
|
|
||||||
|
|
||||||
<DIV CLASS="menubar">
|
|
||||||
<A HREF="manual.html">start</A>
|
|
||||||
·
|
|
||||||
<A HREF="#contents">contents</A>
|
|
||||||
·
|
|
||||||
<A HREF="#index">index</A>
|
|
||||||
·
|
|
||||||
<A HREF="http://www.lua.org/manual/">other versions</A>
|
|
||||||
</DIV>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<SMALL>
|
|
||||||
Copyright © 2020–2023 Lua.org, PUC-Rio.
|
|
||||||
Freely available under the terms of the
|
|
||||||
<A HREF="http://www.lua.org/license.html">Lua license</A>.
|
|
||||||
</SMALL>
|
|
||||||
|
|
||||||
<H2><A NAME="contents">Contents</A></H2>
|
|
||||||
<UL CLASS="contents menubar">
|
|
||||||
<LI><A HREF="manual.html">1 – Introduction</A>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#2">2 – Basic Concepts</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#2.1">2.1 – Values and Types</A>
|
|
||||||
<LI><A HREF="manual.html#2.2">2.2 – Environments and the Global Environment</A>
|
|
||||||
<LI><A HREF="manual.html#2.3">2.3 – Error Handling</A>
|
|
||||||
<LI><A HREF="manual.html#2.4">2.4 – Metatables and Metamethods</A>
|
|
||||||
<LI><A HREF="manual.html#2.5">2.5 – Garbage Collection</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#2.5.1">2.5.1 – Incremental Garbage Collection</A>
|
|
||||||
<LI><A HREF="manual.html#2.5.2">2.5.2 – Generational Garbage Collection</A>
|
|
||||||
<LI><A HREF="manual.html#2.5.3">2.5.3 – Garbage-Collection Metamethods</A>
|
|
||||||
<LI><A HREF="manual.html#2.5.4">2.5.4 – Weak Tables</A>
|
|
||||||
</UL>
|
|
||||||
<LI><A HREF="manual.html#2.6">2.6 – Coroutines</A>
|
|
||||||
</UL>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#3">3 – The Language</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#3.1">3.1 – Lexical Conventions</A>
|
|
||||||
<LI><A HREF="manual.html#3.2">3.2 – Variables</A>
|
|
||||||
<LI><A HREF="manual.html#3.3">3.3 – Statements</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#3.3.1">3.3.1 – Blocks</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.2">3.3.2 – Chunks</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.3">3.3.3 – Assignment</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.4">3.3.4 – Control Structures</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.5">3.3.5 – For Statement</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.6">3.3.6 – Function Calls as Statements</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.7">3.3.7 – Local Declarations</A>
|
|
||||||
<LI><A HREF="manual.html#3.3.8">3.3.8 – To-be-closed Variables</A>
|
|
||||||
</UL>
|
|
||||||
<LI><A HREF="manual.html#3.4">3.4 – Expressions</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#3.4.1">3.4.1 – Arithmetic Operators</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.2">3.4.2 – Bitwise Operators</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.3">3.4.3 – Coercions and Conversions</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.4">3.4.4 – Relational Operators</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.5">3.4.5 – Logical Operators</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.6">3.4.6 – Concatenation</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.7">3.4.7 – The Length Operator</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.8">3.4.8 – Precedence</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.9">3.4.9 – Table Constructors</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.10">3.4.10 – Function Calls</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.11">3.4.11 – Function Definitions</A>
|
|
||||||
<LI><A HREF="manual.html#3.4.12">3.4.12 – Lists of expressions, multiple results, and adjustment<A>
|
|
||||||
|
|
||||||
</UL>
|
|
||||||
<LI><A HREF="manual.html#3.5">3.5 – Visibility Rules</A>
|
|
||||||
</UL>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#4">4 – The Application Program Interface</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#4.1">4.1 – The Stack</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#4.1.1">4.1.1 – Stack Size</A>
|
|
||||||
<LI><A HREF="manual.html#4.1.2">4.1.2 – Valid and Acceptable Indices</A>
|
|
||||||
<LI><A HREF="manual.html#4.1.3">4.1.3 – Pointers to strings</A>
|
|
||||||
</UL>
|
|
||||||
<LI><A HREF="manual.html#4.2">4.2 – C Closures</A>
|
|
||||||
<LI><A HREF="manual.html#4.3">4.3 – Registry</A>
|
|
||||||
<LI><A HREF="manual.html#4.4">4.4 – Error Handling in C</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#4.4.1">4.4.1 – Status Codes</A>
|
|
||||||
</UL>
|
|
||||||
<LI><A HREF="manual.html#4.5">4.5 – Handling Yields in C</A>
|
|
||||||
<LI><A HREF="manual.html#4.6">4.6 – Functions and Types</A>
|
|
||||||
<LI><A HREF="manual.html#4.7">4.7 – The Debug Interface</A>
|
|
||||||
</UL>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#5">5 – The Auxiliary Library</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#5.1">5.1 – Functions and Types</A>
|
|
||||||
</UL>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#6">6 – The Standard Libraries</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#6.1">6.1 – Basic Functions</A>
|
|
||||||
<LI><A HREF="manual.html#6.2">6.2 – Coroutine Manipulation</A>
|
|
||||||
<LI><A HREF="manual.html#6.3">6.3 – Modules</A>
|
|
||||||
<LI><A HREF="manual.html#6.4">6.4 – String Manipulation</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#6.4.1">6.4.1 – Patterns</A>
|
|
||||||
<LI><A HREF="manual.html#6.4.2">6.4.2 – Format Strings for Pack and Unpack</A>
|
|
||||||
</UL>
|
|
||||||
<LI><A HREF="manual.html#6.5">6.5 – UTF-8 Support</A>
|
|
||||||
<LI><A HREF="manual.html#6.6">6.6 – Table Manipulation</A>
|
|
||||||
<LI><A HREF="manual.html#6.7">6.7 – Mathematical Functions</A>
|
|
||||||
<LI><A HREF="manual.html#6.8">6.8 – Input and Output Facilities</A>
|
|
||||||
<LI><A HREF="manual.html#6.9">6.9 – Operating System Facilities</A>
|
|
||||||
<LI><A HREF="manual.html#6.10">6.10 – The Debug Library</A>
|
|
||||||
</UL>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#7">7 – Lua Standalone</A>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#8">8 – Incompatibilities with the Previous Version</A>
|
|
||||||
<UL>
|
|
||||||
<LI><A HREF="manual.html#8.1">8.1 – Incompatibilities in the Language</A>
|
|
||||||
<LI><A HREF="manual.html#8.2">8.2 – Incompatibilities in the Libraries</A>
|
|
||||||
<LI><A HREF="manual.html#8.3">8.3 – Incompatibilities in the API</A>
|
|
||||||
</UL>
|
|
||||||
<P>
|
|
||||||
<LI><A HREF="manual.html#9">9 – The Complete Syntax of Lua</A>
|
|
||||||
</UL>
|
|
||||||
|
|
||||||
<H2><A NAME="index">Index</A></H2>
|
|
||||||
<TABLE CLASS="menubar" WIDTH="100%">
|
|
||||||
<TR>
|
|
||||||
<TD>
|
|
||||||
<H3><A NAME="functions">Lua functions</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.1">basic</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-_G">_G</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-_VERSION">_VERSION</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-assert">assert</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-collectgarbage">collectgarbage</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-dofile">dofile</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-error">error</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-getmetatable">getmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-ipairs">ipairs</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-load">load</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-loadfile">loadfile</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-next">next</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-pairs">pairs</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-pcall">pcall</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-print">print</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-rawequal">rawequal</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-rawget">rawget</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-rawlen">rawlen</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-rawset">rawset</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-require">require</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-select">select</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-setmetatable">setmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-tonumber">tonumber</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-tostring">tostring</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-type">type</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-warn">warn</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-xpcall">xpcall</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.2">coroutine</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.close">coroutine.close</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.create">coroutine.create</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.isyieldable">coroutine.isyieldable</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.resume">coroutine.resume</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.running">coroutine.running</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.status">coroutine.status</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.wrap">coroutine.wrap</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-coroutine.yield">coroutine.yield</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.10">debug</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.debug">debug.debug</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.gethook">debug.gethook</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.getinfo">debug.getinfo</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.getlocal">debug.getlocal</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.getmetatable">debug.getmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.getregistry">debug.getregistry</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.getupvalue">debug.getupvalue</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.getuservalue">debug.getuservalue</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.sethook">debug.sethook</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.setlocal">debug.setlocal</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.setmetatable">debug.setmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.setupvalue">debug.setupvalue</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.setuservalue">debug.setuservalue</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.traceback">debug.traceback</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.upvalueid">debug.upvalueid</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-debug.upvaluejoin">debug.upvaluejoin</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.8">io</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.close">io.close</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.flush">io.flush</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.input">io.input</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.lines">io.lines</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.open">io.open</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.output">io.output</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.popen">io.popen</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.read">io.read</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.stderr">io.stderr</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.stdin">io.stdin</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.stdout">io.stdout</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.tmpfile">io.tmpfile</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.type">io.type</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-io.write">io.write</A><BR>
|
|
||||||
|
|
||||||
<A HREF="manual.html#pdf-file:close">file:close</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-file:flush">file:flush</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-file:lines">file:lines</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-file:read">file:read</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-file:seek">file:seek</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-file:setvbuf">file:setvbuf</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-file:write">file:write</A><BR>
|
|
||||||
|
|
||||||
</TD>
|
|
||||||
<TD>
|
|
||||||
<H3> </H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.7">math</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.abs">math.abs</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.acos">math.acos</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.asin">math.asin</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.atan">math.atan</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.ceil">math.ceil</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.cos">math.cos</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.deg">math.deg</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.exp">math.exp</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.floor">math.floor</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.fmod">math.fmod</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.huge">math.huge</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.log">math.log</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.max">math.max</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.maxinteger">math.maxinteger</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.min">math.min</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.mininteger">math.mininteger</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.modf">math.modf</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.pi">math.pi</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.rad">math.rad</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.random">math.random</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.randomseed">math.randomseed</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.sin">math.sin</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.sqrt">math.sqrt</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.tan">math.tan</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.tointeger">math.tointeger</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.type">math.type</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-math.ult">math.ult</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.9">os</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.clock">os.clock</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.date">os.date</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.difftime">os.difftime</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.execute">os.execute</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.exit">os.exit</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.getenv">os.getenv</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.remove">os.remove</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.rename">os.rename</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.setlocale">os.setlocale</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.time">os.time</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-os.tmpname">os.tmpname</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.3">package</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.config">package.config</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.cpath">package.cpath</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.loaded">package.loaded</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.loadlib">package.loadlib</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.path">package.path</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.preload">package.preload</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.searchers">package.searchers</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-package.searchpath">package.searchpath</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.4">string</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.byte">string.byte</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.char">string.char</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.dump">string.dump</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.find">string.find</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.format">string.format</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.gmatch">string.gmatch</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.gsub">string.gsub</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.len">string.len</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.lower">string.lower</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.match">string.match</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.pack">string.pack</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.packsize">string.packsize</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.rep">string.rep</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.reverse">string.reverse</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.sub">string.sub</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.unpack">string.unpack</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-string.upper">string.upper</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.6">table</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.concat">table.concat</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.insert">table.insert</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.move">table.move</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.pack">table.pack</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.remove">table.remove</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.sort">table.sort</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-table.unpack">table.unpack</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#6.5">utf8</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-utf8.char">utf8.char</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-utf8.charpattern">utf8.charpattern</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-utf8.codepoint">utf8.codepoint</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-utf8.codes">utf8.codes</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-utf8.len">utf8.len</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-utf8.offset">utf8.offset</A><BR>
|
|
||||||
|
|
||||||
<H3><A NAME="metamethods">metamethods</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#2.4">__add</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__band</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__bnot</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__bor</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__bxor</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__call</A><BR>
|
|
||||||
<A HREF="manual.html#3.3.8">__close</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__concat</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__div</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__eq</A><BR>
|
|
||||||
<A HREF="manual.html#2.5.3">__gc</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__idiv</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__index</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__le</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__len</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__lt</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-getmetatable">__metatable</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__mod</A><BR>
|
|
||||||
<A HREF="manual.html#2.5.4">__mode</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__mul</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_newmetatable">__name</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__newindex</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-pairs">__pairs</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__pow</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__shl</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__shr</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__sub</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-tostring">__tostring</A><BR>
|
|
||||||
<A HREF="manual.html#2.4">__unm</A><BR>
|
|
||||||
|
|
||||||
<H3><A NAME="env">environment<BR>variables</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#pdf-LUA_CPATH">LUA_CPATH</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_CPATH_5_4">LUA_CPATH_5_4</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_INIT">LUA_INIT</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_INIT_5_4">LUA_INIT_5_4</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_PATH">LUA_PATH</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_PATH_5_4">LUA_PATH_5_4</A><BR>
|
|
||||||
|
|
||||||
</TD>
|
|
||||||
<TD>
|
|
||||||
<H3><A NAME="api">C API</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#lua_Alloc">lua_Alloc</A><BR>
|
|
||||||
<A HREF="manual.html#lua_CFunction">lua_CFunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Debug">lua_Debug</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Hook">lua_Hook</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Integer">lua_Integer</A><BR>
|
|
||||||
<A HREF="manual.html#lua_KContext">lua_KContext</A><BR>
|
|
||||||
<A HREF="manual.html#lua_KFunction">lua_KFunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Number">lua_Number</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Reader">lua_Reader</A><BR>
|
|
||||||
<A HREF="manual.html#lua_State">lua_State</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Unsigned">lua_Unsigned</A><BR>
|
|
||||||
<A HREF="manual.html#lua_WarnFunction">lua_WarnFunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_Writer">lua_Writer</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#lua_absindex">lua_absindex</A><BR>
|
|
||||||
<A HREF="manual.html#lua_arith">lua_arith</A><BR>
|
|
||||||
<A HREF="manual.html#lua_atpanic">lua_atpanic</A><BR>
|
|
||||||
<A HREF="manual.html#lua_call">lua_call</A><BR>
|
|
||||||
<A HREF="manual.html#lua_callk">lua_callk</A><BR>
|
|
||||||
<A HREF="manual.html#lua_checkstack">lua_checkstack</A><BR>
|
|
||||||
<A HREF="manual.html#lua_close">lua_close</A><BR>
|
|
||||||
<A HREF="manual.html#lua_closeslot">lua_closeslot</A><BR>
|
|
||||||
<A HREF="manual.html#lua_compare">lua_compare</A><BR>
|
|
||||||
<A HREF="manual.html#lua_concat">lua_concat</A><BR>
|
|
||||||
<A HREF="manual.html#lua_copy">lua_copy</A><BR>
|
|
||||||
<A HREF="manual.html#lua_createtable">lua_createtable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_dump">lua_dump</A><BR>
|
|
||||||
<A HREF="manual.html#lua_error">lua_error</A><BR>
|
|
||||||
<A HREF="manual.html#lua_gc">lua_gc</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getallocf">lua_getallocf</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getextraspace">lua_getextraspace</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getfield">lua_getfield</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getglobal">lua_getglobal</A><BR>
|
|
||||||
<A HREF="manual.html#lua_gethook">lua_gethook</A><BR>
|
|
||||||
<A HREF="manual.html#lua_gethookcount">lua_gethookcount</A><BR>
|
|
||||||
<A HREF="manual.html#lua_gethookmask">lua_gethookmask</A><BR>
|
|
||||||
<A HREF="manual.html#lua_geti">lua_geti</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getinfo">lua_getinfo</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getiuservalue">lua_getiuservalue</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getlocal">lua_getlocal</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getmetatable">lua_getmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getstack">lua_getstack</A><BR>
|
|
||||||
<A HREF="manual.html#lua_gettable">lua_gettable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_gettop">lua_gettop</A><BR>
|
|
||||||
<A HREF="manual.html#lua_getupvalue">lua_getupvalue</A><BR>
|
|
||||||
<A HREF="manual.html#lua_insert">lua_insert</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isboolean">lua_isboolean</A><BR>
|
|
||||||
<A HREF="manual.html#lua_iscfunction">lua_iscfunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isfunction">lua_isfunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isinteger">lua_isinteger</A><BR>
|
|
||||||
<A HREF="manual.html#lua_islightuserdata">lua_islightuserdata</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isnil">lua_isnil</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isnone">lua_isnone</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isnoneornil">lua_isnoneornil</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isnumber">lua_isnumber</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isstring">lua_isstring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_istable">lua_istable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isthread">lua_isthread</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isuserdata">lua_isuserdata</A><BR>
|
|
||||||
<A HREF="manual.html#lua_isyieldable">lua_isyieldable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_len">lua_len</A><BR>
|
|
||||||
<A HREF="manual.html#lua_load">lua_load</A><BR>
|
|
||||||
<A HREF="manual.html#lua_newstate">lua_newstate</A><BR>
|
|
||||||
<A HREF="manual.html#lua_newtable">lua_newtable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_newthread">lua_newthread</A><BR>
|
|
||||||
<A HREF="manual.html#lua_newuserdatauv">lua_newuserdatauv</A><BR>
|
|
||||||
<A HREF="manual.html#lua_next">lua_next</A><BR>
|
|
||||||
<A HREF="manual.html#lua_numbertointeger">lua_numbertointeger</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pcall">lua_pcall</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pcallk">lua_pcallk</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pop">lua_pop</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushboolean">lua_pushboolean</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushcclosure">lua_pushcclosure</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushcfunction">lua_pushcfunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushfstring">lua_pushfstring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushglobaltable">lua_pushglobaltable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushinteger">lua_pushinteger</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushlightuserdata">lua_pushlightuserdata</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushliteral">lua_pushliteral</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushlstring">lua_pushlstring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushnil">lua_pushnil</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushnumber">lua_pushnumber</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushstring">lua_pushstring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushthread">lua_pushthread</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushvalue">lua_pushvalue</A><BR>
|
|
||||||
<A HREF="manual.html#lua_pushvfstring">lua_pushvfstring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawequal">lua_rawequal</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawget">lua_rawget</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawgeti">lua_rawgeti</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawgetp">lua_rawgetp</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawlen">lua_rawlen</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawset">lua_rawset</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawseti">lua_rawseti</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rawsetp">lua_rawsetp</A><BR>
|
|
||||||
<A HREF="manual.html#lua_register">lua_register</A><BR>
|
|
||||||
<A HREF="manual.html#lua_remove">lua_remove</A><BR>
|
|
||||||
<A HREF="manual.html#lua_replace">lua_replace</A><BR>
|
|
||||||
<A HREF="manual.html#lua_resetthread">lua_resetthread</A><BR>
|
|
||||||
<A HREF="manual.html#lua_resume">lua_resume</A><BR>
|
|
||||||
<A HREF="manual.html#lua_rotate">lua_rotate</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setallocf">lua_setallocf</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setfield">lua_setfield</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setglobal">lua_setglobal</A><BR>
|
|
||||||
<A HREF="manual.html#lua_sethook">lua_sethook</A><BR>
|
|
||||||
<A HREF="manual.html#lua_seti">lua_seti</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setiuservalue">lua_setiuservalue</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setlocal">lua_setlocal</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setmetatable">lua_setmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_settable">lua_settable</A><BR>
|
|
||||||
<A HREF="manual.html#lua_settop">lua_settop</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setupvalue">lua_setupvalue</A><BR>
|
|
||||||
<A HREF="manual.html#lua_setwarnf">lua_setwarnf</A><BR>
|
|
||||||
<A HREF="manual.html#lua_status">lua_status</A><BR>
|
|
||||||
<A HREF="manual.html#lua_stringtonumber">lua_stringtonumber</A><BR>
|
|
||||||
<A HREF="manual.html#lua_toboolean">lua_toboolean</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tocfunction">lua_tocfunction</A><BR>
|
|
||||||
<A HREF="manual.html#lua_toclose">lua_toclose</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tointeger">lua_tointeger</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tointegerx">lua_tointegerx</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tolstring">lua_tolstring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tonumber">lua_tonumber</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tonumberx">lua_tonumberx</A><BR>
|
|
||||||
<A HREF="manual.html#lua_topointer">lua_topointer</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tostring">lua_tostring</A><BR>
|
|
||||||
<A HREF="manual.html#lua_tothread">lua_tothread</A><BR>
|
|
||||||
<A HREF="manual.html#lua_touserdata">lua_touserdata</A><BR>
|
|
||||||
<A HREF="manual.html#lua_type">lua_type</A><BR>
|
|
||||||
<A HREF="manual.html#lua_typename">lua_typename</A><BR>
|
|
||||||
<A HREF="manual.html#lua_upvalueid">lua_upvalueid</A><BR>
|
|
||||||
<A HREF="manual.html#lua_upvalueindex">lua_upvalueindex</A><BR>
|
|
||||||
<A HREF="manual.html#lua_upvaluejoin">lua_upvaluejoin</A><BR>
|
|
||||||
<A HREF="manual.html#lua_version">lua_version</A><BR>
|
|
||||||
<A HREF="manual.html#lua_warning">lua_warning</A><BR>
|
|
||||||
<A HREF="manual.html#lua_xmove">lua_xmove</A><BR>
|
|
||||||
<A HREF="manual.html#lua_yield">lua_yield</A><BR>
|
|
||||||
<A HREF="manual.html#lua_yieldk">lua_yieldk</A><BR>
|
|
||||||
|
|
||||||
</TD>
|
|
||||||
<TD>
|
|
||||||
<H3><A NAME="auxlib">auxiliary library</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#luaL_Buffer">luaL_Buffer</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_Reg">luaL_Reg</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_Stream">luaL_Stream</A><BR>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#luaL_addchar">luaL_addchar</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_addgsub">luaL_addgsub</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_addlstring">luaL_addlstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_addsize">luaL_addsize</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_addstring">luaL_addstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_addvalue">luaL_addvalue</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_argcheck">luaL_argcheck</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_argerror">luaL_argerror</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_argexpected">luaL_argexpected</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_buffaddr">luaL_buffaddr</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_buffinit">luaL_buffinit</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_buffinitsize">luaL_buffinitsize</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_bufflen">luaL_bufflen</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_buffsub">luaL_buffsub</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_callmeta">luaL_callmeta</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkany">luaL_checkany</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkinteger">luaL_checkinteger</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checklstring">luaL_checklstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checknumber">luaL_checknumber</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkoption">luaL_checkoption</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkstack">luaL_checkstack</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkstring">luaL_checkstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checktype">luaL_checktype</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkudata">luaL_checkudata</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_checkversion">luaL_checkversion</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_dofile">luaL_dofile</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_dostring">luaL_dostring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_error">luaL_error</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_execresult">luaL_execresult</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_fileresult">luaL_fileresult</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_getmetafield">luaL_getmetafield</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_getmetatable">luaL_getmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_getsubtable">luaL_getsubtable</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_gsub">luaL_gsub</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_len">luaL_len</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_loadbuffer">luaL_loadbuffer</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_loadbufferx">luaL_loadbufferx</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_loadfile">luaL_loadfile</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_loadfilex">luaL_loadfilex</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_loadstring">luaL_loadstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_newlib">luaL_newlib</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_newlibtable">luaL_newlibtable</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_newmetatable">luaL_newmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_newstate">luaL_newstate</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_openlibs">luaL_openlibs</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_opt">luaL_opt</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_optinteger">luaL_optinteger</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_optlstring">luaL_optlstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_optnumber">luaL_optnumber</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_optstring">luaL_optstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_prepbuffer">luaL_prepbuffer</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_prepbuffsize">luaL_prepbuffsize</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_pushfail">luaL_pushfail</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_pushresult">luaL_pushresult</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_pushresultsize">luaL_pushresultsize</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_ref">luaL_ref</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_requiref">luaL_requiref</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_setfuncs">luaL_setfuncs</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_setmetatable">luaL_setmetatable</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_testudata">luaL_testudata</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_tolstring">luaL_tolstring</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_traceback">luaL_traceback</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_typeerror">luaL_typeerror</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_typename">luaL_typename</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_unref">luaL_unref</A><BR>
|
|
||||||
<A HREF="manual.html#luaL_where">luaL_where</A><BR>
|
|
||||||
|
|
||||||
<H3><A NAME="library">standard library</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_base">luaopen_base</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_coroutine">luaopen_coroutine</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_debug">luaopen_debug</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_io">luaopen_io</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_math">luaopen_math</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_os">luaopen_os</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_package">luaopen_package</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_string">luaopen_string</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_table">luaopen_table</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-luaopen_utf8">luaopen_utf8</A><BR>
|
|
||||||
|
|
||||||
<H3><A NAME="constants">constants</A></H3>
|
|
||||||
<P>
|
|
||||||
<A HREF="manual.html#pdf-LUA_ERRERR">LUA_ERRERR</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_ERRFILE">LUA_ERRFILE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_ERRMEM">LUA_ERRMEM</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_ERRRUN">LUA_ERRRUN</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_ERRSYNTAX">LUA_ERRSYNTAX</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_HOOKCALL">LUA_HOOKCALL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_HOOKCOUNT">LUA_HOOKCOUNT</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_HOOKLINE">LUA_HOOKLINE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_HOOKRET">LUA_HOOKRET</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_HOOKTAILCALL">LUA_HOOKTAILCALL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_LOADED_TABLE">LUA_LOADED_TABLE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MASKCALL">LUA_MASKCALL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MASKCOUNT">LUA_MASKCOUNT</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MASKLINE">LUA_MASKLINE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MASKRET">LUA_MASKRET</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MAXINTEGER">LUA_MAXINTEGER</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MININTEGER">LUA_MININTEGER</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MINSTACK">LUA_MINSTACK</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_MULTRET">LUA_MULTRET</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_NOREF">LUA_NOREF</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OK">LUA_OK</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPADD">LUA_OPADD</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPBAND">LUA_OPBAND</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPBNOT">LUA_OPBNOT</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPBOR">LUA_OPBOR</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPBXOR">LUA_OPBXOR</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPDIV">LUA_OPDIV</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPEQ">LUA_OPEQ</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPIDIV">LUA_OPIDIV</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPLE">LUA_OPLE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPLT">LUA_OPLT</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPMOD">LUA_OPMOD</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPMUL">LUA_OPMUL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPPOW">LUA_OPPOW</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPSHL">LUA_OPSHL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPSHR">LUA_OPSHR</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPSUB">LUA_OPSUB</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_OPUNM">LUA_OPUNM</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_PRELOAD_TABLE">LUA_PRELOAD_TABLE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_REFNIL">LUA_REFNIL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_REGISTRYINDEX">LUA_REGISTRYINDEX</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_RIDX_GLOBALS">LUA_RIDX_GLOBALS</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_RIDX_MAINTHREAD">LUA_RIDX_MAINTHREAD</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TBOOLEAN">LUA_TBOOLEAN</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TFUNCTION">LUA_TFUNCTION</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TLIGHTUSERDATA">LUA_TLIGHTUSERDATA</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TNIL">LUA_TNIL</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TNONE">LUA_TNONE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TNUMBER">LUA_TNUMBER</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TSTRING">LUA_TSTRING</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TTABLE">LUA_TTABLE</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TTHREAD">LUA_TTHREAD</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_TUSERDATA">LUA_TUSERDATA</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_USE_APICHECK">LUA_USE_APICHECK</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUA_YIELD">LUA_YIELD</A><BR>
|
|
||||||
<A HREF="manual.html#pdf-LUAL_BUFFERSIZE">LUAL_BUFFERSIZE</A><BR>
|
|
||||||
|
|
||||||
</TD>
|
|
||||||
</TR>
|
|
||||||
</TABLE>
|
|
||||||
|
|
||||||
<P CLASS="footer">
|
|
||||||
Last update:
|
|
||||||
Sat Apr 1 17:57:05 UTC 2023
|
|
||||||
</P>
|
|
||||||
<!--
|
|
||||||
Last change: revised for Lua 5.4.5
|
|
||||||
-->
|
|
||||||
|
|
||||||
</BODY>
|
|
||||||
</HTML>
|
|
||||||
@ -1,21 +0,0 @@
|
|||||||
ul {
|
|
||||||
list-style-type: none ;
|
|
||||||
}
|
|
||||||
|
|
||||||
ul.contents {
|
|
||||||
padding: 0 ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table {
|
|
||||||
border: none ;
|
|
||||||
border-spacing: 0 ;
|
|
||||||
border-collapse: collapse ;
|
|
||||||
}
|
|
||||||
|
|
||||||
td {
|
|
||||||
vertical-align: top ;
|
|
||||||
padding: 0 ;
|
|
||||||
text-align: left ;
|
|
||||||
line-height: 1.25 ;
|
|
||||||
width: 15% ;
|
|
||||||
}
|
|
||||||
Binary file not shown.
|
Before Width: | Height: | Size: 9.7 KiB |
@ -1,155 +0,0 @@
|
|||||||
.\" $Id: lua.man,v 1.14 2022/09/23 09:06:36 lhf Exp $
|
|
||||||
.TH LUA 1 "$Date: 2022/09/23 09:06:36 $"
|
|
||||||
.SH NAME
|
|
||||||
lua \- Lua interpreter
|
|
||||||
.SH SYNOPSIS
|
|
||||||
.B lua
|
|
||||||
[
|
|
||||||
.I options
|
|
||||||
]
|
|
||||||
[
|
|
||||||
.I script
|
|
||||||
[
|
|
||||||
.I args
|
|
||||||
]
|
|
||||||
]
|
|
||||||
.SH DESCRIPTION
|
|
||||||
.B lua
|
|
||||||
is the standalone Lua interpreter.
|
|
||||||
It loads and executes Lua programs,
|
|
||||||
either in textual source form or
|
|
||||||
in precompiled binary form.
|
|
||||||
(Precompiled binaries are output by
|
|
||||||
.BR luac ,
|
|
||||||
the Lua compiler.)
|
|
||||||
.B lua
|
|
||||||
can be used as a batch interpreter and also interactively.
|
|
||||||
.LP
|
|
||||||
After handling the
|
|
||||||
.IR options ,
|
|
||||||
the Lua program in file
|
|
||||||
.I script
|
|
||||||
is loaded and executed.
|
|
||||||
The
|
|
||||||
.I args
|
|
||||||
are available to
|
|
||||||
.I script
|
|
||||||
as strings in a global table named
|
|
||||||
.B arg
|
|
||||||
and also as arguments to its main function.
|
|
||||||
When called without arguments,
|
|
||||||
.B lua
|
|
||||||
behaves as
|
|
||||||
.B "lua \-v \-i"
|
|
||||||
if the standard input is a terminal,
|
|
||||||
and as
|
|
||||||
.B "lua \-"
|
|
||||||
otherwise.
|
|
||||||
.LP
|
|
||||||
In interactive mode,
|
|
||||||
.B lua
|
|
||||||
prompts the user,
|
|
||||||
reads lines from the standard input,
|
|
||||||
and executes them as they are read.
|
|
||||||
If the line contains an expression,
|
|
||||||
then the line is evaluated and the result is printed.
|
|
||||||
If a line does not contain a complete statement,
|
|
||||||
then a secondary prompt is displayed and
|
|
||||||
lines are read until a complete statement is formed or
|
|
||||||
a syntax error is found.
|
|
||||||
.LP
|
|
||||||
Before handling command line options and scripts,
|
|
||||||
.B lua
|
|
||||||
checks the contents of the environment variables
|
|
||||||
.B LUA_INIT_5_4
|
|
||||||
and
|
|
||||||
.BR LUA_INIT ,
|
|
||||||
in that order.
|
|
||||||
If the contents are of the form
|
|
||||||
.RI '@ filename ',
|
|
||||||
then
|
|
||||||
.I filename
|
|
||||||
is executed.
|
|
||||||
Otherwise, the contents are assumed to be a Lua statement and is executed.
|
|
||||||
When
|
|
||||||
.B LUA_INIT_5_4
|
|
||||||
is defined,
|
|
||||||
.B LUA_INIT
|
|
||||||
is ignored.
|
|
||||||
.SH OPTIONS
|
|
||||||
.TP
|
|
||||||
.BI \-e " stat"
|
|
||||||
execute statement
|
|
||||||
.IR stat .
|
|
||||||
.TP
|
|
||||||
.B \-i
|
|
||||||
enter interactive mode after executing
|
|
||||||
.IR script .
|
|
||||||
.TP
|
|
||||||
.BI \-l " mod"
|
|
||||||
require library
|
|
||||||
.I mod
|
|
||||||
into global
|
|
||||||
.IR mod .
|
|
||||||
.TP
|
|
||||||
.BI \-l " g=mod"
|
|
||||||
require library
|
|
||||||
.I mod
|
|
||||||
into global
|
|
||||||
.IR g .
|
|
||||||
.TP
|
|
||||||
.B \-v
|
|
||||||
show version information.
|
|
||||||
.TP
|
|
||||||
.B \-E
|
|
||||||
ignore environment variables.
|
|
||||||
.TP
|
|
||||||
.B \-W
|
|
||||||
turn warnings on.
|
|
||||||
.TP
|
|
||||||
.B \-\-
|
|
||||||
stop handling options.
|
|
||||||
.TP
|
|
||||||
.B \-
|
|
||||||
stop handling options and execute the standard input as a file.
|
|
||||||
.SH ENVIRONMENT VARIABLES
|
|
||||||
The following environment variables affect the execution of
|
|
||||||
.BR lua .
|
|
||||||
When defined,
|
|
||||||
the version-specific variants take priority
|
|
||||||
and the version-neutral variants are ignored.
|
|
||||||
.TP
|
|
||||||
.B LUA_INIT, LUA_INIT_5_4
|
|
||||||
Code to be executed before command line options and scripts.
|
|
||||||
.TP
|
|
||||||
.B LUA_PATH, LUA_PATH_5_4
|
|
||||||
Initial value of package.cpath,
|
|
||||||
the path used by require to search for Lua loaders.
|
|
||||||
.TP
|
|
||||||
.B LUA_CPATH, LUA_CPATH_5_4
|
|
||||||
Initial value of package.cpath,
|
|
||||||
the path used by require to search for C loaders.
|
|
||||||
.SH EXIT STATUS
|
|
||||||
If a script calls os.exit,
|
|
||||||
then
|
|
||||||
.B lua
|
|
||||||
exits with the given exit status.
|
|
||||||
Otherwise,
|
|
||||||
.B lua
|
|
||||||
exits
|
|
||||||
with EXIT_SUCCESS (0 on POSIX systems) if there were no errors
|
|
||||||
and
|
|
||||||
with EXIT_FAILURE (1 on POSIX systems) if there were errors.
|
|
||||||
Errors raised in interactive mode do not cause exits.
|
|
||||||
.SH DIAGNOSTICS
|
|
||||||
Error messages should be self explanatory.
|
|
||||||
.SH "SEE ALSO"
|
|
||||||
.BR luac (1)
|
|
||||||
.br
|
|
||||||
The documentation at lua.org,
|
|
||||||
especially section 7 of the reference manual.
|
|
||||||
.SH AUTHORS
|
|
||||||
R. Ierusalimschy,
|
|
||||||
L. H. de Figueiredo,
|
|
||||||
W. Celes
|
|
||||||
.\" EOF
|
|
||||||
@ -1,161 +0,0 @@
|
|||||||
html {
|
|
||||||
background-color: #F8F8F8 ;
|
|
||||||
}
|
|
||||||
|
|
||||||
body {
|
|
||||||
background-color: #FFFFFF ;
|
|
||||||
color: #000000 ;
|
|
||||||
font-family: Helvetica, Arial, sans-serif ;
|
|
||||||
text-align: justify ;
|
|
||||||
line-height: 1.25 ;
|
|
||||||
margin: 16px auto ;
|
|
||||||
padding: 32px ;
|
|
||||||
border: solid #ccc 1px ;
|
|
||||||
border-radius: 20px ;
|
|
||||||
max-width: 70em ;
|
|
||||||
width: 90% ;
|
|
||||||
}
|
|
||||||
|
|
||||||
h1, h2, h3, h4 {
|
|
||||||
color: #000080 ;
|
|
||||||
font-family: Verdana, Geneva, sans-serif ;
|
|
||||||
font-weight: normal ;
|
|
||||||
font-style: normal ;
|
|
||||||
text-align: left ;
|
|
||||||
}
|
|
||||||
|
|
||||||
h1 {
|
|
||||||
font-size: 28pt ;
|
|
||||||
}
|
|
||||||
|
|
||||||
h1 img {
|
|
||||||
vertical-align: text-bottom ;
|
|
||||||
}
|
|
||||||
|
|
||||||
h2:before {
|
|
||||||
content: "\2756" ;
|
|
||||||
padding-right: 0.5em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
a {
|
|
||||||
text-decoration: none ;
|
|
||||||
}
|
|
||||||
|
|
||||||
a:link {
|
|
||||||
color: #000080 ;
|
|
||||||
}
|
|
||||||
|
|
||||||
a:link:hover, a:visited:hover {
|
|
||||||
background-color: #D0D0FF ;
|
|
||||||
color: #000080 ;
|
|
||||||
border-radius: 4px ;
|
|
||||||
}
|
|
||||||
|
|
||||||
a:link:active, a:visited:active {
|
|
||||||
color: #FF0000 ;
|
|
||||||
}
|
|
||||||
|
|
||||||
div.menubar {
|
|
||||||
padding-bottom: 0.5em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
p.menubar {
|
|
||||||
margin-left: 2.5em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
.menubar a:hover {
|
|
||||||
margin: -3px -3px -3px -3px ;
|
|
||||||
padding: 3px 3px 3px 3px ;
|
|
||||||
border-radius: 4px ;
|
|
||||||
}
|
|
||||||
|
|
||||||
:target {
|
|
||||||
background-color: #F0F0F0 ;
|
|
||||||
margin: -8px ;
|
|
||||||
padding: 8px ;
|
|
||||||
border-radius: 8px ;
|
|
||||||
outline: none ;
|
|
||||||
}
|
|
||||||
|
|
||||||
hr {
|
|
||||||
display: none ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table hr {
|
|
||||||
background-color: #a0a0a0 ;
|
|
||||||
color: #a0a0a0 ;
|
|
||||||
border: 0 ;
|
|
||||||
height: 1px ;
|
|
||||||
display: block ;
|
|
||||||
}
|
|
||||||
|
|
||||||
.footer {
|
|
||||||
color: gray ;
|
|
||||||
font-size: x-small ;
|
|
||||||
text-transform: lowercase ;
|
|
||||||
}
|
|
||||||
|
|
||||||
input[type=text] {
|
|
||||||
border: solid #a0a0a0 2px ;
|
|
||||||
border-radius: 2em ;
|
|
||||||
background-image: url('images/search.png') ;
|
|
||||||
background-repeat: no-repeat ;
|
|
||||||
background-position: 4px center ;
|
|
||||||
padding-left: 20px ;
|
|
||||||
height: 2em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
pre.session {
|
|
||||||
background-color: #F8F8F8 ;
|
|
||||||
padding: 1em ;
|
|
||||||
border-radius: 8px ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table {
|
|
||||||
border: none ;
|
|
||||||
border-spacing: 0 ;
|
|
||||||
border-collapse: collapse ;
|
|
||||||
}
|
|
||||||
|
|
||||||
td {
|
|
||||||
padding: 0 ;
|
|
||||||
margin: 0 ;
|
|
||||||
}
|
|
||||||
|
|
||||||
td.gutter {
|
|
||||||
width: 4% ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table.columns td {
|
|
||||||
vertical-align: top ;
|
|
||||||
padding-bottom: 1em ;
|
|
||||||
text-align: justify ;
|
|
||||||
line-height: 1.25 ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table.book td {
|
|
||||||
vertical-align: top ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table.book td.cover {
|
|
||||||
padding-right: 1em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table.book img {
|
|
||||||
border: solid #000080 1px ;
|
|
||||||
}
|
|
||||||
|
|
||||||
table.book span {
|
|
||||||
font-size: small ;
|
|
||||||
text-align: left ;
|
|
||||||
display: block ;
|
|
||||||
margin-top: 0.25em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
p.logos a:link:hover, p.logos a:visited:hover {
|
|
||||||
background-color: inherit ;
|
|
||||||
}
|
|
||||||
|
|
||||||
img {
|
|
||||||
background-color: white ;
|
|
||||||
}
|
|
||||||
@ -1,118 +0,0 @@
|
|||||||
.\" $Id: luac.man,v 1.29 2011/11/16 13:53:40 lhf Exp $
|
|
||||||
.TH LUAC 1 "$Date: 2011/11/16 13:53:40 $"
|
|
||||||
.SH NAME
|
|
||||||
luac \- Lua compiler
|
|
||||||
.SH SYNOPSIS
|
|
||||||
.B luac
|
|
||||||
[
|
|
||||||
.I options
|
|
||||||
] [
|
|
||||||
.I filenames
|
|
||||||
]
|
|
||||||
.SH DESCRIPTION
|
|
||||||
.B luac
|
|
||||||
is the Lua compiler.
|
|
||||||
It translates programs written in the Lua programming language
|
|
||||||
into binary files containing precompiled chunks
|
|
||||||
that can be later loaded and executed.
|
|
||||||
.LP
|
|
||||||
The main advantages of precompiling chunks are:
|
|
||||||
faster loading,
|
|
||||||
protecting source code from accidental user changes,
|
|
||||||
and
|
|
||||||
off-line syntax checking.
|
|
||||||
Precompiling does not imply faster execution
|
|
||||||
because in Lua chunks are always compiled into bytecodes before being executed.
|
|
||||||
.B luac
|
|
||||||
simply allows those bytecodes to be saved in a file for later execution.
|
|
||||||
Precompiled chunks are not necessarily smaller than the corresponding source.
|
|
||||||
The main goal in precompiling is faster loading.
|
|
||||||
.LP
|
|
||||||
In the command line,
|
|
||||||
you can mix
|
|
||||||
text files containing Lua source and
|
|
||||||
binary files containing precompiled chunks.
|
|
||||||
.B luac
|
|
||||||
produces a single output file containing the combined bytecodes
|
|
||||||
for all files given.
|
|
||||||
Executing the combined file is equivalent to executing the given files.
|
|
||||||
By default,
|
|
||||||
the output file is named
|
|
||||||
.BR luac.out ,
|
|
||||||
but you can change this with the
|
|
||||||
.B \-o
|
|
||||||
option.
|
|
||||||
.LP
|
|
||||||
Precompiled chunks are
|
|
||||||
.I not
|
|
||||||
portable across different architectures.
|
|
||||||
Moreover,
|
|
||||||
the internal format of precompiled chunks
|
|
||||||
is likely to change when a new version of Lua is released.
|
|
||||||
Make sure you save the source files of all Lua programs that you precompile.
|
|
||||||
.LP
|
|
||||||
.SH OPTIONS
|
|
||||||
.TP
|
|
||||||
.B \-l
|
|
||||||
produce a listing of the compiled bytecode for Lua's virtual machine.
|
|
||||||
Listing bytecodes is useful to learn about Lua's virtual machine.
|
|
||||||
If no files are given, then
|
|
||||||
.B luac
|
|
||||||
loads
|
|
||||||
.B luac.out
|
|
||||||
and lists its contents.
|
|
||||||
Use
|
|
||||||
.B \-l \-l
|
|
||||||
for a full listing.
|
|
||||||
.TP
|
|
||||||
.BI \-o " file"
|
|
||||||
output to
|
|
||||||
.IR file ,
|
|
||||||
instead of the default
|
|
||||||
.BR luac.out .
|
|
||||||
(You can use
|
|
||||||
.B "'\-'"
|
|
||||||
for standard output,
|
|
||||||
but not on platforms that open standard output in text mode.)
|
|
||||||
The output file may be one of the given files because
|
|
||||||
all files are loaded before the output file is written.
|
|
||||||
Be careful not to overwrite precious files.
|
|
||||||
.TP
|
|
||||||
.B \-p
|
|
||||||
load files but do not generate any output file.
|
|
||||||
Used mainly for syntax checking and for testing precompiled chunks:
|
|
||||||
corrupted files will probably generate errors when loaded.
|
|
||||||
If no files are given, then
|
|
||||||
.B luac
|
|
||||||
loads
|
|
||||||
.B luac.out
|
|
||||||
and tests its contents.
|
|
||||||
No messages are displayed if the file loads without errors.
|
|
||||||
.TP
|
|
||||||
.B \-s
|
|
||||||
strip debug information before writing the output file.
|
|
||||||
This saves some space in very large chunks,
|
|
||||||
but if errors occur when running a stripped chunk,
|
|
||||||
then the error messages may not contain the full information they usually do.
|
|
||||||
In particular,
|
|
||||||
line numbers and names of local variables are lost.
|
|
||||||
.TP
|
|
||||||
.B \-v
|
|
||||||
show version information.
|
|
||||||
.TP
|
|
||||||
.B \-\-
|
|
||||||
stop handling options.
|
|
||||||
.TP
|
|
||||||
.B \-
|
|
||||||
stop handling options and process standard input.
|
|
||||||
.SH "SEE ALSO"
|
|
||||||
.BR lua (1)
|
|
||||||
.br
|
|
||||||
The documentation at lua.org.
|
|
||||||
.SH DIAGNOSTICS
|
|
||||||
Error messages should be self explanatory.
|
|
||||||
.SH AUTHORS
|
|
||||||
R. Ierusalimschy,
|
|
||||||
L. H. de Figueiredo,
|
|
||||||
W. Celes
|
|
||||||
.\" EOF
|
|
||||||
@ -1,21 +0,0 @@
|
|||||||
h3 code {
|
|
||||||
font-family: inherit ;
|
|
||||||
font-size: inherit ;
|
|
||||||
}
|
|
||||||
|
|
||||||
pre, code {
|
|
||||||
font-size: 12pt ;
|
|
||||||
}
|
|
||||||
|
|
||||||
span.apii {
|
|
||||||
color: gray ;
|
|
||||||
float: right ;
|
|
||||||
font-family: inherit ;
|
|
||||||
font-style: normal ;
|
|
||||||
font-size: small ;
|
|
||||||
}
|
|
||||||
|
|
||||||
h2:before {
|
|
||||||
content: "" ;
|
|
||||||
padding-right: 0em ;
|
|
||||||
}
|
|
||||||
File diff suppressed because it is too large
Load Diff
Binary file not shown.
|
Before Width: | Height: | Size: 3.7 KiB |
@ -1,337 +0,0 @@
|
|||||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
|
||||||
<HTML>
|
|
||||||
<HEAD>
|
|
||||||
<TITLE>Lua 5.4 readme</TITLE>
|
|
||||||
<LINK REL="stylesheet" TYPE="text/css" HREF="lua.css">
|
|
||||||
<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-1">
|
|
||||||
<STYLE TYPE="text/css">
|
|
||||||
blockquote, .display {
|
|
||||||
border: solid #a0a0a0 2px ;
|
|
||||||
border-radius: 8px ;
|
|
||||||
padding: 1em ;
|
|
||||||
margin: 0px ;
|
|
||||||
}
|
|
||||||
|
|
||||||
.display {
|
|
||||||
word-spacing: 0.25em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
dl.display dd {
|
|
||||||
padding-bottom: 0.2em ;
|
|
||||||
}
|
|
||||||
|
|
||||||
tt, kbd, code {
|
|
||||||
font-size: 12pt ;
|
|
||||||
}
|
|
||||||
</STYLE>
|
|
||||||
</HEAD>
|
|
||||||
|
|
||||||
<BODY>
|
|
||||||
|
|
||||||
<H1>
|
|
||||||
<A HREF="http://www.lua.org/"><IMG SRC="logo.gif" ALT="Lua"></A>
|
|
||||||
Welcome to Lua 5.4
|
|
||||||
</H1>
|
|
||||||
|
|
||||||
<DIV CLASS="menubar">
|
|
||||||
<A HREF="#about">about</A>
|
|
||||||
·
|
|
||||||
<A HREF="#install">installation</A>
|
|
||||||
·
|
|
||||||
<A HREF="#changes">changes</A>
|
|
||||||
·
|
|
||||||
<A HREF="#license">license</A>
|
|
||||||
·
|
|
||||||
<A HREF="contents.html">reference manual</A>
|
|
||||||
</DIV>
|
|
||||||
|
|
||||||
<H2><A NAME="about">About Lua</A></H2>
|
|
||||||
<P>
|
|
||||||
Lua is a powerful, efficient, lightweight, embeddable scripting language
|
|
||||||
developed by a
|
|
||||||
<A HREF="http://www.lua.org/authors.html">team</A>
|
|
||||||
at
|
|
||||||
<A HREF="http://www.puc-rio.br/">PUC-Rio</A>,
|
|
||||||
the Pontifical Catholic University of Rio de Janeiro in Brazil.
|
|
||||||
Lua is
|
|
||||||
<A HREF="#license">free software</A>
|
|
||||||
used in
|
|
||||||
<A HREF="http://www.lua.org/uses.html">many products and projects</A>
|
|
||||||
around the world.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
Lua's
|
|
||||||
<A HREF="http://www.lua.org/">official web site</A>
|
|
||||||
provides complete information
|
|
||||||
about Lua,
|
|
||||||
including
|
|
||||||
an
|
|
||||||
<A HREF="http://www.lua.org/about.html">executive summary</A>
|
|
||||||
and
|
|
||||||
updated
|
|
||||||
<A HREF="http://www.lua.org/docs.html">documentation</A>,
|
|
||||||
especially the
|
|
||||||
<A HREF="http://www.lua.org/manual/5.4/">reference manual</A>,
|
|
||||||
which may differ slightly from the
|
|
||||||
<A HREF="contents.html">local copy</A>
|
|
||||||
distributed in this package.
|
|
||||||
|
|
||||||
<H2><A NAME="install">Installing Lua</A></H2>
|
|
||||||
<P>
|
|
||||||
Lua is distributed in
|
|
||||||
<A HREF="http://www.lua.org/ftp/">source</A>
|
|
||||||
form.
|
|
||||||
You need to build it before using it.
|
|
||||||
Building Lua should be straightforward
|
|
||||||
because
|
|
||||||
Lua is implemented in pure ANSI C and compiles unmodified in all known
|
|
||||||
platforms that have an ANSI C compiler.
|
|
||||||
Lua also compiles unmodified as C++.
|
|
||||||
The instructions given below for building Lua are for Unix-like platforms,
|
|
||||||
such as Linux and Mac OS X.
|
|
||||||
See also
|
|
||||||
<A HREF="#other">instructions for other systems</A>
|
|
||||||
and
|
|
||||||
<A HREF="#customization">customization options</A>.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
If you don't have the time or the inclination to compile Lua yourself,
|
|
||||||
get a binary from
|
|
||||||
<A HREF="http://lua-users.org/wiki/LuaBinaries">LuaBinaries</A>.
|
|
||||||
|
|
||||||
<H3>Building Lua</H3>
|
|
||||||
<P>
|
|
||||||
In most common Unix-like platforms, simply do "<KBD>make</KBD>".
|
|
||||||
Here are the details.
|
|
||||||
|
|
||||||
<OL>
|
|
||||||
<LI>
|
|
||||||
Open a terminal window and move to
|
|
||||||
the top-level directory, which is named <TT>lua-5.4.5</TT>.
|
|
||||||
The <TT>Makefile</TT> there controls both the build process and the installation process.
|
|
||||||
<P>
|
|
||||||
<LI>
|
|
||||||
Do "<KBD>make</KBD>". The <TT>Makefile</TT> will guess your platform and build Lua for it.
|
|
||||||
<P>
|
|
||||||
<LI>
|
|
||||||
If the guess failed, do "<KBD>make help</KBD>" and see if your platform is listed.
|
|
||||||
The platforms currently supported are:
|
|
||||||
<P>
|
|
||||||
<P CLASS="display">
|
|
||||||
guess aix bsd c89 freebsd generic ios linux linux-readline macosx mingw posix solaris
|
|
||||||
</P>
|
|
||||||
<P>
|
|
||||||
If your platform is listed, just do "<KBD>make xxx</KBD>", where xxx
|
|
||||||
is your platform name.
|
|
||||||
<P>
|
|
||||||
If your platform is not listed, try the closest one or posix, generic,
|
|
||||||
c89, in this order.
|
|
||||||
<P>
|
|
||||||
<LI>
|
|
||||||
The compilation takes only a few moments
|
|
||||||
and produces three files in the <TT>src</TT> directory:
|
|
||||||
lua (the interpreter),
|
|
||||||
luac (the compiler),
|
|
||||||
and liblua.a (the library).
|
|
||||||
<P>
|
|
||||||
<LI>
|
|
||||||
To check that Lua has been built correctly, do "<KBD>make test</KBD>"
|
|
||||||
after building Lua. This will run the interpreter and print its version.
|
|
||||||
</OL>
|
|
||||||
<P>
|
|
||||||
If you're running Linux, try "<KBD>make linux-readline</KBD>" to build the interactive Lua interpreter with handy line-editing and history capabilities.
|
|
||||||
If you get compilation errors,
|
|
||||||
make sure you have installed the <TT>readline</TT> development package
|
|
||||||
(which is probably named <TT>libreadline-dev</TT> or <TT>readline-devel</TT>).
|
|
||||||
If you get link errors after that,
|
|
||||||
then try "<KBD>make linux-readline MYLIBS=-ltermcap</KBD>".
|
|
||||||
|
|
||||||
<H3>Installing Lua</H3>
|
|
||||||
<P>
|
|
||||||
Once you have built Lua, you may want to install it in an official
|
|
||||||
place in your system. In this case, do "<KBD>make install</KBD>". The official
|
|
||||||
place and the way to install files are defined in the <TT>Makefile</TT>. You'll
|
|
||||||
probably need the right permissions to install files, and so may need to do "<KBD>sudo make install</KBD>".
|
|
||||||
|
|
||||||
<P>
|
|
||||||
To build and install Lua in one step, do "<KBD>make all install</KBD>",
|
|
||||||
or "<KBD>make xxx install</KBD>",
|
|
||||||
where xxx is your platform name.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
To install Lua locally after building it, do "<KBD>make local</KBD>".
|
|
||||||
This will create a directory <TT>install</TT> with subdirectories
|
|
||||||
<TT>bin</TT>, <TT>include</TT>, <TT>lib</TT>, <TT>man</TT>, <TT>share</TT>,
|
|
||||||
and install Lua as listed below.
|
|
||||||
|
|
||||||
To install Lua locally, but in some other directory, do
|
|
||||||
"<KBD>make install INSTALL_TOP=xxx</KBD>", where xxx is your chosen directory.
|
|
||||||
The installation starts in the <TT>src</TT> and <TT>doc</TT> directories,
|
|
||||||
so take care if <TT>INSTALL_TOP</TT> is not an absolute path.
|
|
||||||
|
|
||||||
<DL CLASS="display">
|
|
||||||
<DT>
|
|
||||||
bin:
|
|
||||||
<DD>
|
|
||||||
lua luac
|
|
||||||
<DT>
|
|
||||||
include:
|
|
||||||
<DD>
|
|
||||||
lua.h luaconf.h lualib.h lauxlib.h lua.hpp
|
|
||||||
<DT>
|
|
||||||
lib:
|
|
||||||
<DD>
|
|
||||||
liblua.a
|
|
||||||
<DT>
|
|
||||||
man/man1:
|
|
||||||
<DD>
|
|
||||||
lua.1 luac.1
|
|
||||||
</DL>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
These are the only directories you need for development.
|
|
||||||
If you only want to run Lua programs,
|
|
||||||
you only need the files in <TT>bin</TT> and <TT>man</TT>.
|
|
||||||
The files in <TT>include</TT> and <TT>lib</TT> are needed for
|
|
||||||
embedding Lua in C or C++ programs.
|
|
||||||
|
|
||||||
<H3><A NAME="customization">Customization</A></H3>
|
|
||||||
<P>
|
|
||||||
Three kinds of things can be customized by editing a file:
|
|
||||||
<UL>
|
|
||||||
<LI> Where and how to install Lua — edit <TT>Makefile</TT>.
|
|
||||||
<LI> How to build Lua — edit <TT>src/Makefile</TT>.
|
|
||||||
<LI> Lua features — edit <TT>src/luaconf.h</TT>.
|
|
||||||
</UL>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
You don't actually need to edit the Makefiles because you may set the
|
|
||||||
relevant variables in the command line when invoking make.
|
|
||||||
Nevertheless, it's probably best to edit and save the Makefiles to
|
|
||||||
record the changes you've made.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
On the other hand, if you need to customize some Lua features, you'll need
|
|
||||||
to edit <TT>src/luaconf.h</TT> before building and installing Lua.
|
|
||||||
The edited file will be the one installed, and
|
|
||||||
it will be used by any Lua clients that you build, to ensure consistency.
|
|
||||||
Further customization is available to experts by editing the Lua sources.
|
|
||||||
|
|
||||||
<H3><A NAME="other">Building Lua on other systems</A></H3>
|
|
||||||
<P>
|
|
||||||
If you're not using the usual Unix tools, then the instructions for
|
|
||||||
building Lua depend on the compiler you use. You'll need to create
|
|
||||||
projects (or whatever your compiler uses) for building the library,
|
|
||||||
the interpreter, and the compiler, as follows:
|
|
||||||
|
|
||||||
<DL CLASS="display">
|
|
||||||
<DT>
|
|
||||||
library:
|
|
||||||
<DD>
|
|
||||||
lapi.c lcode.c lctype.c ldebug.c ldo.c ldump.c lfunc.c lgc.c llex.c lmem.c lobject.c lopcodes.c lparser.c lstate.c lstring.c ltable.c ltm.c lundump.c lvm.c lzio.c
|
|
||||||
lauxlib.c lbaselib.c lcorolib.c ldblib.c liolib.c lmathlib.c loadlib.c loslib.c lstrlib.c ltablib.c lutf8lib.c linit.c
|
|
||||||
<DT>
|
|
||||||
interpreter:
|
|
||||||
<DD>
|
|
||||||
library, lua.c
|
|
||||||
<DT>
|
|
||||||
compiler:
|
|
||||||
<DD>
|
|
||||||
library, luac.c
|
|
||||||
</DL>
|
|
||||||
|
|
||||||
<P>
|
|
||||||
To use Lua as a library in your own programs, you'll need to know how to
|
|
||||||
create and use libraries with your compiler. Moreover, to dynamically load
|
|
||||||
C libraries for Lua, you'll need to know how to create dynamic libraries
|
|
||||||
and you'll need to make sure that the Lua API functions are accessible to
|
|
||||||
those dynamic libraries — but <EM>don't</EM> link the Lua library
|
|
||||||
into each dynamic library. For Unix, we recommend that the Lua library
|
|
||||||
be linked statically into the host program and its symbols exported for
|
|
||||||
dynamic linking; <TT>src/Makefile</TT> does this for the Lua interpreter.
|
|
||||||
For Windows, we recommend that the Lua library be a DLL.
|
|
||||||
In all cases, the compiler luac should be linked statically.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
As mentioned above, you may edit <TT>src/luaconf.h</TT> to customize
|
|
||||||
some features before building Lua.
|
|
||||||
|
|
||||||
<H2><A NAME="changes">Changes since Lua 5.3</A></H2>
|
|
||||||
<P>
|
|
||||||
Here are the main changes introduced in Lua 5.4.
|
|
||||||
The
|
|
||||||
<A HREF="contents.html">reference manual</A>
|
|
||||||
lists the
|
|
||||||
<A HREF="manual.html#8">incompatibilities</A> that had to be introduced.
|
|
||||||
|
|
||||||
<H3>Main changes</H3>
|
|
||||||
<UL>
|
|
||||||
<LI> new generational mode for garbage collection
|
|
||||||
<LI> to-be-closed variables
|
|
||||||
<LI> const variables
|
|
||||||
<LI> userdata can have multiple user values
|
|
||||||
<LI> new implementation for math.random
|
|
||||||
<LI> warning system
|
|
||||||
<LI> debug information about function arguments and returns
|
|
||||||
<LI> new semantics for the integer 'for' loop
|
|
||||||
<LI> optional 'init' argument to 'string.gmatch'
|
|
||||||
<LI> new functions 'lua_resetthread' and 'coroutine.close'
|
|
||||||
<LI> string-to-number coercions moved to the string library
|
|
||||||
<LI> allocation function allowed to fail when shrinking a memory block
|
|
||||||
<LI> new format '%p' in 'string.format'
|
|
||||||
<LI> utf8 library accepts codepoints up to 2^31
|
|
||||||
</UL>
|
|
||||||
|
|
||||||
<H2><A NAME="license">License</A></H2>
|
|
||||||
<P>
|
|
||||||
<A HREF="http://www.opensource.org/docs/definition.php">
|
|
||||||
<IMG SRC="osi-certified-72x60.png" ALIGN="right" ALT="[osi certified]" STYLE="padding-left: 30px ;">
|
|
||||||
</A>
|
|
||||||
Lua is free software distributed under the terms of the
|
|
||||||
<A HREF="http://www.opensource.org/licenses/mit-license.html">MIT license</A>
|
|
||||||
reproduced below;
|
|
||||||
it may be used for any purpose, including commercial purposes,
|
|
||||||
at absolutely no cost without having to ask us.
|
|
||||||
|
|
||||||
The only requirement is that if you do use Lua,
|
|
||||||
then you should give us credit by including the appropriate copyright notice somewhere in your product or its documentation.
|
|
||||||
|
|
||||||
For details, see
|
|
||||||
<A HREF="http://www.lua.org/license.html">this</A>.
|
|
||||||
|
|
||||||
<BLOCKQUOTE STYLE="padding-bottom: 0em">
|
|
||||||
Copyright © 1994–2023 Lua.org, PUC-Rio.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
||||||
of this software and associated documentation files (the "Software"), to deal
|
|
||||||
in the Software without restriction, including without limitation the rights
|
|
||||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
||||||
copies of the Software, and to permit persons to whom the Software is
|
|
||||||
furnished to do so, subject to the following conditions:
|
|
||||||
|
|
||||||
<P>
|
|
||||||
The above copyright notice and this permission notice shall be included in
|
|
||||||
all copies or substantial portions of the Software.
|
|
||||||
|
|
||||||
<P>
|
|
||||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
||||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
||||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
||||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
||||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
||||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
||||||
THE SOFTWARE.
|
|
||||||
</BLOCKQUOTE>
|
|
||||||
<P>
|
|
||||||
|
|
||||||
<P CLASS="footer">
|
|
||||||
Last update:
|
|
||||||
Mon Mar 27 21:22:06 UTC 2023
|
|
||||||
</P>
|
|
||||||
<!--
|
|
||||||
Last change: revised for Lua 5.4.5
|
|
||||||
-->
|
|
||||||
|
|
||||||
</BODY>
|
|
||||||
</HTML>
|
|
||||||
@ -1,301 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lauxlib.h $
|
|
||||||
** Auxiliary functions for building Lua libraries
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef lauxlib_h
|
|
||||||
#define lauxlib_h
|
|
||||||
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
|
|
||||||
#include "luaconf.h"
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
/* global table */
|
|
||||||
#define LUA_GNAME "_G"
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct luaL_Buffer luaL_Buffer;
|
|
||||||
|
|
||||||
|
|
||||||
/* extra error code for 'luaL_loadfilex' */
|
|
||||||
#define LUA_ERRFILE (LUA_ERRERR+1)
|
|
||||||
|
|
||||||
|
|
||||||
/* key, in the registry, for table of loaded modules */
|
|
||||||
#define LUA_LOADED_TABLE "_LOADED"
|
|
||||||
|
|
||||||
|
|
||||||
/* key, in the registry, for table of preloaded loaders */
|
|
||||||
#define LUA_PRELOAD_TABLE "_PRELOAD"
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct luaL_Reg {
|
|
||||||
const char *name;
|
|
||||||
lua_CFunction func;
|
|
||||||
} luaL_Reg;
|
|
||||||
|
|
||||||
|
|
||||||
#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number))
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);
|
|
||||||
#define luaL_checkversion(L) \
|
|
||||||
luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
|
|
||||||
LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
|
|
||||||
LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
|
|
||||||
LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);
|
|
||||||
LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname);
|
|
||||||
LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,
|
|
||||||
size_t *l);
|
|
||||||
LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,
|
|
||||||
const char *def, size_t *l);
|
|
||||||
LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);
|
|
||||||
LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);
|
|
||||||
|
|
||||||
LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);
|
|
||||||
LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,
|
|
||||||
lua_Integer def);
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
|
|
||||||
LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);
|
|
||||||
LUALIB_API void (luaL_checkany) (lua_State *L, int arg);
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
|
|
||||||
LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);
|
|
||||||
LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
|
|
||||||
LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_where) (lua_State *L, int lvl);
|
|
||||||
LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,
|
|
||||||
const char *const lst[]);
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
|
|
||||||
LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
|
|
||||||
|
|
||||||
|
|
||||||
/* predefined references */
|
|
||||||
#define LUA_NOREF (-2)
|
|
||||||
#define LUA_REFNIL (-1)
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_ref) (lua_State *L, int t);
|
|
||||||
LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
|
|
||||||
const char *mode);
|
|
||||||
|
|
||||||
#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
|
|
||||||
const char *name, const char *mode);
|
|
||||||
LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
|
|
||||||
|
|
||||||
LUALIB_API lua_State *(luaL_newstate) (void);
|
|
||||||
|
|
||||||
LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_addgsub) (luaL_Buffer *b, const char *s,
|
|
||||||
const char *p, const char *r);
|
|
||||||
LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s,
|
|
||||||
const char *p, const char *r);
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
|
|
||||||
|
|
||||||
LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
|
|
||||||
const char *msg, int level);
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
|
|
||||||
lua_CFunction openf, int glb);
|
|
||||||
|
|
||||||
/*
|
|
||||||
** ===============================================================
|
|
||||||
** some useful macros
|
|
||||||
** ===============================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#define luaL_newlibtable(L,l) \
|
|
||||||
lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
|
|
||||||
|
|
||||||
#define luaL_newlib(L,l) \
|
|
||||||
(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
|
|
||||||
|
|
||||||
#define luaL_argcheck(L, cond,arg,extramsg) \
|
|
||||||
((void)(luai_likely(cond) || luaL_argerror(L, (arg), (extramsg))))
|
|
||||||
|
|
||||||
#define luaL_argexpected(L,cond,arg,tname) \
|
|
||||||
((void)(luai_likely(cond) || luaL_typeerror(L, (arg), (tname))))
|
|
||||||
|
|
||||||
#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
|
|
||||||
#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
|
|
||||||
|
|
||||||
#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
|
|
||||||
|
|
||||||
#define luaL_dofile(L, fn) \
|
|
||||||
(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
|
|
||||||
|
|
||||||
#define luaL_dostring(L, s) \
|
|
||||||
(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
|
|
||||||
|
|
||||||
#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
|
|
||||||
|
|
||||||
#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
|
|
||||||
|
|
||||||
#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Perform arithmetic operations on lua_Integer values with wrap-around
|
|
||||||
** semantics, as the Lua core does.
|
|
||||||
*/
|
|
||||||
#define luaL_intop(op,v1,v2) \
|
|
||||||
((lua_Integer)((lua_Unsigned)(v1) op (lua_Unsigned)(v2)))
|
|
||||||
|
|
||||||
|
|
||||||
/* push the value used to represent failure/error */
|
|
||||||
#define luaL_pushfail(L) lua_pushnil(L)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Internal assertions for in-house debugging
|
|
||||||
*/
|
|
||||||
#if !defined(lua_assert)
|
|
||||||
|
|
||||||
#if defined LUAI_ASSERT
|
|
||||||
#include <assert.h>
|
|
||||||
#define lua_assert(c) assert(c)
|
|
||||||
#else
|
|
||||||
#define lua_assert(c) ((void)0)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** Generic Buffer manipulation
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
struct luaL_Buffer {
|
|
||||||
char *b; /* buffer address */
|
|
||||||
size_t size; /* buffer size */
|
|
||||||
size_t n; /* number of characters in buffer */
|
|
||||||
lua_State *L;
|
|
||||||
union {
|
|
||||||
LUAI_MAXALIGN; /* ensure maximum alignment for buffer */
|
|
||||||
char b[LUAL_BUFFERSIZE]; /* initial buffer */
|
|
||||||
} init;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#define luaL_bufflen(bf) ((bf)->n)
|
|
||||||
#define luaL_buffaddr(bf) ((bf)->b)
|
|
||||||
|
|
||||||
|
|
||||||
#define luaL_addchar(B,c) \
|
|
||||||
((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
|
|
||||||
((B)->b[(B)->n++] = (c)))
|
|
||||||
|
|
||||||
#define luaL_addsize(B,s) ((B)->n += (s))
|
|
||||||
|
|
||||||
#define luaL_buffsub(B,s) ((B)->n -= (s))
|
|
||||||
|
|
||||||
LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
|
|
||||||
LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
|
|
||||||
LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
|
|
||||||
LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
|
|
||||||
LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
|
|
||||||
LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
|
|
||||||
LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
|
|
||||||
LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
|
|
||||||
|
|
||||||
#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** File handles for IO library
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
|
|
||||||
** initial structure 'luaL_Stream' (it may contain other fields
|
|
||||||
** after that initial structure).
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_FILEHANDLE "FILE*"
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct luaL_Stream {
|
|
||||||
FILE *f; /* stream (NULL for incompletely created streams) */
|
|
||||||
lua_CFunction closef; /* to close stream (NULL for closed streams) */
|
|
||||||
} luaL_Stream;
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** "Abstraction Layer" for basic report of messages and errors
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* print a string */
|
|
||||||
#if !defined(lua_writestring)
|
|
||||||
#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* print a newline and flush the output */
|
|
||||||
#if !defined(lua_writeline)
|
|
||||||
#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* print an error message */
|
|
||||||
#if !defined(lua_writestringerror)
|
|
||||||
#define lua_writestringerror(s,p) \
|
|
||||||
(fprintf(stderr, (s), (p)), fflush(stderr))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {============================================================
|
|
||||||
** Compatibility with deprecated conversions
|
|
||||||
** =============================================================
|
|
||||||
*/
|
|
||||||
#if defined(LUA_COMPAT_APIINTCASTS)
|
|
||||||
|
|
||||||
#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a))
|
|
||||||
#define luaL_optunsigned(L,a,d) \
|
|
||||||
((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))
|
|
||||||
|
|
||||||
#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
|
|
||||||
#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
|
|
||||||
|
|
||||||
#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
|
|
||||||
#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
|
|
||||||
|
|
||||||
#endif
|
|
||||||
/* }============================================================ */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
@ -1,522 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lua.h $
|
|
||||||
** Lua - A Scripting Language
|
|
||||||
** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
|
|
||||||
** See Copyright Notice at the end of this file
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef lua_h
|
|
||||||
#define lua_h
|
|
||||||
|
|
||||||
#include <stdarg.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
|
|
||||||
#include "luaconf.h"
|
|
||||||
|
|
||||||
|
|
||||||
#define LUA_VERSION_MAJOR "5"
|
|
||||||
#define LUA_VERSION_MINOR "4"
|
|
||||||
#define LUA_VERSION_RELEASE "5"
|
|
||||||
|
|
||||||
#define LUA_VERSION_NUM 504
|
|
||||||
#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 5)
|
|
||||||
|
|
||||||
#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
|
|
||||||
#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
|
|
||||||
#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2023 Lua.org, PUC-Rio"
|
|
||||||
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
|
|
||||||
|
|
||||||
|
|
||||||
/* mark for precompiled code ('<esc>Lua') */
|
|
||||||
#define LUA_SIGNATURE "\x1bLua"
|
|
||||||
|
|
||||||
/* option for multiple returns in 'lua_pcall' and 'lua_call' */
|
|
||||||
#define LUA_MULTRET (-1)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Pseudo-indices
|
|
||||||
** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty
|
|
||||||
** space after that to help overflow detection)
|
|
||||||
*/
|
|
||||||
#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000)
|
|
||||||
#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))
|
|
||||||
|
|
||||||
|
|
||||||
/* thread status */
|
|
||||||
#define LUA_OK 0
|
|
||||||
#define LUA_YIELD 1
|
|
||||||
#define LUA_ERRRUN 2
|
|
||||||
#define LUA_ERRSYNTAX 3
|
|
||||||
#define LUA_ERRMEM 4
|
|
||||||
#define LUA_ERRERR 5
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct lua_State lua_State;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** basic types
|
|
||||||
*/
|
|
||||||
#define LUA_TNONE (-1)
|
|
||||||
|
|
||||||
#define LUA_TNIL 0
|
|
||||||
#define LUA_TBOOLEAN 1
|
|
||||||
#define LUA_TLIGHTUSERDATA 2
|
|
||||||
#define LUA_TNUMBER 3
|
|
||||||
#define LUA_TSTRING 4
|
|
||||||
#define LUA_TTABLE 5
|
|
||||||
#define LUA_TFUNCTION 6
|
|
||||||
#define LUA_TUSERDATA 7
|
|
||||||
#define LUA_TTHREAD 8
|
|
||||||
|
|
||||||
#define LUA_NUMTYPES 9
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* minimum Lua stack available to a C function */
|
|
||||||
#define LUA_MINSTACK 20
|
|
||||||
|
|
||||||
|
|
||||||
/* predefined values in the registry */
|
|
||||||
#define LUA_RIDX_MAINTHREAD 1
|
|
||||||
#define LUA_RIDX_GLOBALS 2
|
|
||||||
#define LUA_RIDX_LAST LUA_RIDX_GLOBALS
|
|
||||||
|
|
||||||
|
|
||||||
/* type of numbers in Lua */
|
|
||||||
typedef LUA_NUMBER lua_Number;
|
|
||||||
|
|
||||||
|
|
||||||
/* type for integer functions */
|
|
||||||
typedef LUA_INTEGER lua_Integer;
|
|
||||||
|
|
||||||
/* unsigned integer type */
|
|
||||||
typedef LUA_UNSIGNED lua_Unsigned;
|
|
||||||
|
|
||||||
/* type for continuation-function contexts */
|
|
||||||
typedef LUA_KCONTEXT lua_KContext;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Type for C functions registered with Lua
|
|
||||||
*/
|
|
||||||
typedef int (*lua_CFunction) (lua_State *L);
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Type for continuation functions
|
|
||||||
*/
|
|
||||||
typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Type for functions that read/write blocks when loading/dumping Lua chunks
|
|
||||||
*/
|
|
||||||
typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
|
|
||||||
|
|
||||||
typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Type for memory-allocation functions
|
|
||||||
*/
|
|
||||||
typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Type for warning functions
|
|
||||||
*/
|
|
||||||
typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Type used by the debug API to collect debug information
|
|
||||||
*/
|
|
||||||
typedef struct lua_Debug lua_Debug;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Functions to be called by the debugger in specific events
|
|
||||||
*/
|
|
||||||
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** generic extra include file
|
|
||||||
*/
|
|
||||||
#if defined(LUA_USER_H)
|
|
||||||
#include LUA_USER_H
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** RCS ident string
|
|
||||||
*/
|
|
||||||
extern const char lua_ident[];
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** state manipulation
|
|
||||||
*/
|
|
||||||
LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
|
|
||||||
LUA_API void (lua_close) (lua_State *L);
|
|
||||||
LUA_API lua_State *(lua_newthread) (lua_State *L);
|
|
||||||
LUA_API int (lua_resetthread) (lua_State *L, lua_State *from);
|
|
||||||
|
|
||||||
LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API lua_Number (lua_version) (lua_State *L);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** basic stack manipulation
|
|
||||||
*/
|
|
||||||
LUA_API int (lua_absindex) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_gettop) (lua_State *L);
|
|
||||||
LUA_API void (lua_settop) (lua_State *L, int idx);
|
|
||||||
LUA_API void (lua_pushvalue) (lua_State *L, int idx);
|
|
||||||
LUA_API void (lua_rotate) (lua_State *L, int idx, int n);
|
|
||||||
LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx);
|
|
||||||
LUA_API int (lua_checkstack) (lua_State *L, int n);
|
|
||||||
|
|
||||||
LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** access functions (stack -> C)
|
|
||||||
*/
|
|
||||||
|
|
||||||
LUA_API int (lua_isnumber) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_isstring) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_iscfunction) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_isinteger) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_isuserdata) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_type) (lua_State *L, int idx);
|
|
||||||
LUA_API const char *(lua_typename) (lua_State *L, int tp);
|
|
||||||
|
|
||||||
LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum);
|
|
||||||
LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum);
|
|
||||||
LUA_API int (lua_toboolean) (lua_State *L, int idx);
|
|
||||||
LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
|
|
||||||
LUA_API lua_Unsigned (lua_rawlen) (lua_State *L, int idx);
|
|
||||||
LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
|
|
||||||
LUA_API void *(lua_touserdata) (lua_State *L, int idx);
|
|
||||||
LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
|
|
||||||
LUA_API const void *(lua_topointer) (lua_State *L, int idx);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Comparison and arithmetic functions
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_OPADD 0 /* ORDER TM, ORDER OP */
|
|
||||||
#define LUA_OPSUB 1
|
|
||||||
#define LUA_OPMUL 2
|
|
||||||
#define LUA_OPMOD 3
|
|
||||||
#define LUA_OPPOW 4
|
|
||||||
#define LUA_OPDIV 5
|
|
||||||
#define LUA_OPIDIV 6
|
|
||||||
#define LUA_OPBAND 7
|
|
||||||
#define LUA_OPBOR 8
|
|
||||||
#define LUA_OPBXOR 9
|
|
||||||
#define LUA_OPSHL 10
|
|
||||||
#define LUA_OPSHR 11
|
|
||||||
#define LUA_OPUNM 12
|
|
||||||
#define LUA_OPBNOT 13
|
|
||||||
|
|
||||||
LUA_API void (lua_arith) (lua_State *L, int op);
|
|
||||||
|
|
||||||
#define LUA_OPEQ 0
|
|
||||||
#define LUA_OPLT 1
|
|
||||||
#define LUA_OPLE 2
|
|
||||||
|
|
||||||
LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
|
|
||||||
LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** push functions (C -> stack)
|
|
||||||
*/
|
|
||||||
LUA_API void (lua_pushnil) (lua_State *L);
|
|
||||||
LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);
|
|
||||||
LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);
|
|
||||||
LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len);
|
|
||||||
LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
|
|
||||||
LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
|
|
||||||
va_list argp);
|
|
||||||
LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
|
|
||||||
LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
|
|
||||||
LUA_API void (lua_pushboolean) (lua_State *L, int b);
|
|
||||||
LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);
|
|
||||||
LUA_API int (lua_pushthread) (lua_State *L);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** get functions (Lua -> stack)
|
|
||||||
*/
|
|
||||||
LUA_API int (lua_getglobal) (lua_State *L, const char *name);
|
|
||||||
LUA_API int (lua_gettable) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k);
|
|
||||||
LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n);
|
|
||||||
LUA_API int (lua_rawget) (lua_State *L, int idx);
|
|
||||||
LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
|
|
||||||
LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
|
|
||||||
|
|
||||||
LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
|
|
||||||
LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue);
|
|
||||||
LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
|
|
||||||
LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** set functions (stack -> Lua)
|
|
||||||
*/
|
|
||||||
LUA_API void (lua_setglobal) (lua_State *L, const char *name);
|
|
||||||
LUA_API void (lua_settable) (lua_State *L, int idx);
|
|
||||||
LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);
|
|
||||||
LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n);
|
|
||||||
LUA_API void (lua_rawset) (lua_State *L, int idx);
|
|
||||||
LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
|
|
||||||
LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p);
|
|
||||||
LUA_API int (lua_setmetatable) (lua_State *L, int objindex);
|
|
||||||
LUA_API int (lua_setiuservalue) (lua_State *L, int idx, int n);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'load' and 'call' functions (load and run Lua code)
|
|
||||||
*/
|
|
||||||
LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults,
|
|
||||||
lua_KContext ctx, lua_KFunction k);
|
|
||||||
#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)
|
|
||||||
|
|
||||||
LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
|
|
||||||
lua_KContext ctx, lua_KFunction k);
|
|
||||||
#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
|
|
||||||
|
|
||||||
LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
|
|
||||||
const char *chunkname, const char *mode);
|
|
||||||
|
|
||||||
LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** coroutine functions
|
|
||||||
*/
|
|
||||||
LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx,
|
|
||||||
lua_KFunction k);
|
|
||||||
LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg,
|
|
||||||
int *nres);
|
|
||||||
LUA_API int (lua_status) (lua_State *L);
|
|
||||||
LUA_API int (lua_isyieldable) (lua_State *L);
|
|
||||||
|
|
||||||
#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Warning-related functions
|
|
||||||
*/
|
|
||||||
LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud);
|
|
||||||
LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** garbage-collection function and options
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_GCSTOP 0
|
|
||||||
#define LUA_GCRESTART 1
|
|
||||||
#define LUA_GCCOLLECT 2
|
|
||||||
#define LUA_GCCOUNT 3
|
|
||||||
#define LUA_GCCOUNTB 4
|
|
||||||
#define LUA_GCSTEP 5
|
|
||||||
#define LUA_GCSETPAUSE 6
|
|
||||||
#define LUA_GCSETSTEPMUL 7
|
|
||||||
#define LUA_GCISRUNNING 9
|
|
||||||
#define LUA_GCGEN 10
|
|
||||||
#define LUA_GCINC 11
|
|
||||||
|
|
||||||
LUA_API int (lua_gc) (lua_State *L, int what, ...);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** miscellaneous functions
|
|
||||||
*/
|
|
||||||
|
|
||||||
LUA_API int (lua_error) (lua_State *L);
|
|
||||||
|
|
||||||
LUA_API int (lua_next) (lua_State *L, int idx);
|
|
||||||
|
|
||||||
LUA_API void (lua_concat) (lua_State *L, int n);
|
|
||||||
LUA_API void (lua_len) (lua_State *L, int idx);
|
|
||||||
|
|
||||||
LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s);
|
|
||||||
|
|
||||||
LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
|
|
||||||
LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
|
|
||||||
|
|
||||||
LUA_API void (lua_toclose) (lua_State *L, int idx);
|
|
||||||
LUA_API void (lua_closeslot) (lua_State *L, int idx);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==============================================================
|
|
||||||
** some useful macros
|
|
||||||
** ===============================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE))
|
|
||||||
|
|
||||||
#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL)
|
|
||||||
#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL)
|
|
||||||
|
|
||||||
#define lua_pop(L,n) lua_settop(L, -(n)-1)
|
|
||||||
|
|
||||||
#define lua_newtable(L) lua_createtable(L, 0, 0)
|
|
||||||
|
|
||||||
#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
|
|
||||||
|
|
||||||
#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
|
|
||||||
|
|
||||||
#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
|
|
||||||
#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
|
|
||||||
#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
|
|
||||||
#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
|
|
||||||
#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
|
|
||||||
#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
|
|
||||||
#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
|
|
||||||
#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
|
|
||||||
|
|
||||||
#define lua_pushliteral(L, s) lua_pushstring(L, "" s)
|
|
||||||
|
|
||||||
#define lua_pushglobaltable(L) \
|
|
||||||
((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS))
|
|
||||||
|
|
||||||
#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
|
|
||||||
|
|
||||||
|
|
||||||
#define lua_insert(L,idx) lua_rotate(L, (idx), 1)
|
|
||||||
|
|
||||||
#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1))
|
|
||||||
|
|
||||||
#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1))
|
|
||||||
|
|
||||||
/* }============================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==============================================================
|
|
||||||
** compatibility macros
|
|
||||||
** ===============================================================
|
|
||||||
*/
|
|
||||||
#if defined(LUA_COMPAT_APIINTCASTS)
|
|
||||||
|
|
||||||
#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n))
|
|
||||||
#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is))
|
|
||||||
#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL)
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1)
|
|
||||||
#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1)
|
|
||||||
#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1)
|
|
||||||
|
|
||||||
#define LUA_NUMTAGS LUA_NUMTYPES
|
|
||||||
|
|
||||||
/* }============================================================== */
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================================
|
|
||||||
** Debug API
|
|
||||||
** =======================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Event codes
|
|
||||||
*/
|
|
||||||
#define LUA_HOOKCALL 0
|
|
||||||
#define LUA_HOOKRET 1
|
|
||||||
#define LUA_HOOKLINE 2
|
|
||||||
#define LUA_HOOKCOUNT 3
|
|
||||||
#define LUA_HOOKTAILCALL 4
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Event masks
|
|
||||||
*/
|
|
||||||
#define LUA_MASKCALL (1 << LUA_HOOKCALL)
|
|
||||||
#define LUA_MASKRET (1 << LUA_HOOKRET)
|
|
||||||
#define LUA_MASKLINE (1 << LUA_HOOKLINE)
|
|
||||||
#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
|
|
||||||
LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
|
|
||||||
LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
|
|
||||||
LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
|
|
||||||
LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
|
|
||||||
LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
|
|
||||||
|
|
||||||
LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
|
|
||||||
LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
|
|
||||||
int fidx2, int n2);
|
|
||||||
|
|
||||||
LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
|
|
||||||
LUA_API lua_Hook (lua_gethook) (lua_State *L);
|
|
||||||
LUA_API int (lua_gethookmask) (lua_State *L);
|
|
||||||
LUA_API int (lua_gethookcount) (lua_State *L);
|
|
||||||
|
|
||||||
LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit);
|
|
||||||
|
|
||||||
struct lua_Debug {
|
|
||||||
int event;
|
|
||||||
const char *name; /* (n) */
|
|
||||||
const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */
|
|
||||||
const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */
|
|
||||||
const char *source; /* (S) */
|
|
||||||
size_t srclen; /* (S) */
|
|
||||||
int currentline; /* (l) */
|
|
||||||
int linedefined; /* (S) */
|
|
||||||
int lastlinedefined; /* (S) */
|
|
||||||
unsigned char nups; /* (u) number of upvalues */
|
|
||||||
unsigned char nparams;/* (u) number of parameters */
|
|
||||||
char isvararg; /* (u) */
|
|
||||||
char istailcall; /* (t) */
|
|
||||||
unsigned short ftransfer; /* (r) index of first value transferred */
|
|
||||||
unsigned short ntransfer; /* (r) number of transferred values */
|
|
||||||
char short_src[LUA_IDSIZE]; /* (S) */
|
|
||||||
/* private part */
|
|
||||||
struct CallInfo *i_ci; /* active function */
|
|
||||||
};
|
|
||||||
|
|
||||||
/* }====================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/******************************************************************************
|
|
||||||
* Copyright (C) 1994-2023 Lua.org, PUC-Rio.
|
|
||||||
*
|
|
||||||
* Permission is hereby granted, free of charge, to any person obtaining
|
|
||||||
* a copy of this software and associated documentation files (the
|
|
||||||
* "Software"), to deal in the Software without restriction, including
|
|
||||||
* without limitation the rights to use, copy, modify, merge, publish,
|
|
||||||
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
||||||
* permit persons to whom the Software is furnished to do so, subject to
|
|
||||||
* the following conditions:
|
|
||||||
*
|
|
||||||
* The above copyright notice and this permission notice shall be
|
|
||||||
* included in all copies or substantial portions of the Software.
|
|
||||||
*
|
|
||||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
||||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
||||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
||||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
|
||||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
||||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
||||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
||||||
******************************************************************************/
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,9 +0,0 @@
|
|||||||
// lua.hpp
|
|
||||||
// Lua header files for C++
|
|
||||||
// <<extern "C">> not supplied automatically because Lua also compiles as C++
|
|
||||||
|
|
||||||
extern "C" {
|
|
||||||
#include "lua.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
#include "lauxlib.h"
|
|
||||||
}
|
|
||||||
@ -1,793 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: luaconf.h $
|
|
||||||
** Configuration file for Lua
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef luaconf_h
|
|
||||||
#define luaconf_h
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** ===================================================================
|
|
||||||
** General Configuration File for Lua
|
|
||||||
**
|
|
||||||
** Some definitions here can be changed externally, through the compiler
|
|
||||||
** (e.g., with '-D' options): They are commented out or protected
|
|
||||||
** by '#if !defined' guards. However, several other definitions
|
|
||||||
** should be changed directly here, either because they affect the
|
|
||||||
** Lua ABI (by making the changes here, you ensure that all software
|
|
||||||
** connected to Lua, such as C libraries, will be compiled with the same
|
|
||||||
** configuration); or because they are seldom changed.
|
|
||||||
**
|
|
||||||
** Search for "@@" to find all configurable definitions.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {====================================================================
|
|
||||||
** System Configuration: macros to adapt (if needed) Lua to some
|
|
||||||
** particular platform, for instance restricting it to C89.
|
|
||||||
** =====================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_USE_C89 controls the use of non-ISO-C89 features.
|
|
||||||
** Define it if you want Lua to avoid the use of a few C99 features
|
|
||||||
** or Windows-specific features on Windows.
|
|
||||||
*/
|
|
||||||
/* #define LUA_USE_C89 */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** By default, Lua on Windows use (some) specific Windows features
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE)
|
|
||||||
#define LUA_USE_WINDOWS /* enable goodies for regular Windows */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(LUA_USE_WINDOWS)
|
|
||||||
#define LUA_DL_DLL /* enable support for DLL */
|
|
||||||
#define LUA_USE_C89 /* broadly, Windows is C89 */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(LUA_USE_LINUX)
|
|
||||||
#define LUA_USE_POSIX
|
|
||||||
#define LUA_USE_DLOPEN /* needs an extra library: -ldl */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(LUA_USE_MACOSX)
|
|
||||||
#define LUA_USE_POSIX
|
|
||||||
#define LUA_USE_DLOPEN /* MacOS does not need -ldl */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(LUA_USE_IOS)
|
|
||||||
#define LUA_USE_POSIX
|
|
||||||
#define LUA_USE_DLOPEN
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits.
|
|
||||||
*/
|
|
||||||
#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3)
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Configuration for Number types. These options should not be
|
|
||||||
** set externally, because any other code connected to Lua must
|
|
||||||
** use the same configuration.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_INT_TYPE defines the type for Lua integers.
|
|
||||||
@@ LUA_FLOAT_TYPE defines the type for Lua floats.
|
|
||||||
** Lua should work fine with any mix of these options supported
|
|
||||||
** by your C compiler. The usual configurations are 64-bit integers
|
|
||||||
** and 'double' (the default), 32-bit integers and 'float' (for
|
|
||||||
** restricted platforms), and 'long'/'double' (for C compilers not
|
|
||||||
** compliant with C99, which may not have support for 'long long').
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* predefined options for LUA_INT_TYPE */
|
|
||||||
#define LUA_INT_INT 1
|
|
||||||
#define LUA_INT_LONG 2
|
|
||||||
#define LUA_INT_LONGLONG 3
|
|
||||||
|
|
||||||
/* predefined options for LUA_FLOAT_TYPE */
|
|
||||||
#define LUA_FLOAT_FLOAT 1
|
|
||||||
#define LUA_FLOAT_DOUBLE 2
|
|
||||||
#define LUA_FLOAT_LONGDOUBLE 3
|
|
||||||
|
|
||||||
|
|
||||||
/* Default configuration ('long long' and 'double', for 64-bit Lua) */
|
|
||||||
#define LUA_INT_DEFAULT LUA_INT_LONGLONG
|
|
||||||
#define LUA_FLOAT_DEFAULT LUA_FLOAT_DOUBLE
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats.
|
|
||||||
*/
|
|
||||||
#define LUA_32BITS 0
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for
|
|
||||||
** C89 ('long' and 'double'); Windows always has '__int64', so it does
|
|
||||||
** not need to use this case.
|
|
||||||
*/
|
|
||||||
#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS)
|
|
||||||
#define LUA_C89_NUMBERS 1
|
|
||||||
#else
|
|
||||||
#define LUA_C89_NUMBERS 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if LUA_32BITS /* { */
|
|
||||||
/*
|
|
||||||
** 32-bit integers and 'float'
|
|
||||||
*/
|
|
||||||
#if LUAI_IS32INT /* use 'int' if big enough */
|
|
||||||
#define LUA_INT_TYPE LUA_INT_INT
|
|
||||||
#else /* otherwise use 'long' */
|
|
||||||
#define LUA_INT_TYPE LUA_INT_LONG
|
|
||||||
#endif
|
|
||||||
#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT
|
|
||||||
|
|
||||||
#elif LUA_C89_NUMBERS /* }{ */
|
|
||||||
/*
|
|
||||||
** largest types available for C89 ('long' and 'double')
|
|
||||||
*/
|
|
||||||
#define LUA_INT_TYPE LUA_INT_LONG
|
|
||||||
#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
/* use defaults */
|
|
||||||
|
|
||||||
#define LUA_INT_TYPE LUA_INT_DEFAULT
|
|
||||||
#define LUA_FLOAT_TYPE LUA_FLOAT_DEFAULT
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Configuration for Paths.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** LUA_PATH_SEP is the character that separates templates in a path.
|
|
||||||
** LUA_PATH_MARK is the string that marks the substitution points in a
|
|
||||||
** template.
|
|
||||||
** LUA_EXEC_DIR in a Windows path is replaced by the executable's
|
|
||||||
** directory.
|
|
||||||
*/
|
|
||||||
#define LUA_PATH_SEP ";"
|
|
||||||
#define LUA_PATH_MARK "?"
|
|
||||||
#define LUA_EXEC_DIR "!"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
|
|
||||||
** Lua libraries.
|
|
||||||
@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
|
|
||||||
** C libraries.
|
|
||||||
** CHANGE them if your machine has a non-conventional directory
|
|
||||||
** hierarchy or if you want to install your libraries in
|
|
||||||
** non-conventional directories.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
|
|
||||||
#if defined(_WIN32) /* { */
|
|
||||||
/*
|
|
||||||
** In Windows, any exclamation mark ('!') in the path is replaced by the
|
|
||||||
** path of the directory of the executable file of the current process.
|
|
||||||
*/
|
|
||||||
#define LUA_LDIR "!\\lua\\"
|
|
||||||
#define LUA_CDIR "!\\"
|
|
||||||
#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\"
|
|
||||||
|
|
||||||
#if !defined(LUA_PATH_DEFAULT)
|
|
||||||
#define LUA_PATH_DEFAULT \
|
|
||||||
LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
|
|
||||||
LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \
|
|
||||||
LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \
|
|
||||||
".\\?.lua;" ".\\?\\init.lua"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(LUA_CPATH_DEFAULT)
|
|
||||||
#define LUA_CPATH_DEFAULT \
|
|
||||||
LUA_CDIR"?.dll;" \
|
|
||||||
LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \
|
|
||||||
LUA_CDIR"loadall.dll;" ".\\?.dll"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
#define LUA_ROOT "/usr/local/"
|
|
||||||
#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/"
|
|
||||||
#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/"
|
|
||||||
|
|
||||||
#if !defined(LUA_PATH_DEFAULT)
|
|
||||||
#define LUA_PATH_DEFAULT \
|
|
||||||
LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
|
|
||||||
LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \
|
|
||||||
"./?.lua;" "./?/init.lua"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(LUA_CPATH_DEFAULT)
|
|
||||||
#define LUA_CPATH_DEFAULT \
|
|
||||||
LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_DIRSEP is the directory separator (for submodules).
|
|
||||||
** CHANGE it if your machine does not use "/" as the directory separator
|
|
||||||
** and is not Windows. (On Windows Lua automatically uses "\".)
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_DIRSEP)
|
|
||||||
|
|
||||||
#if defined(_WIN32)
|
|
||||||
#define LUA_DIRSEP "\\"
|
|
||||||
#else
|
|
||||||
#define LUA_DIRSEP "/"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Marks for exported symbols in the C code
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_API is a mark for all core API functions.
|
|
||||||
@@ LUALIB_API is a mark for all auxiliary library functions.
|
|
||||||
@@ LUAMOD_API is a mark for all standard library opening functions.
|
|
||||||
** CHANGE them if you need to define those functions in some special way.
|
|
||||||
** For instance, if you want to create one Windows DLL with the core and
|
|
||||||
** the libraries, you may want to use the following definition (define
|
|
||||||
** LUA_BUILD_AS_DLL to get it).
|
|
||||||
*/
|
|
||||||
#if defined(LUA_BUILD_AS_DLL) /* { */
|
|
||||||
|
|
||||||
#if defined(LUA_CORE) || defined(LUA_LIB) /* { */
|
|
||||||
#define LUA_API __declspec(dllexport)
|
|
||||||
#else /* }{ */
|
|
||||||
#define LUA_API __declspec(dllimport)
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
#define LUA_API extern
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** More often than not the libs go together with the core.
|
|
||||||
*/
|
|
||||||
#define LUALIB_API LUA_API
|
|
||||||
#define LUAMOD_API LUA_API
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUAI_FUNC is a mark for all extern functions that are not to be
|
|
||||||
** exported to outside modules.
|
|
||||||
@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables,
|
|
||||||
** none of which to be exported to outside modules (LUAI_DDEF for
|
|
||||||
** definitions and LUAI_DDEC for declarations).
|
|
||||||
** CHANGE them if you need to mark them in some special way. Elf/gcc
|
|
||||||
** (versions 3.2 and later) mark them as "hidden" to optimize access
|
|
||||||
** when Lua is compiled as a shared library. Not all elf targets support
|
|
||||||
** this attribute. Unfortunately, gcc does not offer a way to check
|
|
||||||
** whether the target offers that support, and those without support
|
|
||||||
** give a warning about it. To avoid these warnings, change to the
|
|
||||||
** default definition.
|
|
||||||
*/
|
|
||||||
#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
|
|
||||||
defined(__ELF__) /* { */
|
|
||||||
#define LUAI_FUNC __attribute__((visibility("internal"))) extern
|
|
||||||
#else /* }{ */
|
|
||||||
#define LUAI_FUNC extern
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#define LUAI_DDEC(dec) LUAI_FUNC dec
|
|
||||||
#define LUAI_DDEF /* empty */
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Compatibility with previous versions
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3.
|
|
||||||
** You can define it to get all options, or change specific options
|
|
||||||
** to fit your specific needs.
|
|
||||||
*/
|
|
||||||
#if defined(LUA_COMPAT_5_3) /* { */
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
|
|
||||||
** functions in the mathematical library.
|
|
||||||
** (These functions were already officially removed in 5.3;
|
|
||||||
** nevertheless they are still available here.)
|
|
||||||
*/
|
|
||||||
#define LUA_COMPAT_MATHLIB
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
|
|
||||||
** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
|
|
||||||
** luaL_checkint, luaL_checklong, etc.)
|
|
||||||
** (These macros were also officially removed in 5.3, but they are still
|
|
||||||
** available here.)
|
|
||||||
*/
|
|
||||||
#define LUA_COMPAT_APIINTCASTS
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod
|
|
||||||
** using '__lt'.
|
|
||||||
*/
|
|
||||||
#define LUA_COMPAT_LT_LE
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ The following macros supply trivial compatibility for some
|
|
||||||
** changes in the API. The macros themselves document how to
|
|
||||||
** change your code to avoid using them.
|
|
||||||
** (Once more, these macros were officially removed in 5.3, but they are
|
|
||||||
** still available here.)
|
|
||||||
*/
|
|
||||||
#define lua_strlen(L,i) lua_rawlen(L, (i))
|
|
||||||
|
|
||||||
#define lua_objlen(L,i) lua_rawlen(L, (i))
|
|
||||||
|
|
||||||
#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
|
|
||||||
#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Configuration for Numbers (low-level part).
|
|
||||||
** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_*
|
|
||||||
** satisfy your needs.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUAI_UACNUMBER is the result of a 'default argument promotion'
|
|
||||||
@@ over a floating number.
|
|
||||||
@@ l_floatatt(x) corrects float attribute 'x' to the proper float type
|
|
||||||
** by prefixing it with one of FLT/DBL/LDBL.
|
|
||||||
@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats.
|
|
||||||
@@ LUA_NUMBER_FMT is the format for writing floats.
|
|
||||||
@@ lua_number2str converts a float to a string.
|
|
||||||
@@ l_mathop allows the addition of an 'l' or 'f' to all math operations.
|
|
||||||
@@ l_floor takes the floor of a float.
|
|
||||||
@@ lua_str2number converts a decimal numeral to a number.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/* The following definitions are good for most cases here */
|
|
||||||
|
|
||||||
#define l_floor(x) (l_mathop(floor)(x))
|
|
||||||
|
|
||||||
#define lua_number2str(s,sz,n) \
|
|
||||||
l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ lua_numbertointeger converts a float number with an integral value
|
|
||||||
** to an integer, or returns 0 if float is not within the range of
|
|
||||||
** a lua_Integer. (The range comparisons are tricky because of
|
|
||||||
** rounding. The tests here assume a two-complement representation,
|
|
||||||
** where MININTEGER always has an exact representation as a float;
|
|
||||||
** MAXINTEGER may not have one, and therefore its conversion to float
|
|
||||||
** may have an ill-defined value.)
|
|
||||||
*/
|
|
||||||
#define lua_numbertointeger(n,p) \
|
|
||||||
((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
|
|
||||||
(n) < -(LUA_NUMBER)(LUA_MININTEGER) && \
|
|
||||||
(*(p) = (LUA_INTEGER)(n), 1))
|
|
||||||
|
|
||||||
|
|
||||||
/* now the variable definitions */
|
|
||||||
|
|
||||||
#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */
|
|
||||||
|
|
||||||
#define LUA_NUMBER float
|
|
||||||
|
|
||||||
#define l_floatatt(n) (FLT_##n)
|
|
||||||
|
|
||||||
#define LUAI_UACNUMBER double
|
|
||||||
|
|
||||||
#define LUA_NUMBER_FRMLEN ""
|
|
||||||
#define LUA_NUMBER_FMT "%.7g"
|
|
||||||
|
|
||||||
#define l_mathop(op) op##f
|
|
||||||
|
|
||||||
#define lua_str2number(s,p) strtof((s), (p))
|
|
||||||
|
|
||||||
|
|
||||||
#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */
|
|
||||||
|
|
||||||
#define LUA_NUMBER long double
|
|
||||||
|
|
||||||
#define l_floatatt(n) (LDBL_##n)
|
|
||||||
|
|
||||||
#define LUAI_UACNUMBER long double
|
|
||||||
|
|
||||||
#define LUA_NUMBER_FRMLEN "L"
|
|
||||||
#define LUA_NUMBER_FMT "%.19Lg"
|
|
||||||
|
|
||||||
#define l_mathop(op) op##l
|
|
||||||
|
|
||||||
#define lua_str2number(s,p) strtold((s), (p))
|
|
||||||
|
|
||||||
#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */
|
|
||||||
|
|
||||||
#define LUA_NUMBER double
|
|
||||||
|
|
||||||
#define l_floatatt(n) (DBL_##n)
|
|
||||||
|
|
||||||
#define LUAI_UACNUMBER double
|
|
||||||
|
|
||||||
#define LUA_NUMBER_FRMLEN ""
|
|
||||||
#define LUA_NUMBER_FMT "%.14g"
|
|
||||||
|
|
||||||
#define l_mathop(op) op
|
|
||||||
|
|
||||||
#define lua_str2number(s,p) strtod((s), (p))
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
#error "numeric float type not defined"
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER.
|
|
||||||
@@ LUAI_UACINT is the result of a 'default argument promotion'
|
|
||||||
@@ over a LUA_INTEGER.
|
|
||||||
@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers.
|
|
||||||
@@ LUA_INTEGER_FMT is the format for writing integers.
|
|
||||||
@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
|
|
||||||
@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
|
|
||||||
@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
|
|
||||||
@@ lua_integer2str converts an integer to a string.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/* The following definitions are good for most cases here */
|
|
||||||
|
|
||||||
#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d"
|
|
||||||
|
|
||||||
#define LUAI_UACINT LUA_INTEGER
|
|
||||||
|
|
||||||
#define lua_integer2str(s,sz,n) \
|
|
||||||
l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n))
|
|
||||||
|
|
||||||
/*
|
|
||||||
** use LUAI_UACINT here to avoid problems with promotions (which
|
|
||||||
** can turn a comparison between unsigneds into a signed comparison)
|
|
||||||
*/
|
|
||||||
#define LUA_UNSIGNED unsigned LUAI_UACINT
|
|
||||||
|
|
||||||
|
|
||||||
/* now the variable definitions */
|
|
||||||
|
|
||||||
#if LUA_INT_TYPE == LUA_INT_INT /* { int */
|
|
||||||
|
|
||||||
#define LUA_INTEGER int
|
|
||||||
#define LUA_INTEGER_FRMLEN ""
|
|
||||||
|
|
||||||
#define LUA_MAXINTEGER INT_MAX
|
|
||||||
#define LUA_MININTEGER INT_MIN
|
|
||||||
|
|
||||||
#define LUA_MAXUNSIGNED UINT_MAX
|
|
||||||
|
|
||||||
#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */
|
|
||||||
|
|
||||||
#define LUA_INTEGER long
|
|
||||||
#define LUA_INTEGER_FRMLEN "l"
|
|
||||||
|
|
||||||
#define LUA_MAXINTEGER LONG_MAX
|
|
||||||
#define LUA_MININTEGER LONG_MIN
|
|
||||||
|
|
||||||
#define LUA_MAXUNSIGNED ULONG_MAX
|
|
||||||
|
|
||||||
#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */
|
|
||||||
|
|
||||||
/* use presence of macro LLONG_MAX as proxy for C99 compliance */
|
|
||||||
#if defined(LLONG_MAX) /* { */
|
|
||||||
/* use ISO C99 stuff */
|
|
||||||
|
|
||||||
#define LUA_INTEGER long long
|
|
||||||
#define LUA_INTEGER_FRMLEN "ll"
|
|
||||||
|
|
||||||
#define LUA_MAXINTEGER LLONG_MAX
|
|
||||||
#define LUA_MININTEGER LLONG_MIN
|
|
||||||
|
|
||||||
#define LUA_MAXUNSIGNED ULLONG_MAX
|
|
||||||
|
|
||||||
#elif defined(LUA_USE_WINDOWS) /* }{ */
|
|
||||||
/* in Windows, can use specific Windows types */
|
|
||||||
|
|
||||||
#define LUA_INTEGER __int64
|
|
||||||
#define LUA_INTEGER_FRMLEN "I64"
|
|
||||||
|
|
||||||
#define LUA_MAXINTEGER _I64_MAX
|
|
||||||
#define LUA_MININTEGER _I64_MIN
|
|
||||||
|
|
||||||
#define LUA_MAXUNSIGNED _UI64_MAX
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \
|
|
||||||
or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)"
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
#error "numeric integer type not defined"
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Dependencies with C99 and other C details
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89.
|
|
||||||
** (All uses in Lua have only one format item.)
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89)
|
|
||||||
#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i)
|
|
||||||
#else
|
|
||||||
#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ lua_strx2number converts a hexadecimal numeral to a number.
|
|
||||||
** In C99, 'strtod' does that conversion. Otherwise, you can
|
|
||||||
** leave 'lua_strx2number' undefined and Lua will provide its own
|
|
||||||
** implementation.
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89)
|
|
||||||
#define lua_strx2number(s,p) lua_str2number(s,p)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ lua_pointer2str converts a pointer to a readable string in a
|
|
||||||
** non-specified way.
|
|
||||||
*/
|
|
||||||
#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ lua_number2strx converts a float to a hexadecimal numeral.
|
|
||||||
** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
|
|
||||||
** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
|
|
||||||
** provide its own implementation.
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89)
|
|
||||||
#define lua_number2strx(L,b,sz,f,n) \
|
|
||||||
((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n)))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'strtof' and 'opf' variants for math functions are not valid in
|
|
||||||
** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the
|
|
||||||
** availability of these variants. ('math.h' is already included in
|
|
||||||
** all files that use these macros.)
|
|
||||||
*/
|
|
||||||
#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF))
|
|
||||||
#undef l_mathop /* variants not available */
|
|
||||||
#undef lua_str2number
|
|
||||||
#define l_mathop(op) (lua_Number)op /* no variant */
|
|
||||||
#define lua_str2number(s,p) ((lua_Number)strtod((s), (p)))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation
|
|
||||||
** functions. It must be a numerical type; Lua will use 'intptr_t' if
|
|
||||||
** available, otherwise it will use 'ptrdiff_t' (the nearest thing to
|
|
||||||
** 'intptr_t' in C89)
|
|
||||||
*/
|
|
||||||
#define LUA_KCONTEXT ptrdiff_t
|
|
||||||
|
|
||||||
#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
|
|
||||||
__STDC_VERSION__ >= 199901L
|
|
||||||
#include <stdint.h>
|
|
||||||
#if defined(INTPTR_MAX) /* even in C99 this type is optional */
|
|
||||||
#undef LUA_KCONTEXT
|
|
||||||
#define LUA_KCONTEXT intptr_t
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point).
|
|
||||||
** Change that if you do not want to use C locales. (Code using this
|
|
||||||
** macro must include the header 'locale.h'.)
|
|
||||||
*/
|
|
||||||
#if !defined(lua_getlocaledecpoint)
|
|
||||||
#define lua_getlocaledecpoint() (localeconv()->decimal_point[0])
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** macros to improve jump prediction, used mostly for error handling
|
|
||||||
** and debug facilities. (Some macros in the Lua API use these macros.
|
|
||||||
** Define LUA_NOBUILTIN if you do not want '__builtin_expect' in your
|
|
||||||
** code.)
|
|
||||||
*/
|
|
||||||
#if !defined(luai_likely)
|
|
||||||
|
|
||||||
#if defined(__GNUC__) && !defined(LUA_NOBUILTIN)
|
|
||||||
#define luai_likely(x) (__builtin_expect(((x) != 0), 1))
|
|
||||||
#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0))
|
|
||||||
#else
|
|
||||||
#define luai_likely(x) (x)
|
|
||||||
#define luai_unlikely(x) (x)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(LUA_CORE) || defined(LUA_LIB)
|
|
||||||
/* shorter names for Lua's own use */
|
|
||||||
#define l_likely(x) luai_likely(x)
|
|
||||||
#define l_unlikely(x) luai_unlikely(x)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Language Variations
|
|
||||||
** =====================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some
|
|
||||||
** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from
|
|
||||||
** numbers to strings. Define LUA_NOCVTS2N to turn off automatic
|
|
||||||
** coercion from strings to numbers.
|
|
||||||
*/
|
|
||||||
/* #define LUA_NOCVTN2S */
|
|
||||||
/* #define LUA_NOCVTS2N */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_USE_APICHECK turns on several consistency checks on the C API.
|
|
||||||
** Define it as a help when debugging C code.
|
|
||||||
*/
|
|
||||||
#if defined(LUA_USE_APICHECK)
|
|
||||||
#include <assert.h>
|
|
||||||
#define luai_apicheck(l,e) assert(e)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Macros that affect the API and must be stable (that is, must be the
|
|
||||||
** same when you compile Lua and when you compile code that links to
|
|
||||||
** Lua).
|
|
||||||
** =====================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUAI_MAXSTACK limits the size of the Lua stack.
|
|
||||||
** CHANGE it if you need a different limit. This limit is arbitrary;
|
|
||||||
** its only purpose is to stop Lua from consuming unlimited stack
|
|
||||||
** space (and to reserve some numbers for pseudo-indices).
|
|
||||||
** (It must fit into max(size_t)/32 and max(int)/2.)
|
|
||||||
*/
|
|
||||||
#if LUAI_IS32INT
|
|
||||||
#define LUAI_MAXSTACK 1000000
|
|
||||||
#else
|
|
||||||
#define LUAI_MAXSTACK 15000
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_EXTRASPACE defines the size of a raw memory area associated with
|
|
||||||
** a Lua state with very fast access.
|
|
||||||
** CHANGE it if you need a different size.
|
|
||||||
*/
|
|
||||||
#define LUA_EXTRASPACE (sizeof(void *))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUA_IDSIZE gives the maximum size for the description of the source
|
|
||||||
** of a function in debug information.
|
|
||||||
** CHANGE it if you want a different size.
|
|
||||||
*/
|
|
||||||
#define LUA_IDSIZE 60
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUAL_BUFFERSIZE is the initial buffer size used by the lauxlib
|
|
||||||
** buffer system.
|
|
||||||
*/
|
|
||||||
#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number)))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure
|
|
||||||
** maximum alignment for the other items in that union.
|
|
||||||
*/
|
|
||||||
#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* =================================================================== */
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Local configuration. You can use this space to add your redefinitions
|
|
||||||
** without modifying the main part of the file.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,52 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lualib.h $
|
|
||||||
** Lua standard libraries
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef lualib_h
|
|
||||||
#define lualib_h
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
/* version suffix for environment variable names */
|
|
||||||
#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int (luaopen_base) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_COLIBNAME "coroutine"
|
|
||||||
LUAMOD_API int (luaopen_coroutine) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_TABLIBNAME "table"
|
|
||||||
LUAMOD_API int (luaopen_table) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_IOLIBNAME "io"
|
|
||||||
LUAMOD_API int (luaopen_io) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_OSLIBNAME "os"
|
|
||||||
LUAMOD_API int (luaopen_os) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_STRLIBNAME "string"
|
|
||||||
LUAMOD_API int (luaopen_string) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_UTF8LIBNAME "utf8"
|
|
||||||
LUAMOD_API int (luaopen_utf8) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_MATHLIBNAME "math"
|
|
||||||
LUAMOD_API int (luaopen_math) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_DBLIBNAME "debug"
|
|
||||||
LUAMOD_API int (luaopen_debug) (lua_State *L);
|
|
||||||
|
|
||||||
#define LUA_LOADLIBNAME "package"
|
|
||||||
LUAMOD_API int (luaopen_package) (lua_State *L);
|
|
||||||
|
|
||||||
|
|
||||||
/* open all previous libraries */
|
|
||||||
LUALIB_API void (luaL_openlibs) (lua_State *L);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,225 +0,0 @@
|
|||||||
# Makefile for building Lua
|
|
||||||
# See ../doc/readme.html for installation and customization instructions.
|
|
||||||
|
|
||||||
# == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
|
|
||||||
|
|
||||||
# Your platform. See PLATS for possible values.
|
|
||||||
PLAT= guess
|
|
||||||
|
|
||||||
CC= gcc -std=gnu99
|
|
||||||
CFLAGS= -O2 -Wall -Wextra -DLUA_COMPAT_5_3 $(SYSCFLAGS) $(MYCFLAGS)
|
|
||||||
LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
|
|
||||||
LIBS= -lm $(SYSLIBS) $(MYLIBS)
|
|
||||||
|
|
||||||
AR= ar rcu
|
|
||||||
RANLIB= ranlib
|
|
||||||
RM= rm -f
|
|
||||||
UNAME= uname
|
|
||||||
|
|
||||||
SYSCFLAGS=
|
|
||||||
SYSLDFLAGS=
|
|
||||||
SYSLIBS=
|
|
||||||
|
|
||||||
MYCFLAGS=
|
|
||||||
MYLDFLAGS=
|
|
||||||
MYLIBS=
|
|
||||||
MYOBJS=
|
|
||||||
|
|
||||||
# Special flags for compiler modules; -Os reduces code size.
|
|
||||||
CMCFLAGS=
|
|
||||||
|
|
||||||
# == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
|
|
||||||
|
|
||||||
PLATS= guess aix bsd c89 freebsd generic ios linux linux-readline macosx mingw posix solaris
|
|
||||||
|
|
||||||
LUA_A= liblua.a
|
|
||||||
CORE_O= lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o lundump.o lvm.o lzio.o
|
|
||||||
LIB_O= lauxlib.o lbaselib.o lcorolib.o ldblib.o liolib.o lmathlib.o loadlib.o loslib.o lstrlib.o ltablib.o lutf8lib.o linit.o
|
|
||||||
BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
|
|
||||||
|
|
||||||
LUA_T= lua
|
|
||||||
LUA_O= lua.o
|
|
||||||
|
|
||||||
LUAC_T= luac
|
|
||||||
LUAC_O= luac.o
|
|
||||||
|
|
||||||
ALL_O= $(BASE_O) $(LUA_O) $(LUAC_O)
|
|
||||||
ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
|
|
||||||
ALL_A= $(LUA_A)
|
|
||||||
|
|
||||||
# Targets start here.
|
|
||||||
default: $(PLAT)
|
|
||||||
|
|
||||||
all: $(ALL_T)
|
|
||||||
|
|
||||||
o: $(ALL_O)
|
|
||||||
|
|
||||||
a: $(ALL_A)
|
|
||||||
|
|
||||||
$(LUA_A): $(BASE_O)
|
|
||||||
$(AR) $@ $(BASE_O)
|
|
||||||
$(RANLIB) $@
|
|
||||||
|
|
||||||
$(LUA_T): $(LUA_O) $(LUA_A)
|
|
||||||
$(CC) -o $@ $(LDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
|
|
||||||
|
|
||||||
$(LUAC_T): $(LUAC_O) $(LUA_A)
|
|
||||||
$(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
|
|
||||||
|
|
||||||
test:
|
|
||||||
./$(LUA_T) -v
|
|
||||||
|
|
||||||
clean:
|
|
||||||
$(RM) $(ALL_T) $(ALL_O)
|
|
||||||
|
|
||||||
depend:
|
|
||||||
@$(CC) $(CFLAGS) -MM l*.c
|
|
||||||
|
|
||||||
echo:
|
|
||||||
@echo "PLAT= $(PLAT)"
|
|
||||||
@echo "CC= $(CC)"
|
|
||||||
@echo "CFLAGS= $(CFLAGS)"
|
|
||||||
@echo "LDFLAGS= $(LDFLAGS)"
|
|
||||||
@echo "LIBS= $(LIBS)"
|
|
||||||
@echo "AR= $(AR)"
|
|
||||||
@echo "RANLIB= $(RANLIB)"
|
|
||||||
@echo "RM= $(RM)"
|
|
||||||
@echo "UNAME= $(UNAME)"
|
|
||||||
|
|
||||||
# Convenience targets for popular platforms.
|
|
||||||
ALL= all
|
|
||||||
|
|
||||||
help:
|
|
||||||
@echo "Do 'make PLATFORM' where PLATFORM is one of these:"
|
|
||||||
@echo " $(PLATS)"
|
|
||||||
@echo "See doc/readme.html for complete instructions."
|
|
||||||
|
|
||||||
guess:
|
|
||||||
@echo Guessing `$(UNAME)`
|
|
||||||
@$(MAKE) `$(UNAME)`
|
|
||||||
|
|
||||||
AIX aix:
|
|
||||||
$(MAKE) $(ALL) CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl" SYSLDFLAGS="-brtl -bexpall"
|
|
||||||
|
|
||||||
bsd:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-Wl,-E"
|
|
||||||
|
|
||||||
c89:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_C89" CC="gcc -std=c89"
|
|
||||||
@echo ''
|
|
||||||
@echo '*** C89 does not guarantee 64-bit integers for Lua.'
|
|
||||||
@echo '*** Make sure to compile all external Lua libraries'
|
|
||||||
@echo '*** with LUA_USE_C89 to ensure consistency'
|
|
||||||
@echo ''
|
|
||||||
|
|
||||||
FreeBSD NetBSD OpenBSD freebsd:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE -I/usr/include/edit" SYSLIBS="-Wl,-E -ledit" CC="cc"
|
|
||||||
|
|
||||||
generic: $(ALL)
|
|
||||||
|
|
||||||
ios:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_IOS"
|
|
||||||
|
|
||||||
Linux linux: linux-noreadline
|
|
||||||
|
|
||||||
linux-noreadline:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl"
|
|
||||||
|
|
||||||
linux-readline:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX -DLUA_USE_READLINE" SYSLIBS="-Wl,-E -ldl -lreadline"
|
|
||||||
|
|
||||||
Darwin macos macosx:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX -DLUA_USE_READLINE" SYSLIBS="-lreadline"
|
|
||||||
|
|
||||||
mingw:
|
|
||||||
$(MAKE) "LUA_A=lua54.dll" "LUA_T=lua.exe" \
|
|
||||||
"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
|
|
||||||
"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
|
|
||||||
$(MAKE) "LUAC_T=luac.exe" luac.exe
|
|
||||||
|
|
||||||
posix:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
|
|
||||||
|
|
||||||
SunOS solaris:
|
|
||||||
$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN -D_REENTRANT" SYSLIBS="-ldl"
|
|
||||||
|
|
||||||
# Targets that do not create files (not all makes understand .PHONY).
|
|
||||||
.PHONY: all $(PLATS) help test clean default o a depend echo
|
|
||||||
|
|
||||||
# Compiler modules may use special flags.
|
|
||||||
llex.o:
|
|
||||||
$(CC) $(CFLAGS) $(CMCFLAGS) -c llex.c
|
|
||||||
|
|
||||||
lparser.o:
|
|
||||||
$(CC) $(CFLAGS) $(CMCFLAGS) -c lparser.c
|
|
||||||
|
|
||||||
lcode.o:
|
|
||||||
$(CC) $(CFLAGS) $(CMCFLAGS) -c lcode.c
|
|
||||||
|
|
||||||
# DO NOT DELETE
|
|
||||||
|
|
||||||
lapi.o: lapi.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
|
|
||||||
lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lstring.h \
|
|
||||||
ltable.h lundump.h lvm.h
|
|
||||||
lauxlib.o: lauxlib.c lprefix.h lua.h luaconf.h lauxlib.h
|
|
||||||
lbaselib.o: lbaselib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
lcode.o: lcode.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
|
|
||||||
llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
|
|
||||||
ldo.h lgc.h lstring.h ltable.h lvm.h
|
|
||||||
lcorolib.o: lcorolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
lctype.o: lctype.c lprefix.h lctype.h lua.h luaconf.h llimits.h
|
|
||||||
ldblib.o: ldblib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
ldebug.o: ldebug.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
|
|
||||||
lobject.h ltm.h lzio.h lmem.h lcode.h llex.h lopcodes.h lparser.h \
|
|
||||||
ldebug.h ldo.h lfunc.h lstring.h lgc.h ltable.h lvm.h
|
|
||||||
ldo.o: ldo.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
|
|
||||||
lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lopcodes.h \
|
|
||||||
lparser.h lstring.h ltable.h lundump.h lvm.h
|
|
||||||
ldump.o: ldump.c lprefix.h lua.h luaconf.h lobject.h llimits.h lstate.h \
|
|
||||||
ltm.h lzio.h lmem.h lundump.h
|
|
||||||
lfunc.o: lfunc.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
|
|
||||||
llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h
|
|
||||||
lgc.o: lgc.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
|
|
||||||
llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
|
|
||||||
linit.o: linit.c lprefix.h lua.h luaconf.h lualib.h lauxlib.h
|
|
||||||
liolib.o: liolib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
llex.o: llex.c lprefix.h lua.h luaconf.h lctype.h llimits.h ldebug.h \
|
|
||||||
lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lgc.h llex.h lparser.h \
|
|
||||||
lstring.h ltable.h
|
|
||||||
lmathlib.o: lmathlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
lmem.o: lmem.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
|
|
||||||
llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h
|
|
||||||
loadlib.o: loadlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
lobject.o: lobject.c lprefix.h lua.h luaconf.h lctype.h llimits.h \
|
|
||||||
ldebug.h lstate.h lobject.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h \
|
|
||||||
lvm.h
|
|
||||||
lopcodes.o: lopcodes.c lprefix.h lopcodes.h llimits.h lua.h luaconf.h
|
|
||||||
loslib.o: loslib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
lparser.o: lparser.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
|
|
||||||
llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
|
|
||||||
ldo.h lfunc.h lstring.h lgc.h ltable.h
|
|
||||||
lstate.o: lstate.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
|
|
||||||
lobject.h ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h \
|
|
||||||
lstring.h ltable.h
|
|
||||||
lstring.o: lstring.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
|
|
||||||
lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h
|
|
||||||
lstrlib.o: lstrlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
ltable.o: ltable.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
|
|
||||||
llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
|
|
||||||
ltablib.o: ltablib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
ltm.o: ltm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
|
|
||||||
llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
|
|
||||||
lua.o: lua.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
luac.o: luac.c lprefix.h lua.h luaconf.h lauxlib.h ldebug.h lstate.h \
|
|
||||||
lobject.h llimits.h ltm.h lzio.h lmem.h lopcodes.h lopnames.h lundump.h
|
|
||||||
lundump.o: lundump.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
|
|
||||||
lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h \
|
|
||||||
lundump.h
|
|
||||||
lutf8lib.o: lutf8lib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
|
|
||||||
lvm.o: lvm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
|
|
||||||
llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h \
|
|
||||||
ltable.h lvm.h ljumptab.h
|
|
||||||
lzio.o: lzio.c lprefix.h lua.h luaconf.h llimits.h lmem.h lstate.h \
|
|
||||||
lobject.h ltm.h lzio.h
|
|
||||||
|
|
||||||
# (end of Makefile)
|
|
||||||
1463
lua-5.4.5/src/lapi.c
1463
lua-5.4.5/src/lapi.c
File diff suppressed because it is too large
Load Diff
@ -1,52 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lapi.h $
|
|
||||||
** Auxiliary functions from Lua API
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lapi_h
|
|
||||||
#define lapi_h
|
|
||||||
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
|
|
||||||
|
|
||||||
/* Increments 'L->top.p', checking for stack overflows */
|
|
||||||
#define api_incr_top(L) {L->top.p++; \
|
|
||||||
api_check(L, L->top.p <= L->ci->top.p, \
|
|
||||||
"stack overflow");}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** If a call returns too many multiple returns, the callee may not have
|
|
||||||
** stack space to accommodate all results. In this case, this macro
|
|
||||||
** increases its stack space ('L->ci->top.p').
|
|
||||||
*/
|
|
||||||
#define adjustresults(L,nres) \
|
|
||||||
{ if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \
|
|
||||||
L->ci->top.p = L->top.p; }
|
|
||||||
|
|
||||||
|
|
||||||
/* Ensure the stack has at least 'n' elements */
|
|
||||||
#define api_checknelems(L,n) \
|
|
||||||
api_check(L, (n) < (L->top.p - L->ci->func.p), \
|
|
||||||
"not enough elements in the stack")
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** To reduce the overhead of returning from C functions, the presence of
|
|
||||||
** to-be-closed variables in these functions is coded in the CallInfo's
|
|
||||||
** field 'nresults', in a way that functions with no to-be-closed variables
|
|
||||||
** with zero, one, or "all" wanted results have no overhead. Functions
|
|
||||||
** with other number of wanted results, as well as functions with
|
|
||||||
** variables to be closed, have an extra check.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define hastocloseCfunc(n) ((n) < LUA_MULTRET)
|
|
||||||
|
|
||||||
/* Map [-1, inf) (range of 'nresults') into (-inf, -2] */
|
|
||||||
#define codeNresults(n) (-(n) - 3)
|
|
||||||
#define decodeNresults(n) (-(n) - 3)
|
|
||||||
|
|
||||||
#endif
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,549 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lbaselib.c $
|
|
||||||
** Basic library
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lbaselib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <ctype.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_print (lua_State *L) {
|
|
||||||
int n = lua_gettop(L); /* number of arguments */
|
|
||||||
int i;
|
|
||||||
for (i = 1; i <= n; i++) { /* for each argument */
|
|
||||||
size_t l;
|
|
||||||
const char *s = luaL_tolstring(L, i, &l); /* convert it to string */
|
|
||||||
if (i > 1) /* not the first element? */
|
|
||||||
lua_writestring("\t", 1); /* add a tab before it */
|
|
||||||
lua_writestring(s, l); /* print it */
|
|
||||||
lua_pop(L, 1); /* pop result */
|
|
||||||
}
|
|
||||||
lua_writeline();
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Creates a warning with all given arguments.
|
|
||||||
** Check first for errors; otherwise an error may interrupt
|
|
||||||
** the composition of a warning, leaving it unfinished.
|
|
||||||
*/
|
|
||||||
static int luaB_warn (lua_State *L) {
|
|
||||||
int n = lua_gettop(L); /* number of arguments */
|
|
||||||
int i;
|
|
||||||
luaL_checkstring(L, 1); /* at least one argument */
|
|
||||||
for (i = 2; i <= n; i++)
|
|
||||||
luaL_checkstring(L, i); /* make sure all arguments are strings */
|
|
||||||
for (i = 1; i < n; i++) /* compose warning */
|
|
||||||
lua_warning(L, lua_tostring(L, i), 1);
|
|
||||||
lua_warning(L, lua_tostring(L, n), 0); /* close warning */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#define SPACECHARS " \f\n\r\t\v"
|
|
||||||
|
|
||||||
static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
|
|
||||||
lua_Unsigned n = 0;
|
|
||||||
int neg = 0;
|
|
||||||
s += strspn(s, SPACECHARS); /* skip initial spaces */
|
|
||||||
if (*s == '-') { s++; neg = 1; } /* handle sign */
|
|
||||||
else if (*s == '+') s++;
|
|
||||||
if (!isalnum((unsigned char)*s)) /* no digit? */
|
|
||||||
return NULL;
|
|
||||||
do {
|
|
||||||
int digit = (isdigit((unsigned char)*s)) ? *s - '0'
|
|
||||||
: (toupper((unsigned char)*s) - 'A') + 10;
|
|
||||||
if (digit >= base) return NULL; /* invalid numeral */
|
|
||||||
n = n * base + digit;
|
|
||||||
s++;
|
|
||||||
} while (isalnum((unsigned char)*s));
|
|
||||||
s += strspn(s, SPACECHARS); /* skip trailing spaces */
|
|
||||||
*pn = (lua_Integer)((neg) ? (0u - n) : n);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_tonumber (lua_State *L) {
|
|
||||||
if (lua_isnoneornil(L, 2)) { /* standard conversion? */
|
|
||||||
if (lua_type(L, 1) == LUA_TNUMBER) { /* already a number? */
|
|
||||||
lua_settop(L, 1); /* yes; return it */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
size_t l;
|
|
||||||
const char *s = lua_tolstring(L, 1, &l);
|
|
||||||
if (s != NULL && lua_stringtonumber(L, s) == l + 1)
|
|
||||||
return 1; /* successful conversion to number */
|
|
||||||
/* else not a number */
|
|
||||||
luaL_checkany(L, 1); /* (but there must be some parameter) */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
size_t l;
|
|
||||||
const char *s;
|
|
||||||
lua_Integer n = 0; /* to avoid warnings */
|
|
||||||
lua_Integer base = luaL_checkinteger(L, 2);
|
|
||||||
luaL_checktype(L, 1, LUA_TSTRING); /* no numbers as strings */
|
|
||||||
s = lua_tolstring(L, 1, &l);
|
|
||||||
luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");
|
|
||||||
if (b_str2int(s, (int)base, &n) == s + l) {
|
|
||||||
lua_pushinteger(L, n);
|
|
||||||
return 1;
|
|
||||||
} /* else not a number */
|
|
||||||
} /* else not a number */
|
|
||||||
luaL_pushfail(L); /* not a number */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_error (lua_State *L) {
|
|
||||||
int level = (int)luaL_optinteger(L, 2, 1);
|
|
||||||
lua_settop(L, 1);
|
|
||||||
if (lua_type(L, 1) == LUA_TSTRING && level > 0) {
|
|
||||||
luaL_where(L, level); /* add extra information */
|
|
||||||
lua_pushvalue(L, 1);
|
|
||||||
lua_concat(L, 2);
|
|
||||||
}
|
|
||||||
return lua_error(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_getmetatable (lua_State *L) {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
if (!lua_getmetatable(L, 1)) {
|
|
||||||
lua_pushnil(L);
|
|
||||||
return 1; /* no metatable */
|
|
||||||
}
|
|
||||||
luaL_getmetafield(L, 1, "__metatable");
|
|
||||||
return 1; /* returns either __metatable field (if present) or metatable */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_setmetatable (lua_State *L) {
|
|
||||||
int t = lua_type(L, 2);
|
|
||||||
luaL_checktype(L, 1, LUA_TTABLE);
|
|
||||||
luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
|
|
||||||
if (l_unlikely(luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL))
|
|
||||||
return luaL_error(L, "cannot change a protected metatable");
|
|
||||||
lua_settop(L, 2);
|
|
||||||
lua_setmetatable(L, 1);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_rawequal (lua_State *L) {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
luaL_checkany(L, 2);
|
|
||||||
lua_pushboolean(L, lua_rawequal(L, 1, 2));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_rawlen (lua_State *L) {
|
|
||||||
int t = lua_type(L, 1);
|
|
||||||
luaL_argexpected(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,
|
|
||||||
"table or string");
|
|
||||||
lua_pushinteger(L, lua_rawlen(L, 1));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_rawget (lua_State *L) {
|
|
||||||
luaL_checktype(L, 1, LUA_TTABLE);
|
|
||||||
luaL_checkany(L, 2);
|
|
||||||
lua_settop(L, 2);
|
|
||||||
lua_rawget(L, 1);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int luaB_rawset (lua_State *L) {
|
|
||||||
luaL_checktype(L, 1, LUA_TTABLE);
|
|
||||||
luaL_checkany(L, 2);
|
|
||||||
luaL_checkany(L, 3);
|
|
||||||
lua_settop(L, 3);
|
|
||||||
lua_rawset(L, 1);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int pushmode (lua_State *L, int oldmode) {
|
|
||||||
if (oldmode == -1)
|
|
||||||
luaL_pushfail(L); /* invalid call to 'lua_gc' */
|
|
||||||
else
|
|
||||||
lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental"
|
|
||||||
: "generational");
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** check whether call to 'lua_gc' was valid (not inside a finalizer)
|
|
||||||
*/
|
|
||||||
#define checkvalres(res) { if (res == -1) break; }
|
|
||||||
|
|
||||||
static int luaB_collectgarbage (lua_State *L) {
|
|
||||||
static const char *const opts[] = {"stop", "restart", "collect",
|
|
||||||
"count", "step", "setpause", "setstepmul",
|
|
||||||
"isrunning", "generational", "incremental", NULL};
|
|
||||||
static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
|
|
||||||
LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
|
|
||||||
LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
|
|
||||||
int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
|
|
||||||
switch (o) {
|
|
||||||
case LUA_GCCOUNT: {
|
|
||||||
int k = lua_gc(L, o);
|
|
||||||
int b = lua_gc(L, LUA_GCCOUNTB);
|
|
||||||
checkvalres(k);
|
|
||||||
lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
case LUA_GCSTEP: {
|
|
||||||
int step = (int)luaL_optinteger(L, 2, 0);
|
|
||||||
int res = lua_gc(L, o, step);
|
|
||||||
checkvalres(res);
|
|
||||||
lua_pushboolean(L, res);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
case LUA_GCSETPAUSE:
|
|
||||||
case LUA_GCSETSTEPMUL: {
|
|
||||||
int p = (int)luaL_optinteger(L, 2, 0);
|
|
||||||
int previous = lua_gc(L, o, p);
|
|
||||||
checkvalres(previous);
|
|
||||||
lua_pushinteger(L, previous);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
case LUA_GCISRUNNING: {
|
|
||||||
int res = lua_gc(L, o);
|
|
||||||
checkvalres(res);
|
|
||||||
lua_pushboolean(L, res);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
case LUA_GCGEN: {
|
|
||||||
int minormul = (int)luaL_optinteger(L, 2, 0);
|
|
||||||
int majormul = (int)luaL_optinteger(L, 3, 0);
|
|
||||||
return pushmode(L, lua_gc(L, o, minormul, majormul));
|
|
||||||
}
|
|
||||||
case LUA_GCINC: {
|
|
||||||
int pause = (int)luaL_optinteger(L, 2, 0);
|
|
||||||
int stepmul = (int)luaL_optinteger(L, 3, 0);
|
|
||||||
int stepsize = (int)luaL_optinteger(L, 4, 0);
|
|
||||||
return pushmode(L, lua_gc(L, o, pause, stepmul, stepsize));
|
|
||||||
}
|
|
||||||
default: {
|
|
||||||
int res = lua_gc(L, o);
|
|
||||||
checkvalres(res);
|
|
||||||
lua_pushinteger(L, res);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
luaL_pushfail(L); /* invalid call (inside a finalizer) */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_type (lua_State *L) {
|
|
||||||
int t = lua_type(L, 1);
|
|
||||||
luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");
|
|
||||||
lua_pushstring(L, lua_typename(L, t));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_next (lua_State *L) {
|
|
||||||
luaL_checktype(L, 1, LUA_TTABLE);
|
|
||||||
lua_settop(L, 2); /* create a 2nd argument if there isn't one */
|
|
||||||
if (lua_next(L, 1))
|
|
||||||
return 2;
|
|
||||||
else {
|
|
||||||
lua_pushnil(L);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int pairscont (lua_State *L, int status, lua_KContext k) {
|
|
||||||
(void)L; (void)status; (void)k; /* unused */
|
|
||||||
return 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int luaB_pairs (lua_State *L) {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) { /* no metamethod? */
|
|
||||||
lua_pushcfunction(L, luaB_next); /* will return generator, */
|
|
||||||
lua_pushvalue(L, 1); /* state, */
|
|
||||||
lua_pushnil(L); /* and initial value */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_pushvalue(L, 1); /* argument 'self' to metamethod */
|
|
||||||
lua_callk(L, 1, 3, 0, pairscont); /* get 3 values from metamethod */
|
|
||||||
}
|
|
||||||
return 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Traversal function for 'ipairs'
|
|
||||||
*/
|
|
||||||
static int ipairsaux (lua_State *L) {
|
|
||||||
lua_Integer i = luaL_checkinteger(L, 2);
|
|
||||||
i = luaL_intop(+, i, 1);
|
|
||||||
lua_pushinteger(L, i);
|
|
||||||
return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'ipairs' function. Returns 'ipairsaux', given "table", 0.
|
|
||||||
** (The given "table" may not be a table.)
|
|
||||||
*/
|
|
||||||
static int luaB_ipairs (lua_State *L) {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
lua_pushcfunction(L, ipairsaux); /* iteration function */
|
|
||||||
lua_pushvalue(L, 1); /* state */
|
|
||||||
lua_pushinteger(L, 0); /* initial value */
|
|
||||||
return 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int load_aux (lua_State *L, int status, int envidx) {
|
|
||||||
if (l_likely(status == LUA_OK)) {
|
|
||||||
if (envidx != 0) { /* 'env' parameter? */
|
|
||||||
lua_pushvalue(L, envidx); /* environment for loaded function */
|
|
||||||
if (!lua_setupvalue(L, -2, 1)) /* set it as 1st upvalue */
|
|
||||||
lua_pop(L, 1); /* remove 'env' if not used by previous call */
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else { /* error (message is on top of the stack) */
|
|
||||||
luaL_pushfail(L);
|
|
||||||
lua_insert(L, -2); /* put before error message */
|
|
||||||
return 2; /* return fail plus error message */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_loadfile (lua_State *L) {
|
|
||||||
const char *fname = luaL_optstring(L, 1, NULL);
|
|
||||||
const char *mode = luaL_optstring(L, 2, NULL);
|
|
||||||
int env = (!lua_isnone(L, 3) ? 3 : 0); /* 'env' index or 0 if no 'env' */
|
|
||||||
int status = luaL_loadfilex(L, fname, mode);
|
|
||||||
return load_aux(L, status, env);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** Generic Read function
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** reserved slot, above all arguments, to hold a copy of the returned
|
|
||||||
** string to avoid it being collected while parsed. 'load' has four
|
|
||||||
** optional arguments (chunk, source name, mode, and environment).
|
|
||||||
*/
|
|
||||||
#define RESERVEDSLOT 5
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Reader for generic 'load' function: 'lua_load' uses the
|
|
||||||
** stack for internal stuff, so the reader cannot change the
|
|
||||||
** stack top. Instead, it keeps its resulting string in a
|
|
||||||
** reserved slot inside the stack.
|
|
||||||
*/
|
|
||||||
static const char *generic_reader (lua_State *L, void *ud, size_t *size) {
|
|
||||||
(void)(ud); /* not used */
|
|
||||||
luaL_checkstack(L, 2, "too many nested functions");
|
|
||||||
lua_pushvalue(L, 1); /* get function */
|
|
||||||
lua_call(L, 0, 1); /* call it */
|
|
||||||
if (lua_isnil(L, -1)) {
|
|
||||||
lua_pop(L, 1); /* pop result */
|
|
||||||
*size = 0;
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
else if (l_unlikely(!lua_isstring(L, -1)))
|
|
||||||
luaL_error(L, "reader function must return a string");
|
|
||||||
lua_replace(L, RESERVEDSLOT); /* save string in reserved slot */
|
|
||||||
return lua_tolstring(L, RESERVEDSLOT, size);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_load (lua_State *L) {
|
|
||||||
int status;
|
|
||||||
size_t l;
|
|
||||||
const char *s = lua_tolstring(L, 1, &l);
|
|
||||||
const char *mode = luaL_optstring(L, 3, "bt");
|
|
||||||
int env = (!lua_isnone(L, 4) ? 4 : 0); /* 'env' index or 0 if no 'env' */
|
|
||||||
if (s != NULL) { /* loading a string? */
|
|
||||||
const char *chunkname = luaL_optstring(L, 2, s);
|
|
||||||
status = luaL_loadbufferx(L, s, l, chunkname, mode);
|
|
||||||
}
|
|
||||||
else { /* loading from a reader function */
|
|
||||||
const char *chunkname = luaL_optstring(L, 2, "=(load)");
|
|
||||||
luaL_checktype(L, 1, LUA_TFUNCTION);
|
|
||||||
lua_settop(L, RESERVEDSLOT); /* create reserved slot */
|
|
||||||
status = lua_load(L, generic_reader, NULL, chunkname, mode);
|
|
||||||
}
|
|
||||||
return load_aux(L, status, env);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
static int dofilecont (lua_State *L, int d1, lua_KContext d2) {
|
|
||||||
(void)d1; (void)d2; /* only to match 'lua_Kfunction' prototype */
|
|
||||||
return lua_gettop(L) - 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_dofile (lua_State *L) {
|
|
||||||
const char *fname = luaL_optstring(L, 1, NULL);
|
|
||||||
lua_settop(L, 1);
|
|
||||||
if (l_unlikely(luaL_loadfile(L, fname) != LUA_OK))
|
|
||||||
return lua_error(L);
|
|
||||||
lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);
|
|
||||||
return dofilecont(L, 0, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_assert (lua_State *L) {
|
|
||||||
if (l_likely(lua_toboolean(L, 1))) /* condition is true? */
|
|
||||||
return lua_gettop(L); /* return all arguments */
|
|
||||||
else { /* error */
|
|
||||||
luaL_checkany(L, 1); /* there must be a condition */
|
|
||||||
lua_remove(L, 1); /* remove it */
|
|
||||||
lua_pushliteral(L, "assertion failed!"); /* default message */
|
|
||||||
lua_settop(L, 1); /* leave only message (default if no other one) */
|
|
||||||
return luaB_error(L); /* call 'error' */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_select (lua_State *L) {
|
|
||||||
int n = lua_gettop(L);
|
|
||||||
if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {
|
|
||||||
lua_pushinteger(L, n-1);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_Integer i = luaL_checkinteger(L, 1);
|
|
||||||
if (i < 0) i = n + i;
|
|
||||||
else if (i > n) i = n;
|
|
||||||
luaL_argcheck(L, 1 <= i, 1, "index out of range");
|
|
||||||
return n - (int)i;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Continuation function for 'pcall' and 'xpcall'. Both functions
|
|
||||||
** already pushed a 'true' before doing the call, so in case of success
|
|
||||||
** 'finishpcall' only has to return everything in the stack minus
|
|
||||||
** 'extra' values (where 'extra' is exactly the number of items to be
|
|
||||||
** ignored).
|
|
||||||
*/
|
|
||||||
static int finishpcall (lua_State *L, int status, lua_KContext extra) {
|
|
||||||
if (l_unlikely(status != LUA_OK && status != LUA_YIELD)) { /* error? */
|
|
||||||
lua_pushboolean(L, 0); /* first result (false) */
|
|
||||||
lua_pushvalue(L, -2); /* error message */
|
|
||||||
return 2; /* return false, msg */
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return lua_gettop(L) - (int)extra; /* return all results */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_pcall (lua_State *L) {
|
|
||||||
int status;
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
lua_pushboolean(L, 1); /* first result if no errors */
|
|
||||||
lua_insert(L, 1); /* put it in place */
|
|
||||||
status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);
|
|
||||||
return finishpcall(L, status, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Do a protected call with error handling. After 'lua_rotate', the
|
|
||||||
** stack will have <f, err, true, f, [args...]>; so, the function passes
|
|
||||||
** 2 to 'finishpcall' to skip the 2 first values when returning results.
|
|
||||||
*/
|
|
||||||
static int luaB_xpcall (lua_State *L) {
|
|
||||||
int status;
|
|
||||||
int n = lua_gettop(L);
|
|
||||||
luaL_checktype(L, 2, LUA_TFUNCTION); /* check error function */
|
|
||||||
lua_pushboolean(L, 1); /* first result */
|
|
||||||
lua_pushvalue(L, 1); /* function */
|
|
||||||
lua_rotate(L, 3, 2); /* move them below function's arguments */
|
|
||||||
status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);
|
|
||||||
return finishpcall(L, status, 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_tostring (lua_State *L) {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
luaL_tolstring(L, 1, NULL);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg base_funcs[] = {
|
|
||||||
{"assert", luaB_assert},
|
|
||||||
{"collectgarbage", luaB_collectgarbage},
|
|
||||||
{"dofile", luaB_dofile},
|
|
||||||
{"error", luaB_error},
|
|
||||||
{"getmetatable", luaB_getmetatable},
|
|
||||||
{"ipairs", luaB_ipairs},
|
|
||||||
{"loadfile", luaB_loadfile},
|
|
||||||
{"load", luaB_load},
|
|
||||||
{"next", luaB_next},
|
|
||||||
{"pairs", luaB_pairs},
|
|
||||||
{"pcall", luaB_pcall},
|
|
||||||
{"print", luaB_print},
|
|
||||||
{"warn", luaB_warn},
|
|
||||||
{"rawequal", luaB_rawequal},
|
|
||||||
{"rawlen", luaB_rawlen},
|
|
||||||
{"rawget", luaB_rawget},
|
|
||||||
{"rawset", luaB_rawset},
|
|
||||||
{"select", luaB_select},
|
|
||||||
{"setmetatable", luaB_setmetatable},
|
|
||||||
{"tonumber", luaB_tonumber},
|
|
||||||
{"tostring", luaB_tostring},
|
|
||||||
{"type", luaB_type},
|
|
||||||
{"xpcall", luaB_xpcall},
|
|
||||||
/* placeholders */
|
|
||||||
{LUA_GNAME, NULL},
|
|
||||||
{"_VERSION", NULL},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_base (lua_State *L) {
|
|
||||||
/* open lib into global table */
|
|
||||||
lua_pushglobaltable(L);
|
|
||||||
luaL_setfuncs(L, base_funcs, 0);
|
|
||||||
/* set global _G */
|
|
||||||
lua_pushvalue(L, -1);
|
|
||||||
lua_setfield(L, -2, LUA_GNAME);
|
|
||||||
/* set global _VERSION */
|
|
||||||
lua_pushliteral(L, LUA_VERSION);
|
|
||||||
lua_setfield(L, -2, "_VERSION");
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,104 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lcode.h $
|
|
||||||
** Code generator for Lua
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lcode_h
|
|
||||||
#define lcode_h
|
|
||||||
|
|
||||||
#include "llex.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lopcodes.h"
|
|
||||||
#include "lparser.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 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).
|
|
||||||
*/
|
|
||||||
#define NO_JUMP (-1)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** grep "ORDER OPR" if you change these enums (ORDER OP)
|
|
||||||
*/
|
|
||||||
typedef enum BinOpr {
|
|
||||||
/* arithmetic operators */
|
|
||||||
OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,
|
|
||||||
OPR_DIV, OPR_IDIV,
|
|
||||||
/* bitwise operators */
|
|
||||||
OPR_BAND, OPR_BOR, OPR_BXOR,
|
|
||||||
OPR_SHL, OPR_SHR,
|
|
||||||
/* string operator */
|
|
||||||
OPR_CONCAT,
|
|
||||||
/* comparison operators */
|
|
||||||
OPR_EQ, OPR_LT, OPR_LE,
|
|
||||||
OPR_NE, OPR_GT, OPR_GE,
|
|
||||||
/* logical operators */
|
|
||||||
OPR_AND, OPR_OR,
|
|
||||||
OPR_NOBINOPR
|
|
||||||
} BinOpr;
|
|
||||||
|
|
||||||
|
|
||||||
/* true if operation is foldable (that is, it is arithmetic or bitwise) */
|
|
||||||
#define foldbinop(op) ((op) <= OPR_SHR)
|
|
||||||
|
|
||||||
|
|
||||||
#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0)
|
|
||||||
|
|
||||||
|
|
||||||
typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
|
|
||||||
|
|
||||||
|
|
||||||
/* get (pointer to) instruction of given 'expdesc' */
|
|
||||||
#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info])
|
|
||||||
|
|
||||||
|
|
||||||
#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)
|
|
||||||
|
|
||||||
#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t)
|
|
||||||
|
|
||||||
LUAI_FUNC int luaK_code (FuncState *fs, Instruction i);
|
|
||||||
LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
|
|
||||||
LUAI_FUNC int luaK_codeAsBx (FuncState *fs, OpCode o, int A, int Bx);
|
|
||||||
LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A,
|
|
||||||
int B, int C, int k);
|
|
||||||
LUAI_FUNC int luaK_isKint (expdesc *e);
|
|
||||||
LUAI_FUNC int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v);
|
|
||||||
LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
|
|
||||||
LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
|
|
||||||
LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
|
|
||||||
LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
|
|
||||||
LUAI_FUNC void luaK_int (FuncState *fs, int reg, lua_Integer n);
|
|
||||||
LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
|
|
||||||
LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
|
|
||||||
LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
|
|
||||||
LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
|
|
||||||
LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
|
|
||||||
LUAI_FUNC int luaK_jump (FuncState *fs);
|
|
||||||
LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
|
|
||||||
LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
|
|
||||||
LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
|
|
||||||
LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
|
|
||||||
LUAI_FUNC int luaK_getlabel (FuncState *fs);
|
|
||||||
LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
|
|
||||||
LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
|
|
||||||
LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
|
|
||||||
expdesc *v2, int line);
|
|
||||||
LUAI_FUNC void luaK_settablesize (FuncState *fs, int pc,
|
|
||||||
int ra, int asize, int hsize);
|
|
||||||
LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
|
|
||||||
LUAI_FUNC void luaK_finish (FuncState *fs);
|
|
||||||
LUAI_FUNC l_noret luaK_semerror (LexState *ls, const char *msg);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,210 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lcorolib.c $
|
|
||||||
** Coroutine Library
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lcorolib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stdlib.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
static lua_State *getco (lua_State *L) {
|
|
||||||
lua_State *co = lua_tothread(L, 1);
|
|
||||||
luaL_argexpected(L, co, 1, "thread");
|
|
||||||
return co;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Resumes a coroutine. Returns the number of results for non-error
|
|
||||||
** cases or -1 for errors.
|
|
||||||
*/
|
|
||||||
static int auxresume (lua_State *L, lua_State *co, int narg) {
|
|
||||||
int status, nres;
|
|
||||||
if (l_unlikely(!lua_checkstack(co, narg))) {
|
|
||||||
lua_pushliteral(L, "too many arguments to resume");
|
|
||||||
return -1; /* error flag */
|
|
||||||
}
|
|
||||||
lua_xmove(L, co, narg);
|
|
||||||
status = lua_resume(co, L, narg, &nres);
|
|
||||||
if (l_likely(status == LUA_OK || status == LUA_YIELD)) {
|
|
||||||
if (l_unlikely(!lua_checkstack(L, nres + 1))) {
|
|
||||||
lua_pop(co, nres); /* remove results anyway */
|
|
||||||
lua_pushliteral(L, "too many results to resume");
|
|
||||||
return -1; /* error flag */
|
|
||||||
}
|
|
||||||
lua_xmove(co, L, nres); /* move yielded values */
|
|
||||||
return nres;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_xmove(co, L, 1); /* move error message */
|
|
||||||
return -1; /* error flag */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_coresume (lua_State *L) {
|
|
||||||
lua_State *co = getco(L);
|
|
||||||
int r;
|
|
||||||
r = auxresume(L, co, lua_gettop(L) - 1);
|
|
||||||
if (l_unlikely(r < 0)) {
|
|
||||||
lua_pushboolean(L, 0);
|
|
||||||
lua_insert(L, -2);
|
|
||||||
return 2; /* return false + error message */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_pushboolean(L, 1);
|
|
||||||
lua_insert(L, -(r + 1));
|
|
||||||
return r + 1; /* return true + 'resume' returns */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_auxwrap (lua_State *L) {
|
|
||||||
lua_State *co = lua_tothread(L, lua_upvalueindex(1));
|
|
||||||
int r = auxresume(L, co, lua_gettop(L));
|
|
||||||
if (l_unlikely(r < 0)) { /* error? */
|
|
||||||
int stat = lua_status(co);
|
|
||||||
if (stat != LUA_OK && stat != LUA_YIELD) { /* error in the coroutine? */
|
|
||||||
stat = lua_resetthread(co, L); /* close its tbc variables */
|
|
||||||
lua_assert(stat != LUA_OK);
|
|
||||||
lua_xmove(co, L, 1); /* move error message to the caller */
|
|
||||||
}
|
|
||||||
if (stat != LUA_ERRMEM && /* not a memory error and ... */
|
|
||||||
lua_type(L, -1) == LUA_TSTRING) { /* ... error object is a string? */
|
|
||||||
luaL_where(L, 1); /* add extra info, if available */
|
|
||||||
lua_insert(L, -2);
|
|
||||||
lua_concat(L, 2);
|
|
||||||
}
|
|
||||||
return lua_error(L); /* propagate error */
|
|
||||||
}
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_cocreate (lua_State *L) {
|
|
||||||
lua_State *NL;
|
|
||||||
luaL_checktype(L, 1, LUA_TFUNCTION);
|
|
||||||
NL = lua_newthread(L);
|
|
||||||
lua_pushvalue(L, 1); /* move function to top */
|
|
||||||
lua_xmove(L, NL, 1); /* move function from L to NL */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_cowrap (lua_State *L) {
|
|
||||||
luaB_cocreate(L);
|
|
||||||
lua_pushcclosure(L, luaB_auxwrap, 1);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_yield (lua_State *L) {
|
|
||||||
return lua_yield(L, lua_gettop(L));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#define COS_RUN 0
|
|
||||||
#define COS_DEAD 1
|
|
||||||
#define COS_YIELD 2
|
|
||||||
#define COS_NORM 3
|
|
||||||
|
|
||||||
|
|
||||||
static const char *const statname[] =
|
|
||||||
{"running", "dead", "suspended", "normal"};
|
|
||||||
|
|
||||||
|
|
||||||
static int auxstatus (lua_State *L, lua_State *co) {
|
|
||||||
if (L == co) return COS_RUN;
|
|
||||||
else {
|
|
||||||
switch (lua_status(co)) {
|
|
||||||
case LUA_YIELD:
|
|
||||||
return COS_YIELD;
|
|
||||||
case LUA_OK: {
|
|
||||||
lua_Debug ar;
|
|
||||||
if (lua_getstack(co, 0, &ar)) /* does it have frames? */
|
|
||||||
return COS_NORM; /* it is running */
|
|
||||||
else if (lua_gettop(co) == 0)
|
|
||||||
return COS_DEAD;
|
|
||||||
else
|
|
||||||
return COS_YIELD; /* initial state */
|
|
||||||
}
|
|
||||||
default: /* some error occurred */
|
|
||||||
return COS_DEAD;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_costatus (lua_State *L) {
|
|
||||||
lua_State *co = getco(L);
|
|
||||||
lua_pushstring(L, statname[auxstatus(L, co)]);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_yieldable (lua_State *L) {
|
|
||||||
lua_State *co = lua_isnone(L, 1) ? L : getco(L);
|
|
||||||
lua_pushboolean(L, lua_isyieldable(co));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_corunning (lua_State *L) {
|
|
||||||
int ismain = lua_pushthread(L);
|
|
||||||
lua_pushboolean(L, ismain);
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int luaB_close (lua_State *L) {
|
|
||||||
lua_State *co = getco(L);
|
|
||||||
int status = auxstatus(L, co);
|
|
||||||
switch (status) {
|
|
||||||
case COS_DEAD: case COS_YIELD: {
|
|
||||||
status = lua_resetthread(co, L);
|
|
||||||
if (status == LUA_OK) {
|
|
||||||
lua_pushboolean(L, 1);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_pushboolean(L, 0);
|
|
||||||
lua_xmove(co, L, 1); /* move error message */
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
default: /* normal or running coroutine */
|
|
||||||
return luaL_error(L, "cannot close a %s coroutine", statname[status]);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg co_funcs[] = {
|
|
||||||
{"create", luaB_cocreate},
|
|
||||||
{"resume", luaB_coresume},
|
|
||||||
{"running", luaB_corunning},
|
|
||||||
{"status", luaB_costatus},
|
|
||||||
{"wrap", luaB_cowrap},
|
|
||||||
{"yield", luaB_yield},
|
|
||||||
{"isyieldable", luaB_yieldable},
|
|
||||||
{"close", luaB_close},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_coroutine (lua_State *L) {
|
|
||||||
luaL_newlib(L, co_funcs);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,64 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lctype.c $
|
|
||||||
** 'ctype' functions for Lua
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lctype_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include "lctype.h"
|
|
||||||
|
|
||||||
#if !LUA_USE_CTYPE /* { */
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
|
|
||||||
|
|
||||||
#if defined (LUA_UCID) /* accept UniCode IDentifiers? */
|
|
||||||
/* consider all non-ascii codepoints to be alphabetic */
|
|
||||||
#define NONA 0x01
|
|
||||||
#else
|
|
||||||
#define NONA 0x00 /* default */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
|
|
||||||
0x00, /* EOZ */
|
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0. */
|
|
||||||
0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
|
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 1. */
|
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
||||||
0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, /* 2. */
|
|
||||||
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
|
|
||||||
0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, 0x16, /* 3. */
|
|
||||||
0x16, 0x16, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
|
|
||||||
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 4. */
|
|
||||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
|
|
||||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 5. */
|
|
||||||
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x05,
|
|
||||||
0x04, 0x15, 0x15, 0x15, 0x15, 0x15, 0x15, 0x05, /* 6. */
|
|
||||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
|
|
||||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, /* 7. */
|
|
||||||
0x05, 0x05, 0x05, 0x04, 0x04, 0x04, 0x04, 0x00,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* 8. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* 9. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* a. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* b. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
0x00, 0x00, NONA, NONA, NONA, NONA, NONA, NONA, /* c. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* d. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA, /* e. */
|
|
||||||
NONA, NONA, NONA, NONA, NONA, NONA, NONA, NONA,
|
|
||||||
NONA, NONA, NONA, NONA, NONA, 0x00, 0x00, 0x00, /* f. */
|
|
||||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
@ -1,101 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lctype.h $
|
|
||||||
** 'ctype' functions for Lua
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lctype_h
|
|
||||||
#define lctype_h
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** WARNING: the functions defined here do not necessarily correspond
|
|
||||||
** to the similar functions in the standard C ctype.h. They are
|
|
||||||
** optimized for the specific needs of Lua.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if !defined(LUA_USE_CTYPE)
|
|
||||||
|
|
||||||
#if 'A' == 65 && '0' == 48
|
|
||||||
/* ASCII case: can use its own tables; faster and fixed */
|
|
||||||
#define LUA_USE_CTYPE 0
|
|
||||||
#else
|
|
||||||
/* must use standard C ctype */
|
|
||||||
#define LUA_USE_CTYPE 1
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if !LUA_USE_CTYPE /* { */
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
|
|
||||||
|
|
||||||
#define ALPHABIT 0
|
|
||||||
#define DIGITBIT 1
|
|
||||||
#define PRINTBIT 2
|
|
||||||
#define SPACEBIT 3
|
|
||||||
#define XDIGITBIT 4
|
|
||||||
|
|
||||||
|
|
||||||
#define MASK(B) (1 << (B))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** add 1 to char to allow index -1 (EOZ)
|
|
||||||
*/
|
|
||||||
#define testprop(c,p) (luai_ctype_[(c)+1] & (p))
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
|
|
||||||
*/
|
|
||||||
#define lislalpha(c) testprop(c, MASK(ALPHABIT))
|
|
||||||
#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
|
|
||||||
#define lisdigit(c) testprop(c, MASK(DIGITBIT))
|
|
||||||
#define lisspace(c) testprop(c, MASK(SPACEBIT))
|
|
||||||
#define lisprint(c) testprop(c, MASK(PRINTBIT))
|
|
||||||
#define lisxdigit(c) testprop(c, MASK(XDIGITBIT))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** In ASCII, this 'ltolower' is correct for alphabetic characters and
|
|
||||||
** for '.'. That is enough for Lua needs. ('check_exp' ensures that
|
|
||||||
** the character either is an upper-case letter or is unchanged by
|
|
||||||
** the transformation, which holds for lower-case letters and '.'.)
|
|
||||||
*/
|
|
||||||
#define ltolower(c) \
|
|
||||||
check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \
|
|
||||||
(c) | ('A' ^ 'a'))
|
|
||||||
|
|
||||||
|
|
||||||
/* one entry for each character and for -1 (EOZ) */
|
|
||||||
LUAI_DDEC(const lu_byte luai_ctype_[UCHAR_MAX + 2];)
|
|
||||||
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
/*
|
|
||||||
** use standard C ctypes
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <ctype.h>
|
|
||||||
|
|
||||||
|
|
||||||
#define lislalpha(c) (isalpha(c) || (c) == '_')
|
|
||||||
#define lislalnum(c) (isalnum(c) || (c) == '_')
|
|
||||||
#define lisdigit(c) (isdigit(c))
|
|
||||||
#define lisspace(c) (isspace(c))
|
|
||||||
#define lisprint(c) (isprint(c))
|
|
||||||
#define lisxdigit(c) (isxdigit(c))
|
|
||||||
|
|
||||||
#define ltolower(c) (tolower(c))
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,483 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ldblib.c $
|
|
||||||
** Interface from Lua to its debug API
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define ldblib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** The hook table at registry[HOOKKEY] maps threads to their current
|
|
||||||
** hook function.
|
|
||||||
*/
|
|
||||||
static const char *const HOOKKEY = "_HOOKKEY";
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** If L1 != L, L1 can be in any state, and therefore there are no
|
|
||||||
** guarantees about its stack space; any push in L1 must be
|
|
||||||
** checked.
|
|
||||||
*/
|
|
||||||
static void checkstack (lua_State *L, lua_State *L1, int n) {
|
|
||||||
if (l_unlikely(L != L1 && !lua_checkstack(L1, n)))
|
|
||||||
luaL_error(L, "stack overflow");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_getregistry (lua_State *L) {
|
|
||||||
lua_pushvalue(L, LUA_REGISTRYINDEX);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_getmetatable (lua_State *L) {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
if (!lua_getmetatable(L, 1)) {
|
|
||||||
lua_pushnil(L); /* no metatable */
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_setmetatable (lua_State *L) {
|
|
||||||
int t = lua_type(L, 2);
|
|
||||||
luaL_argexpected(L, t == LUA_TNIL || t == LUA_TTABLE, 2, "nil or table");
|
|
||||||
lua_settop(L, 2);
|
|
||||||
lua_setmetatable(L, 1);
|
|
||||||
return 1; /* return 1st argument */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_getuservalue (lua_State *L) {
|
|
||||||
int n = (int)luaL_optinteger(L, 2, 1);
|
|
||||||
if (lua_type(L, 1) != LUA_TUSERDATA)
|
|
||||||
luaL_pushfail(L);
|
|
||||||
else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) {
|
|
||||||
lua_pushboolean(L, 1);
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_setuservalue (lua_State *L) {
|
|
||||||
int n = (int)luaL_optinteger(L, 3, 1);
|
|
||||||
luaL_checktype(L, 1, LUA_TUSERDATA);
|
|
||||||
luaL_checkany(L, 2);
|
|
||||||
lua_settop(L, 2);
|
|
||||||
if (!lua_setiuservalue(L, 1, n))
|
|
||||||
luaL_pushfail(L);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Auxiliary function used by several library functions: check for
|
|
||||||
** an optional thread as function's first argument and set 'arg' with
|
|
||||||
** 1 if this argument is present (so that functions can skip it to
|
|
||||||
** access their other arguments)
|
|
||||||
*/
|
|
||||||
static lua_State *getthread (lua_State *L, int *arg) {
|
|
||||||
if (lua_isthread(L, 1)) {
|
|
||||||
*arg = 1;
|
|
||||||
return lua_tothread(L, 1);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
*arg = 0;
|
|
||||||
return L; /* function will operate over current thread */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Variations of 'lua_settable', used by 'db_getinfo' to put results
|
|
||||||
** from 'lua_getinfo' into result table. Key is always a string;
|
|
||||||
** value can be a string, an int, or a boolean.
|
|
||||||
*/
|
|
||||||
static void settabss (lua_State *L, const char *k, const char *v) {
|
|
||||||
lua_pushstring(L, v);
|
|
||||||
lua_setfield(L, -2, k);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void settabsi (lua_State *L, const char *k, int v) {
|
|
||||||
lua_pushinteger(L, v);
|
|
||||||
lua_setfield(L, -2, k);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void settabsb (lua_State *L, const char *k, int v) {
|
|
||||||
lua_pushboolean(L, v);
|
|
||||||
lua_setfield(L, -2, k);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** In function 'db_getinfo', the call to 'lua_getinfo' may push
|
|
||||||
** results on the stack; later it creates the result table to put
|
|
||||||
** these objects. Function 'treatstackoption' puts the result from
|
|
||||||
** 'lua_getinfo' on top of the result table so that it can call
|
|
||||||
** 'lua_setfield'.
|
|
||||||
*/
|
|
||||||
static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
|
|
||||||
if (L == L1)
|
|
||||||
lua_rotate(L, -2, 1); /* exchange object and table */
|
|
||||||
else
|
|
||||||
lua_xmove(L1, L, 1); /* move object to the "main" stack */
|
|
||||||
lua_setfield(L, -2, fname); /* put object into table */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Calls 'lua_getinfo' and collects all results in a new table.
|
|
||||||
** L1 needs stack space for an optional input (function) plus
|
|
||||||
** two optional outputs (function and line table) from function
|
|
||||||
** 'lua_getinfo'.
|
|
||||||
*/
|
|
||||||
static int db_getinfo (lua_State *L) {
|
|
||||||
lua_Debug ar;
|
|
||||||
int arg;
|
|
||||||
lua_State *L1 = getthread(L, &arg);
|
|
||||||
const char *options = luaL_optstring(L, arg+2, "flnSrtu");
|
|
||||||
checkstack(L, L1, 3);
|
|
||||||
luaL_argcheck(L, options[0] != '>', arg + 2, "invalid option '>'");
|
|
||||||
if (lua_isfunction(L, arg + 1)) { /* info about a function? */
|
|
||||||
options = lua_pushfstring(L, ">%s", options); /* add '>' to 'options' */
|
|
||||||
lua_pushvalue(L, arg + 1); /* move function to 'L1' stack */
|
|
||||||
lua_xmove(L, L1, 1);
|
|
||||||
}
|
|
||||||
else { /* stack level */
|
|
||||||
if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {
|
|
||||||
luaL_pushfail(L); /* level out of range */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (!lua_getinfo(L1, options, &ar))
|
|
||||||
return luaL_argerror(L, arg+2, "invalid option");
|
|
||||||
lua_newtable(L); /* table to collect results */
|
|
||||||
if (strchr(options, 'S')) {
|
|
||||||
lua_pushlstring(L, ar.source, ar.srclen);
|
|
||||||
lua_setfield(L, -2, "source");
|
|
||||||
settabss(L, "short_src", ar.short_src);
|
|
||||||
settabsi(L, "linedefined", ar.linedefined);
|
|
||||||
settabsi(L, "lastlinedefined", ar.lastlinedefined);
|
|
||||||
settabss(L, "what", ar.what);
|
|
||||||
}
|
|
||||||
if (strchr(options, 'l'))
|
|
||||||
settabsi(L, "currentline", ar.currentline);
|
|
||||||
if (strchr(options, 'u')) {
|
|
||||||
settabsi(L, "nups", ar.nups);
|
|
||||||
settabsi(L, "nparams", ar.nparams);
|
|
||||||
settabsb(L, "isvararg", ar.isvararg);
|
|
||||||
}
|
|
||||||
if (strchr(options, 'n')) {
|
|
||||||
settabss(L, "name", ar.name);
|
|
||||||
settabss(L, "namewhat", ar.namewhat);
|
|
||||||
}
|
|
||||||
if (strchr(options, 'r')) {
|
|
||||||
settabsi(L, "ftransfer", ar.ftransfer);
|
|
||||||
settabsi(L, "ntransfer", ar.ntransfer);
|
|
||||||
}
|
|
||||||
if (strchr(options, 't'))
|
|
||||||
settabsb(L, "istailcall", ar.istailcall);
|
|
||||||
if (strchr(options, 'L'))
|
|
||||||
treatstackoption(L, L1, "activelines");
|
|
||||||
if (strchr(options, 'f'))
|
|
||||||
treatstackoption(L, L1, "func");
|
|
||||||
return 1; /* return table */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_getlocal (lua_State *L) {
|
|
||||||
int arg;
|
|
||||||
lua_State *L1 = getthread(L, &arg);
|
|
||||||
int nvar = (int)luaL_checkinteger(L, arg + 2); /* local-variable index */
|
|
||||||
if (lua_isfunction(L, arg + 1)) { /* function argument? */
|
|
||||||
lua_pushvalue(L, arg + 1); /* push function */
|
|
||||||
lua_pushstring(L, lua_getlocal(L, NULL, nvar)); /* push local name */
|
|
||||||
return 1; /* return only name (there is no value) */
|
|
||||||
}
|
|
||||||
else { /* stack-level argument */
|
|
||||||
lua_Debug ar;
|
|
||||||
const char *name;
|
|
||||||
int level = (int)luaL_checkinteger(L, arg + 1);
|
|
||||||
if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */
|
|
||||||
return luaL_argerror(L, arg+1, "level out of range");
|
|
||||||
checkstack(L, L1, 1);
|
|
||||||
name = lua_getlocal(L1, &ar, nvar);
|
|
||||||
if (name) {
|
|
||||||
lua_xmove(L1, L, 1); /* move local value */
|
|
||||||
lua_pushstring(L, name); /* push name */
|
|
||||||
lua_rotate(L, -2, 1); /* re-order */
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
luaL_pushfail(L); /* no name (nor value) */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_setlocal (lua_State *L) {
|
|
||||||
int arg;
|
|
||||||
const char *name;
|
|
||||||
lua_State *L1 = getthread(L, &arg);
|
|
||||||
lua_Debug ar;
|
|
||||||
int level = (int)luaL_checkinteger(L, arg + 1);
|
|
||||||
int nvar = (int)luaL_checkinteger(L, arg + 2);
|
|
||||||
if (l_unlikely(!lua_getstack(L1, level, &ar))) /* out of range? */
|
|
||||||
return luaL_argerror(L, arg+1, "level out of range");
|
|
||||||
luaL_checkany(L, arg+3);
|
|
||||||
lua_settop(L, arg+3);
|
|
||||||
checkstack(L, L1, 1);
|
|
||||||
lua_xmove(L, L1, 1);
|
|
||||||
name = lua_setlocal(L1, &ar, nvar);
|
|
||||||
if (name == NULL)
|
|
||||||
lua_pop(L1, 1); /* pop value (if not popped by 'lua_setlocal') */
|
|
||||||
lua_pushstring(L, name);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** get (if 'get' is true) or set an upvalue from a closure
|
|
||||||
*/
|
|
||||||
static int auxupvalue (lua_State *L, int get) {
|
|
||||||
const char *name;
|
|
||||||
int n = (int)luaL_checkinteger(L, 2); /* upvalue index */
|
|
||||||
luaL_checktype(L, 1, LUA_TFUNCTION); /* closure */
|
|
||||||
name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
|
|
||||||
if (name == NULL) return 0;
|
|
||||||
lua_pushstring(L, name);
|
|
||||||
lua_insert(L, -(get+1)); /* no-op if get is false */
|
|
||||||
return get + 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_getupvalue (lua_State *L) {
|
|
||||||
return auxupvalue(L, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_setupvalue (lua_State *L) {
|
|
||||||
luaL_checkany(L, 3);
|
|
||||||
return auxupvalue(L, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether a given upvalue from a given closure exists and
|
|
||||||
** returns its index
|
|
||||||
*/
|
|
||||||
static void *checkupval (lua_State *L, int argf, int argnup, int *pnup) {
|
|
||||||
void *id;
|
|
||||||
int nup = (int)luaL_checkinteger(L, argnup); /* upvalue index */
|
|
||||||
luaL_checktype(L, argf, LUA_TFUNCTION); /* closure */
|
|
||||||
id = lua_upvalueid(L, argf, nup);
|
|
||||||
if (pnup) {
|
|
||||||
luaL_argcheck(L, id != NULL, argnup, "invalid upvalue index");
|
|
||||||
*pnup = nup;
|
|
||||||
}
|
|
||||||
return id;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_upvalueid (lua_State *L) {
|
|
||||||
void *id = checkupval(L, 1, 2, NULL);
|
|
||||||
if (id != NULL)
|
|
||||||
lua_pushlightuserdata(L, id);
|
|
||||||
else
|
|
||||||
luaL_pushfail(L);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_upvaluejoin (lua_State *L) {
|
|
||||||
int n1, n2;
|
|
||||||
checkupval(L, 1, 2, &n1);
|
|
||||||
checkupval(L, 3, 4, &n2);
|
|
||||||
luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");
|
|
||||||
luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");
|
|
||||||
lua_upvaluejoin(L, 1, n1, 3, n2);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Call hook function registered at hook table for the current
|
|
||||||
** thread (if there is one)
|
|
||||||
*/
|
|
||||||
static void hookf (lua_State *L, lua_Debug *ar) {
|
|
||||||
static const char *const hooknames[] =
|
|
||||||
{"call", "return", "line", "count", "tail call"};
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
|
|
||||||
lua_pushthread(L);
|
|
||||||
if (lua_rawget(L, -2) == LUA_TFUNCTION) { /* is there a hook function? */
|
|
||||||
lua_pushstring(L, hooknames[(int)ar->event]); /* push event name */
|
|
||||||
if (ar->currentline >= 0)
|
|
||||||
lua_pushinteger(L, ar->currentline); /* push current line */
|
|
||||||
else lua_pushnil(L);
|
|
||||||
lua_assert(lua_getinfo(L, "lS", ar));
|
|
||||||
lua_call(L, 2, 0); /* call hook function */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert a string mask (for 'sethook') into a bit mask
|
|
||||||
*/
|
|
||||||
static int makemask (const char *smask, int count) {
|
|
||||||
int mask = 0;
|
|
||||||
if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
|
|
||||||
if (strchr(smask, 'r')) mask |= LUA_MASKRET;
|
|
||||||
if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
|
|
||||||
if (count > 0) mask |= LUA_MASKCOUNT;
|
|
||||||
return mask;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert a bit mask (for 'gethook') into a string mask
|
|
||||||
*/
|
|
||||||
static char *unmakemask (int mask, char *smask) {
|
|
||||||
int i = 0;
|
|
||||||
if (mask & LUA_MASKCALL) smask[i++] = 'c';
|
|
||||||
if (mask & LUA_MASKRET) smask[i++] = 'r';
|
|
||||||
if (mask & LUA_MASKLINE) smask[i++] = 'l';
|
|
||||||
smask[i] = '\0';
|
|
||||||
return smask;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_sethook (lua_State *L) {
|
|
||||||
int arg, mask, count;
|
|
||||||
lua_Hook func;
|
|
||||||
lua_State *L1 = getthread(L, &arg);
|
|
||||||
if (lua_isnoneornil(L, arg+1)) { /* no hook? */
|
|
||||||
lua_settop(L, arg+1);
|
|
||||||
func = NULL; mask = 0; count = 0; /* turn off hooks */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
const char *smask = luaL_checkstring(L, arg+2);
|
|
||||||
luaL_checktype(L, arg+1, LUA_TFUNCTION);
|
|
||||||
count = (int)luaL_optinteger(L, arg + 3, 0);
|
|
||||||
func = hookf; mask = makemask(smask, count);
|
|
||||||
}
|
|
||||||
if (!luaL_getsubtable(L, LUA_REGISTRYINDEX, HOOKKEY)) {
|
|
||||||
/* table just created; initialize it */
|
|
||||||
lua_pushliteral(L, "k");
|
|
||||||
lua_setfield(L, -2, "__mode"); /** hooktable.__mode = "k" */
|
|
||||||
lua_pushvalue(L, -1);
|
|
||||||
lua_setmetatable(L, -2); /* metatable(hooktable) = hooktable */
|
|
||||||
}
|
|
||||||
checkstack(L, L1, 1);
|
|
||||||
lua_pushthread(L1); lua_xmove(L1, L, 1); /* key (thread) */
|
|
||||||
lua_pushvalue(L, arg + 1); /* value (hook function) */
|
|
||||||
lua_rawset(L, -3); /* hooktable[L1] = new Lua hook */
|
|
||||||
lua_sethook(L1, func, mask, count);
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_gethook (lua_State *L) {
|
|
||||||
int arg;
|
|
||||||
lua_State *L1 = getthread(L, &arg);
|
|
||||||
char buff[5];
|
|
||||||
int mask = lua_gethookmask(L1);
|
|
||||||
lua_Hook hook = lua_gethook(L1);
|
|
||||||
if (hook == NULL) { /* no hook? */
|
|
||||||
luaL_pushfail(L);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else if (hook != hookf) /* external hook? */
|
|
||||||
lua_pushliteral(L, "external hook");
|
|
||||||
else { /* hook table must exist */
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, HOOKKEY);
|
|
||||||
checkstack(L, L1, 1);
|
|
||||||
lua_pushthread(L1); lua_xmove(L1, L, 1);
|
|
||||||
lua_rawget(L, -2); /* 1st result = hooktable[L1] */
|
|
||||||
lua_remove(L, -2); /* remove hook table */
|
|
||||||
}
|
|
||||||
lua_pushstring(L, unmakemask(mask, buff)); /* 2nd result = mask */
|
|
||||||
lua_pushinteger(L, lua_gethookcount(L1)); /* 3rd result = count */
|
|
||||||
return 3;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_debug (lua_State *L) {
|
|
||||||
for (;;) {
|
|
||||||
char buffer[250];
|
|
||||||
lua_writestringerror("%s", "lua_debug> ");
|
|
||||||
if (fgets(buffer, sizeof(buffer), stdin) == NULL ||
|
|
||||||
strcmp(buffer, "cont\n") == 0)
|
|
||||||
return 0;
|
|
||||||
if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
|
|
||||||
lua_pcall(L, 0, 0, 0))
|
|
||||||
lua_writestringerror("%s\n", luaL_tolstring(L, -1, NULL));
|
|
||||||
lua_settop(L, 0); /* remove eventual returns */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_traceback (lua_State *L) {
|
|
||||||
int arg;
|
|
||||||
lua_State *L1 = getthread(L, &arg);
|
|
||||||
const char *msg = lua_tostring(L, arg + 1);
|
|
||||||
if (msg == NULL && !lua_isnoneornil(L, arg + 1)) /* non-string 'msg'? */
|
|
||||||
lua_pushvalue(L, arg + 1); /* return it untouched */
|
|
||||||
else {
|
|
||||||
int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);
|
|
||||||
luaL_traceback(L, L1, msg, level);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int db_setcstacklimit (lua_State *L) {
|
|
||||||
int limit = (int)luaL_checkinteger(L, 1);
|
|
||||||
int res = lua_setcstacklimit(L, limit);
|
|
||||||
lua_pushinteger(L, res);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg dblib[] = {
|
|
||||||
{"debug", db_debug},
|
|
||||||
{"getuservalue", db_getuservalue},
|
|
||||||
{"gethook", db_gethook},
|
|
||||||
{"getinfo", db_getinfo},
|
|
||||||
{"getlocal", db_getlocal},
|
|
||||||
{"getregistry", db_getregistry},
|
|
||||||
{"getmetatable", db_getmetatable},
|
|
||||||
{"getupvalue", db_getupvalue},
|
|
||||||
{"upvaluejoin", db_upvaluejoin},
|
|
||||||
{"upvalueid", db_upvalueid},
|
|
||||||
{"setuservalue", db_setuservalue},
|
|
||||||
{"sethook", db_sethook},
|
|
||||||
{"setlocal", db_setlocal},
|
|
||||||
{"setmetatable", db_setmetatable},
|
|
||||||
{"setupvalue", db_setupvalue},
|
|
||||||
{"traceback", db_traceback},
|
|
||||||
{"setcstacklimit", db_setcstacklimit},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_debug (lua_State *L) {
|
|
||||||
luaL_newlib(L, dblib);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,924 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ldebug.c $
|
|
||||||
** Debug Interface
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define ldebug_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stdarg.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lapi.h"
|
|
||||||
#include "lcode.h"
|
|
||||||
#include "ldebug.h"
|
|
||||||
#include "ldo.h"
|
|
||||||
#include "lfunc.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lopcodes.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
#include "lstring.h"
|
|
||||||
#include "ltable.h"
|
|
||||||
#include "ltm.h"
|
|
||||||
#include "lvm.h"
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL)
|
|
||||||
|
|
||||||
|
|
||||||
static const char *funcnamefromcall (lua_State *L, CallInfo *ci,
|
|
||||||
const char **name);
|
|
||||||
|
|
||||||
|
|
||||||
static int currentpc (CallInfo *ci) {
|
|
||||||
lua_assert(isLua(ci));
|
|
||||||
return pcRel(ci->u.l.savedpc, ci_func(ci)->p);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Get a "base line" to find the line corresponding to an instruction.
|
|
||||||
** Base lines are regularly placed at MAXIWTHABS intervals, so usually
|
|
||||||
** an integer division gets the right place. When the source file has
|
|
||||||
** large sequences of empty/comment lines, it may need extra entries,
|
|
||||||
** so the original estimate needs a correction.
|
|
||||||
** If the original estimate is -1, the initial 'if' ensures that the
|
|
||||||
** 'while' will run at least once.
|
|
||||||
** The assertion that the estimate is a lower bound for the correct base
|
|
||||||
** is valid as long as the debug info has been generated with the same
|
|
||||||
** value for MAXIWTHABS or smaller. (Previous releases use a little
|
|
||||||
** smaller value.)
|
|
||||||
*/
|
|
||||||
static int getbaseline (const Proto *f, int pc, int *basepc) {
|
|
||||||
if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) {
|
|
||||||
*basepc = -1; /* start from the beginning */
|
|
||||||
return f->linedefined;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */
|
|
||||||
/* estimate must be a lower bound of the correct base */
|
|
||||||
lua_assert(i < 0 ||
|
|
||||||
(i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc));
|
|
||||||
while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc)
|
|
||||||
i++; /* low estimate; adjust it */
|
|
||||||
*basepc = f->abslineinfo[i].pc;
|
|
||||||
return f->abslineinfo[i].line;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Get the line corresponding to instruction 'pc' in function 'f';
|
|
||||||
** first gets a base line and from there does the increments until
|
|
||||||
** the desired instruction.
|
|
||||||
*/
|
|
||||||
int luaG_getfuncline (const Proto *f, int pc) {
|
|
||||||
if (f->lineinfo == NULL) /* no debug information? */
|
|
||||||
return -1;
|
|
||||||
else {
|
|
||||||
int basepc;
|
|
||||||
int baseline = getbaseline(f, pc, &basepc);
|
|
||||||
while (basepc++ < pc) { /* walk until given instruction */
|
|
||||||
lua_assert(f->lineinfo[basepc] != ABSLINEINFO);
|
|
||||||
baseline += f->lineinfo[basepc]; /* correct line */
|
|
||||||
}
|
|
||||||
return baseline;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int getcurrentline (CallInfo *ci) {
|
|
||||||
return luaG_getfuncline(ci_func(ci)->p, currentpc(ci));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Set 'trap' for all active Lua frames.
|
|
||||||
** This function can be called during a signal, under "reasonable"
|
|
||||||
** assumptions. A new 'ci' is completely linked in the list before it
|
|
||||||
** becomes part of the "active" list, and we assume that pointers are
|
|
||||||
** atomic; see comment in next function.
|
|
||||||
** (A compiler doing interprocedural optimizations could, theoretically,
|
|
||||||
** reorder memory writes in such a way that the list could be
|
|
||||||
** temporarily broken while inserting a new element. We simply assume it
|
|
||||||
** has no good reasons to do that.)
|
|
||||||
*/
|
|
||||||
static void settraps (CallInfo *ci) {
|
|
||||||
for (; ci != NULL; ci = ci->previous)
|
|
||||||
if (isLua(ci))
|
|
||||||
ci->u.l.trap = 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** This function can be called during a signal, under "reasonable"
|
|
||||||
** assumptions.
|
|
||||||
** Fields 'basehookcount' and 'hookcount' (set by 'resethookcount')
|
|
||||||
** are for debug only, and it is no problem if they get arbitrary
|
|
||||||
** values (causes at most one wrong hook call). 'hookmask' is an atomic
|
|
||||||
** value. We assume that pointers are atomic too (e.g., gcc ensures that
|
|
||||||
** for all platforms where it runs). Moreover, 'hook' is always checked
|
|
||||||
** before being called (see 'luaD_hook').
|
|
||||||
*/
|
|
||||||
LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
|
|
||||||
if (func == NULL || mask == 0) { /* turn off hooks? */
|
|
||||||
mask = 0;
|
|
||||||
func = NULL;
|
|
||||||
}
|
|
||||||
L->hook = func;
|
|
||||||
L->basehookcount = count;
|
|
||||||
resethookcount(L);
|
|
||||||
L->hookmask = cast_byte(mask);
|
|
||||||
if (mask)
|
|
||||||
settraps(L->ci); /* to trace inside 'luaV_execute' */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API lua_Hook lua_gethook (lua_State *L) {
|
|
||||||
return L->hook;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int lua_gethookmask (lua_State *L) {
|
|
||||||
return L->hookmask;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int lua_gethookcount (lua_State *L) {
|
|
||||||
return L->basehookcount;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
|
|
||||||
int status;
|
|
||||||
CallInfo *ci;
|
|
||||||
if (level < 0) return 0; /* invalid (negative) level */
|
|
||||||
lua_lock(L);
|
|
||||||
for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)
|
|
||||||
level--;
|
|
||||||
if (level == 0 && ci != &L->base_ci) { /* level found? */
|
|
||||||
status = 1;
|
|
||||||
ar->i_ci = ci;
|
|
||||||
}
|
|
||||||
else status = 0; /* no such level */
|
|
||||||
lua_unlock(L);
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *upvalname (const Proto *p, int uv) {
|
|
||||||
TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
|
|
||||||
if (s == NULL) return "?";
|
|
||||||
else return getstr(s);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
|
|
||||||
if (clLvalue(s2v(ci->func.p))->p->is_vararg) {
|
|
||||||
int nextra = ci->u.l.nextraargs;
|
|
||||||
if (n >= -nextra) { /* 'n' is negative */
|
|
||||||
*pos = ci->func.p - nextra - (n + 1);
|
|
||||||
return "(vararg)"; /* generic name for any vararg */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return NULL; /* no such vararg */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, StkId *pos) {
|
|
||||||
StkId base = ci->func.p + 1;
|
|
||||||
const char *name = NULL;
|
|
||||||
if (isLua(ci)) {
|
|
||||||
if (n < 0) /* access to vararg values? */
|
|
||||||
return findvararg(ci, n, pos);
|
|
||||||
else
|
|
||||||
name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
|
|
||||||
}
|
|
||||||
if (name == NULL) { /* no 'standard' name? */
|
|
||||||
StkId limit = (ci == L->ci) ? L->top.p : ci->next->func.p;
|
|
||||||
if (limit - base >= n && n > 0) { /* is 'n' inside 'ci' stack? */
|
|
||||||
/* generic name for any valid slot */
|
|
||||||
name = isLua(ci) ? "(temporary)" : "(C temporary)";
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return NULL; /* no name */
|
|
||||||
}
|
|
||||||
if (pos)
|
|
||||||
*pos = base + (n - 1);
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
|
|
||||||
const char *name;
|
|
||||||
lua_lock(L);
|
|
||||||
if (ar == NULL) { /* information about non-active function? */
|
|
||||||
if (!isLfunction(s2v(L->top.p - 1))) /* not a Lua function? */
|
|
||||||
name = NULL;
|
|
||||||
else /* consider live variables at function start (parameters) */
|
|
||||||
name = luaF_getlocalname(clLvalue(s2v(L->top.p - 1))->p, n, 0);
|
|
||||||
}
|
|
||||||
else { /* active function; get information through 'ar' */
|
|
||||||
StkId pos = NULL; /* to avoid warnings */
|
|
||||||
name = luaG_findlocal(L, ar->i_ci, n, &pos);
|
|
||||||
if (name) {
|
|
||||||
setobjs2s(L, L->top.p, pos);
|
|
||||||
api_incr_top(L);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
lua_unlock(L);
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
|
|
||||||
StkId pos = NULL; /* to avoid warnings */
|
|
||||||
const char *name;
|
|
||||||
lua_lock(L);
|
|
||||||
name = luaG_findlocal(L, ar->i_ci, n, &pos);
|
|
||||||
if (name) {
|
|
||||||
setobjs2s(L, pos, L->top.p - 1);
|
|
||||||
L->top.p--; /* pop value */
|
|
||||||
}
|
|
||||||
lua_unlock(L);
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void funcinfo (lua_Debug *ar, Closure *cl) {
|
|
||||||
if (noLuaClosure(cl)) {
|
|
||||||
ar->source = "=[C]";
|
|
||||||
ar->srclen = LL("=[C]");
|
|
||||||
ar->linedefined = -1;
|
|
||||||
ar->lastlinedefined = -1;
|
|
||||||
ar->what = "C";
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
const Proto *p = cl->l.p;
|
|
||||||
if (p->source) {
|
|
||||||
ar->source = getstr(p->source);
|
|
||||||
ar->srclen = tsslen(p->source);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
ar->source = "=?";
|
|
||||||
ar->srclen = LL("=?");
|
|
||||||
}
|
|
||||||
ar->linedefined = p->linedefined;
|
|
||||||
ar->lastlinedefined = p->lastlinedefined;
|
|
||||||
ar->what = (ar->linedefined == 0) ? "main" : "Lua";
|
|
||||||
}
|
|
||||||
luaO_chunkid(ar->short_src, ar->source, ar->srclen);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int nextline (const Proto *p, int currentline, int pc) {
|
|
||||||
if (p->lineinfo[pc] != ABSLINEINFO)
|
|
||||||
return currentline + p->lineinfo[pc];
|
|
||||||
else
|
|
||||||
return luaG_getfuncline(p, pc);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void collectvalidlines (lua_State *L, Closure *f) {
|
|
||||||
if (noLuaClosure(f)) {
|
|
||||||
setnilvalue(s2v(L->top.p));
|
|
||||||
api_incr_top(L);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
int i;
|
|
||||||
TValue v;
|
|
||||||
const Proto *p = f->l.p;
|
|
||||||
int currentline = p->linedefined;
|
|
||||||
Table *t = luaH_new(L); /* new table to store active lines */
|
|
||||||
sethvalue2s(L, L->top.p, t); /* push it on stack */
|
|
||||||
api_incr_top(L);
|
|
||||||
setbtvalue(&v); /* boolean 'true' to be the value of all indices */
|
|
||||||
if (!p->is_vararg) /* regular function? */
|
|
||||||
i = 0; /* consider all instructions */
|
|
||||||
else { /* vararg function */
|
|
||||||
lua_assert(GET_OPCODE(p->code[0]) == OP_VARARGPREP);
|
|
||||||
currentline = nextline(p, currentline, 0);
|
|
||||||
i = 1; /* skip first instruction (OP_VARARGPREP) */
|
|
||||||
}
|
|
||||||
for (; i < p->sizelineinfo; i++) { /* for each instruction */
|
|
||||||
currentline = nextline(p, currentline, i); /* get its line */
|
|
||||||
luaH_setint(L, t, currentline, &v); /* table[line] = true */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
|
|
||||||
/* calling function is a known function? */
|
|
||||||
if (ci != NULL && !(ci->callstatus & CIST_TAIL))
|
|
||||||
return funcnamefromcall(L, ci->previous, name);
|
|
||||||
else return NULL; /* no way to find a name */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
|
|
||||||
Closure *f, CallInfo *ci) {
|
|
||||||
int status = 1;
|
|
||||||
for (; *what; what++) {
|
|
||||||
switch (*what) {
|
|
||||||
case 'S': {
|
|
||||||
funcinfo(ar, f);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'l': {
|
|
||||||
ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'u': {
|
|
||||||
ar->nups = (f == NULL) ? 0 : f->c.nupvalues;
|
|
||||||
if (noLuaClosure(f)) {
|
|
||||||
ar->isvararg = 1;
|
|
||||||
ar->nparams = 0;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
ar->isvararg = f->l.p->is_vararg;
|
|
||||||
ar->nparams = f->l.p->numparams;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 't': {
|
|
||||||
ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'n': {
|
|
||||||
ar->namewhat = getfuncname(L, ci, &ar->name);
|
|
||||||
if (ar->namewhat == NULL) {
|
|
||||||
ar->namewhat = ""; /* not found */
|
|
||||||
ar->name = NULL;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'r': {
|
|
||||||
if (ci == NULL || !(ci->callstatus & CIST_TRAN))
|
|
||||||
ar->ftransfer = ar->ntransfer = 0;
|
|
||||||
else {
|
|
||||||
ar->ftransfer = ci->u2.transferinfo.ftransfer;
|
|
||||||
ar->ntransfer = ci->u2.transferinfo.ntransfer;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'L':
|
|
||||||
case 'f': /* handled by lua_getinfo */
|
|
||||||
break;
|
|
||||||
default: status = 0; /* invalid option */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
|
|
||||||
int status;
|
|
||||||
Closure *cl;
|
|
||||||
CallInfo *ci;
|
|
||||||
TValue *func;
|
|
||||||
lua_lock(L);
|
|
||||||
if (*what == '>') {
|
|
||||||
ci = NULL;
|
|
||||||
func = s2v(L->top.p - 1);
|
|
||||||
api_check(L, ttisfunction(func), "function expected");
|
|
||||||
what++; /* skip the '>' */
|
|
||||||
L->top.p--; /* pop function */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
ci = ar->i_ci;
|
|
||||||
func = s2v(ci->func.p);
|
|
||||||
lua_assert(ttisfunction(func));
|
|
||||||
}
|
|
||||||
cl = ttisclosure(func) ? clvalue(func) : NULL;
|
|
||||||
status = auxgetinfo(L, what, ar, cl, ci);
|
|
||||||
if (strchr(what, 'f')) {
|
|
||||||
setobj2s(L, L->top.p, func);
|
|
||||||
api_incr_top(L);
|
|
||||||
}
|
|
||||||
if (strchr(what, 'L'))
|
|
||||||
collectvalidlines(L, cl);
|
|
||||||
lua_unlock(L);
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** Symbolic Execution
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
static const char *getobjname (const Proto *p, int lastpc, int reg,
|
|
||||||
const char **name);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Find a "name" for the constant 'c'.
|
|
||||||
*/
|
|
||||||
static void kname (const Proto *p, int c, const char **name) {
|
|
||||||
TValue *kvalue = &p->k[c];
|
|
||||||
*name = (ttisstring(kvalue)) ? svalue(kvalue) : "?";
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Find a "name" for the register 'c'.
|
|
||||||
*/
|
|
||||||
static void rname (const Proto *p, int pc, int c, const char **name) {
|
|
||||||
const char *what = getobjname(p, pc, c, name); /* search for 'c' */
|
|
||||||
if (!(what && *what == 'c')) /* did not find a constant name? */
|
|
||||||
*name = "?";
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Find a "name" for a 'C' value in an RK instruction.
|
|
||||||
*/
|
|
||||||
static void rkname (const Proto *p, int pc, Instruction i, const char **name) {
|
|
||||||
int c = GETARG_C(i); /* key index */
|
|
||||||
if (GETARG_k(i)) /* is 'c' a constant? */
|
|
||||||
kname(p, c, name);
|
|
||||||
else /* 'c' is a register */
|
|
||||||
rname(p, pc, c, name);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int filterpc (int pc, int jmptarget) {
|
|
||||||
if (pc < jmptarget) /* is code conditional (inside a jump)? */
|
|
||||||
return -1; /* cannot know who sets that register */
|
|
||||||
else return pc; /* current position sets that register */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Try to find last instruction before 'lastpc' that modified register 'reg'.
|
|
||||||
*/
|
|
||||||
static int findsetreg (const Proto *p, int lastpc, int reg) {
|
|
||||||
int pc;
|
|
||||||
int setreg = -1; /* keep last instruction that changed 'reg' */
|
|
||||||
int jmptarget = 0; /* any code before this address is conditional */
|
|
||||||
if (testMMMode(GET_OPCODE(p->code[lastpc])))
|
|
||||||
lastpc--; /* previous instruction was not actually executed */
|
|
||||||
for (pc = 0; pc < lastpc; pc++) {
|
|
||||||
Instruction i = p->code[pc];
|
|
||||||
OpCode op = GET_OPCODE(i);
|
|
||||||
int a = GETARG_A(i);
|
|
||||||
int change; /* true if current instruction changed 'reg' */
|
|
||||||
switch (op) {
|
|
||||||
case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */
|
|
||||||
int b = GETARG_B(i);
|
|
||||||
change = (a <= reg && reg <= a + b);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case OP_TFORCALL: { /* affect all regs above its base */
|
|
||||||
change = (reg >= a + 2);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case OP_CALL:
|
|
||||||
case OP_TAILCALL: { /* affect all registers above base */
|
|
||||||
change = (reg >= a);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */
|
|
||||||
int b = GETARG_sJ(i);
|
|
||||||
int dest = pc + 1 + b;
|
|
||||||
/* jump does not skip 'lastpc' and is larger than current one? */
|
|
||||||
if (dest <= lastpc && dest > jmptarget)
|
|
||||||
jmptarget = dest; /* update 'jmptarget' */
|
|
||||||
change = 0;
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
default: /* any instruction that sets A */
|
|
||||||
change = (testAMode(op) && reg == a);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
if (change)
|
|
||||||
setreg = filterpc(pc, jmptarget);
|
|
||||||
}
|
|
||||||
return setreg;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether table being indexed by instruction 'i' is the
|
|
||||||
** environment '_ENV'
|
|
||||||
*/
|
|
||||||
static const char *gxf (const Proto *p, int pc, Instruction i, int isup) {
|
|
||||||
int t = GETARG_B(i); /* table index */
|
|
||||||
const char *name; /* name of indexed variable */
|
|
||||||
if (isup) /* is an upvalue? */
|
|
||||||
name = upvalname(p, t);
|
|
||||||
else
|
|
||||||
getobjname(p, pc, t, &name);
|
|
||||||
return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field";
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *getobjname (const Proto *p, int lastpc, int reg,
|
|
||||||
const char **name) {
|
|
||||||
int pc;
|
|
||||||
*name = luaF_getlocalname(p, reg + 1, lastpc);
|
|
||||||
if (*name) /* is a local? */
|
|
||||||
return "local";
|
|
||||||
/* else try symbolic execution */
|
|
||||||
pc = findsetreg(p, lastpc, reg);
|
|
||||||
if (pc != -1) { /* could find instruction? */
|
|
||||||
Instruction i = p->code[pc];
|
|
||||||
OpCode op = GET_OPCODE(i);
|
|
||||||
switch (op) {
|
|
||||||
case OP_MOVE: {
|
|
||||||
int b = GETARG_B(i); /* move from 'b' to 'a' */
|
|
||||||
if (b < GETARG_A(i))
|
|
||||||
return getobjname(p, pc, b, name); /* get name for 'b' */
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case OP_GETTABUP: {
|
|
||||||
int k = GETARG_C(i); /* key index */
|
|
||||||
kname(p, k, name);
|
|
||||||
return gxf(p, pc, i, 1);
|
|
||||||
}
|
|
||||||
case OP_GETTABLE: {
|
|
||||||
int k = GETARG_C(i); /* key index */
|
|
||||||
rname(p, pc, k, name);
|
|
||||||
return gxf(p, pc, i, 0);
|
|
||||||
}
|
|
||||||
case OP_GETI: {
|
|
||||||
*name = "integer index";
|
|
||||||
return "field";
|
|
||||||
}
|
|
||||||
case OP_GETFIELD: {
|
|
||||||
int k = GETARG_C(i); /* key index */
|
|
||||||
kname(p, k, name);
|
|
||||||
return gxf(p, pc, i, 0);
|
|
||||||
}
|
|
||||||
case OP_GETUPVAL: {
|
|
||||||
*name = upvalname(p, GETARG_B(i));
|
|
||||||
return "upvalue";
|
|
||||||
}
|
|
||||||
case OP_LOADK:
|
|
||||||
case OP_LOADKX: {
|
|
||||||
int b = (op == OP_LOADK) ? GETARG_Bx(i)
|
|
||||||
: GETARG_Ax(p->code[pc + 1]);
|
|
||||||
if (ttisstring(&p->k[b])) {
|
|
||||||
*name = svalue(&p->k[b]);
|
|
||||||
return "constant";
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case OP_SELF: {
|
|
||||||
rkname(p, pc, i, name);
|
|
||||||
return "method";
|
|
||||||
}
|
|
||||||
default: break; /* go through to return NULL */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return NULL; /* could not find reasonable name */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Try to find a name for a function based on the code that called it.
|
|
||||||
** (Only works when function was called by a Lua function.)
|
|
||||||
** Returns what the name is (e.g., "for iterator", "method",
|
|
||||||
** "metamethod") and sets '*name' to point to the name.
|
|
||||||
*/
|
|
||||||
static const char *funcnamefromcode (lua_State *L, const Proto *p,
|
|
||||||
int pc, const char **name) {
|
|
||||||
TMS tm = (TMS)0; /* (initial value avoids warnings) */
|
|
||||||
Instruction i = p->code[pc]; /* calling instruction */
|
|
||||||
switch (GET_OPCODE(i)) {
|
|
||||||
case OP_CALL:
|
|
||||||
case OP_TAILCALL:
|
|
||||||
return getobjname(p, pc, GETARG_A(i), name); /* get function name */
|
|
||||||
case OP_TFORCALL: { /* for iterator */
|
|
||||||
*name = "for iterator";
|
|
||||||
return "for iterator";
|
|
||||||
}
|
|
||||||
/* other instructions can do calls through metamethods */
|
|
||||||
case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:
|
|
||||||
case OP_GETI: case OP_GETFIELD:
|
|
||||||
tm = TM_INDEX;
|
|
||||||
break;
|
|
||||||
case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD:
|
|
||||||
tm = TM_NEWINDEX;
|
|
||||||
break;
|
|
||||||
case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: {
|
|
||||||
tm = cast(TMS, GETARG_C(i));
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case OP_UNM: tm = TM_UNM; break;
|
|
||||||
case OP_BNOT: tm = TM_BNOT; break;
|
|
||||||
case OP_LEN: tm = TM_LEN; break;
|
|
||||||
case OP_CONCAT: tm = TM_CONCAT; break;
|
|
||||||
case OP_EQ: tm = TM_EQ; break;
|
|
||||||
/* no cases for OP_EQI and OP_EQK, as they don't call metamethods */
|
|
||||||
case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break;
|
|
||||||
case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break;
|
|
||||||
case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break;
|
|
||||||
default:
|
|
||||||
return NULL; /* cannot find a reasonable name */
|
|
||||||
}
|
|
||||||
*name = getstr(G(L)->tmname[tm]) + 2;
|
|
||||||
return "metamethod";
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Try to find a name for a function based on how it was called.
|
|
||||||
*/
|
|
||||||
static const char *funcnamefromcall (lua_State *L, CallInfo *ci,
|
|
||||||
const char **name) {
|
|
||||||
if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */
|
|
||||||
*name = "?";
|
|
||||||
return "hook";
|
|
||||||
}
|
|
||||||
else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */
|
|
||||||
*name = "__gc";
|
|
||||||
return "metamethod"; /* report it as such */
|
|
||||||
}
|
|
||||||
else if (isLua(ci))
|
|
||||||
return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name);
|
|
||||||
else
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether pointer 'o' points to some value in the stack frame of
|
|
||||||
** the current function and, if so, returns its index. Because 'o' may
|
|
||||||
** not point to a value in this stack, we cannot compare it with the
|
|
||||||
** region boundaries (undefined behavior in ISO C).
|
|
||||||
*/
|
|
||||||
static int instack (CallInfo *ci, const TValue *o) {
|
|
||||||
int pos;
|
|
||||||
StkId base = ci->func.p + 1;
|
|
||||||
for (pos = 0; base + pos < ci->top.p; pos++) {
|
|
||||||
if (o == s2v(base + pos))
|
|
||||||
return pos;
|
|
||||||
}
|
|
||||||
return -1; /* not found */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Checks whether value 'o' came from an upvalue. (That can only happen
|
|
||||||
** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
|
|
||||||
** upvalues.)
|
|
||||||
*/
|
|
||||||
static const char *getupvalname (CallInfo *ci, const TValue *o,
|
|
||||||
const char **name) {
|
|
||||||
LClosure *c = ci_func(ci);
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < c->nupvalues; i++) {
|
|
||||||
if (c->upvals[i]->v.p == o) {
|
|
||||||
*name = upvalname(c->p, i);
|
|
||||||
return "upvalue";
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *formatvarinfo (lua_State *L, const char *kind,
|
|
||||||
const char *name) {
|
|
||||||
if (kind == NULL)
|
|
||||||
return ""; /* no information */
|
|
||||||
else
|
|
||||||
return luaO_pushfstring(L, " (%s '%s')", kind, name);
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Build a string with a "description" for the value 'o', such as
|
|
||||||
** "variable 'x'" or "upvalue 'y'".
|
|
||||||
*/
|
|
||||||
static const char *varinfo (lua_State *L, const TValue *o) {
|
|
||||||
CallInfo *ci = L->ci;
|
|
||||||
const char *name = NULL; /* to avoid warnings */
|
|
||||||
const char *kind = NULL;
|
|
||||||
if (isLua(ci)) {
|
|
||||||
kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */
|
|
||||||
if (!kind) { /* not an upvalue? */
|
|
||||||
int reg = instack(ci, o); /* try a register */
|
|
||||||
if (reg >= 0) /* is 'o' a register? */
|
|
||||||
kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return formatvarinfo(L, kind, name);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Raise a type error
|
|
||||||
*/
|
|
||||||
static l_noret typeerror (lua_State *L, const TValue *o, const char *op,
|
|
||||||
const char *extra) {
|
|
||||||
const char *t = luaT_objtypename(L, o);
|
|
||||||
luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Raise a type error with "standard" information about the faulty
|
|
||||||
** object 'o' (using 'varinfo').
|
|
||||||
*/
|
|
||||||
l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {
|
|
||||||
typeerror(L, o, op, varinfo(L, o));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Raise an error for calling a non-callable object. Try to find a name
|
|
||||||
** for the object based on how it was called ('funcnamefromcall'); if it
|
|
||||||
** cannot get a name there, try 'varinfo'.
|
|
||||||
*/
|
|
||||||
l_noret luaG_callerror (lua_State *L, const TValue *o) {
|
|
||||||
CallInfo *ci = L->ci;
|
|
||||||
const char *name = NULL; /* to avoid warnings */
|
|
||||||
const char *kind = funcnamefromcall(L, ci, &name);
|
|
||||||
const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o);
|
|
||||||
typeerror(L, o, "call", extra);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) {
|
|
||||||
luaG_runerror(L, "bad 'for' %s (number expected, got %s)",
|
|
||||||
what, luaT_objtypename(L, o));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
|
|
||||||
if (ttisstring(p1) || cvt2str(p1)) p1 = p2;
|
|
||||||
luaG_typeerror(L, p1, "concatenate");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaG_opinterror (lua_State *L, const TValue *p1,
|
|
||||||
const TValue *p2, const char *msg) {
|
|
||||||
if (!ttisnumber(p1)) /* first operand is wrong? */
|
|
||||||
p2 = p1; /* now second is wrong */
|
|
||||||
luaG_typeerror(L, p2, msg);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Error when both values are convertible to numbers, but not to integers
|
|
||||||
*/
|
|
||||||
l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
|
|
||||||
lua_Integer temp;
|
|
||||||
if (!luaV_tointegerns(p1, &temp, LUA_FLOORN2I))
|
|
||||||
p2 = p1;
|
|
||||||
luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {
|
|
||||||
const char *t1 = luaT_objtypename(L, p1);
|
|
||||||
const char *t2 = luaT_objtypename(L, p2);
|
|
||||||
if (strcmp(t1, t2) == 0)
|
|
||||||
luaG_runerror(L, "attempt to compare two %s values", t1);
|
|
||||||
else
|
|
||||||
luaG_runerror(L, "attempt to compare %s with %s", t1, t2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* add src:line information to 'msg' */
|
|
||||||
const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
|
|
||||||
int line) {
|
|
||||||
char buff[LUA_IDSIZE];
|
|
||||||
if (src)
|
|
||||||
luaO_chunkid(buff, getstr(src), tsslen(src));
|
|
||||||
else { /* no source available; use "?" instead */
|
|
||||||
buff[0] = '?'; buff[1] = '\0';
|
|
||||||
}
|
|
||||||
return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaG_errormsg (lua_State *L) {
|
|
||||||
if (L->errfunc != 0) { /* is there an error handling function? */
|
|
||||||
StkId errfunc = restorestack(L, L->errfunc);
|
|
||||||
lua_assert(ttisfunction(s2v(errfunc)));
|
|
||||||
setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */
|
|
||||||
setobjs2s(L, L->top.p - 1, errfunc); /* push function */
|
|
||||||
L->top.p++; /* assume EXTRA_STACK */
|
|
||||||
luaD_callnoyield(L, L->top.p - 2, 1); /* call it */
|
|
||||||
}
|
|
||||||
luaD_throw(L, LUA_ERRRUN);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
|
|
||||||
CallInfo *ci = L->ci;
|
|
||||||
const char *msg;
|
|
||||||
va_list argp;
|
|
||||||
luaC_checkGC(L); /* error message uses memory */
|
|
||||||
va_start(argp, fmt);
|
|
||||||
msg = luaO_pushvfstring(L, fmt, argp); /* format message */
|
|
||||||
va_end(argp);
|
|
||||||
if (isLua(ci)) { /* if Lua function, add source:line information */
|
|
||||||
luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci));
|
|
||||||
setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */
|
|
||||||
L->top.p--;
|
|
||||||
}
|
|
||||||
luaG_errormsg(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether new instruction 'newpc' is in a different line from
|
|
||||||
** previous instruction 'oldpc'. More often than not, 'newpc' is only
|
|
||||||
** one or a few instructions after 'oldpc' (it must be after, see
|
|
||||||
** caller), so try to avoid calling 'luaG_getfuncline'. If they are
|
|
||||||
** too far apart, there is a good chance of a ABSLINEINFO in the way,
|
|
||||||
** so it goes directly to 'luaG_getfuncline'.
|
|
||||||
*/
|
|
||||||
static int changedline (const Proto *p, int oldpc, int newpc) {
|
|
||||||
if (p->lineinfo == NULL) /* no debug information? */
|
|
||||||
return 0;
|
|
||||||
if (newpc - oldpc < MAXIWTHABS / 2) { /* not too far apart? */
|
|
||||||
int delta = 0; /* line difference */
|
|
||||||
int pc = oldpc;
|
|
||||||
for (;;) {
|
|
||||||
int lineinfo = p->lineinfo[++pc];
|
|
||||||
if (lineinfo == ABSLINEINFO)
|
|
||||||
break; /* cannot compute delta; fall through */
|
|
||||||
delta += lineinfo;
|
|
||||||
if (pc == newpc)
|
|
||||||
return (delta != 0); /* delta computed successfully */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* either instructions are too far apart or there is an absolute line
|
|
||||||
info in the way; compute line difference explicitly */
|
|
||||||
return (luaG_getfuncline(p, oldpc) != luaG_getfuncline(p, newpc));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Traces the execution of a Lua function. Called before the execution
|
|
||||||
** of each opcode, when debug is on. 'L->oldpc' stores the last
|
|
||||||
** instruction traced, to detect line changes. When entering a new
|
|
||||||
** function, 'npci' will be zero and will test as a new line whatever
|
|
||||||
** the value of 'oldpc'. Some exceptional conditions may return to
|
|
||||||
** a function without setting 'oldpc'. In that case, 'oldpc' may be
|
|
||||||
** invalid; if so, use zero as a valid value. (A wrong but valid 'oldpc'
|
|
||||||
** at most causes an extra call to a line hook.)
|
|
||||||
** This function is not "Protected" when called, so it should correct
|
|
||||||
** 'L->top.p' before calling anything that can run the GC.
|
|
||||||
*/
|
|
||||||
int luaG_traceexec (lua_State *L, const Instruction *pc) {
|
|
||||||
CallInfo *ci = L->ci;
|
|
||||||
lu_byte mask = L->hookmask;
|
|
||||||
const Proto *p = ci_func(ci)->p;
|
|
||||||
int counthook;
|
|
||||||
if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */
|
|
||||||
ci->u.l.trap = 0; /* don't need to stop again */
|
|
||||||
return 0; /* turn off 'trap' */
|
|
||||||
}
|
|
||||||
pc++; /* reference is always next instruction */
|
|
||||||
ci->u.l.savedpc = pc; /* save 'pc' */
|
|
||||||
counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
|
|
||||||
if (counthook)
|
|
||||||
resethookcount(L); /* reset count */
|
|
||||||
else if (!(mask & LUA_MASKLINE))
|
|
||||||
return 1; /* no line hook and count != 0; nothing to be done now */
|
|
||||||
if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */
|
|
||||||
ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */
|
|
||||||
return 1; /* do not call hook again (VM yielded, so it did not move) */
|
|
||||||
}
|
|
||||||
if (!isIT(*(ci->u.l.savedpc - 1))) /* top not being used? */
|
|
||||||
L->top.p = ci->top.p; /* correct top */
|
|
||||||
if (counthook)
|
|
||||||
luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */
|
|
||||||
if (mask & LUA_MASKLINE) {
|
|
||||||
/* 'L->oldpc' may be invalid; use zero in this case */
|
|
||||||
int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0;
|
|
||||||
int npci = pcRel(pc, p);
|
|
||||||
if (npci <= oldpc || /* call hook when jump back (loop), */
|
|
||||||
changedline(p, oldpc, npci)) { /* or when enter new line */
|
|
||||||
int newline = luaG_getfuncline(p, npci);
|
|
||||||
luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */
|
|
||||||
}
|
|
||||||
L->oldpc = npci; /* 'pc' of last call to line hook */
|
|
||||||
}
|
|
||||||
if (L->status == LUA_YIELD) { /* did hook yield? */
|
|
||||||
if (counthook)
|
|
||||||
L->hookcount = 1; /* undo decrement to zero */
|
|
||||||
ci->u.l.savedpc--; /* undo increment (resume will increment it again) */
|
|
||||||
ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */
|
|
||||||
luaD_throw(L, LUA_YIELD);
|
|
||||||
}
|
|
||||||
return 1; /* keep 'trap' on */
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,63 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ldebug.h $
|
|
||||||
** Auxiliary functions from Debug Interface module
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef ldebug_h
|
|
||||||
#define ldebug_h
|
|
||||||
|
|
||||||
|
|
||||||
#include "lstate.h"
|
|
||||||
|
|
||||||
|
|
||||||
#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1)
|
|
||||||
|
|
||||||
|
|
||||||
/* Active Lua function (given call info) */
|
|
||||||
#define ci_func(ci) (clLvalue(s2v((ci)->func.p)))
|
|
||||||
|
|
||||||
|
|
||||||
#define resethookcount(L) (L->hookcount = L->basehookcount)
|
|
||||||
|
|
||||||
/*
|
|
||||||
** mark for entries in 'lineinfo' array that has absolute information in
|
|
||||||
** 'abslineinfo' array
|
|
||||||
*/
|
|
||||||
#define ABSLINEINFO (-0x80)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** MAXimum number of successive Instructions WiTHout ABSolute line
|
|
||||||
** information. (A power of two allows fast divisions.)
|
|
||||||
*/
|
|
||||||
#if !defined(MAXIWTHABS)
|
|
||||||
#define MAXIWTHABS 128
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
LUAI_FUNC int luaG_getfuncline (const Proto *f, int pc);
|
|
||||||
LUAI_FUNC const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n,
|
|
||||||
StkId *pos);
|
|
||||||
LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
|
|
||||||
const char *opname);
|
|
||||||
LUAI_FUNC l_noret luaG_callerror (lua_State *L, const TValue *o);
|
|
||||||
LUAI_FUNC l_noret luaG_forerror (lua_State *L, const TValue *o,
|
|
||||||
const char *what);
|
|
||||||
LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
|
|
||||||
const TValue *p2);
|
|
||||||
LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,
|
|
||||||
const TValue *p2,
|
|
||||||
const char *msg);
|
|
||||||
LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,
|
|
||||||
const TValue *p2);
|
|
||||||
LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
|
|
||||||
const TValue *p2);
|
|
||||||
LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
|
|
||||||
LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
|
|
||||||
TString *src, int line);
|
|
||||||
LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
|
|
||||||
LUAI_FUNC int luaG_traceexec (lua_State *L, const Instruction *pc);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
1024
lua-5.4.5/src/ldo.c
1024
lua-5.4.5/src/ldo.c
File diff suppressed because it is too large
Load Diff
@ -1,88 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ldo.h $
|
|
||||||
** Stack and Call structure of Lua
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef ldo_h
|
|
||||||
#define ldo_h
|
|
||||||
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
#include "lzio.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Macro to check stack size and grow stack if needed. Parameters
|
|
||||||
** 'pre'/'pos' allow the macro to preserve a pointer into the
|
|
||||||
** stack across reallocations, doing the work only when needed.
|
|
||||||
** It also allows the running of one GC step when the stack is
|
|
||||||
** reallocated.
|
|
||||||
** 'condmovestack' is used in heavy tests to force a stack reallocation
|
|
||||||
** at every check.
|
|
||||||
*/
|
|
||||||
#define luaD_checkstackaux(L,n,pre,pos) \
|
|
||||||
if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \
|
|
||||||
{ pre; luaD_growstack(L, n, 1); pos; } \
|
|
||||||
else { condmovestack(L,pre,pos); }
|
|
||||||
|
|
||||||
/* In general, 'pre'/'pos' are empty (nothing to save) */
|
|
||||||
#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p))
|
|
||||||
#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n))
|
|
||||||
|
|
||||||
|
|
||||||
/* macro to check stack size, preserving 'p' */
|
|
||||||
#define checkstackp(L,n,p) \
|
|
||||||
luaD_checkstackaux(L, n, \
|
|
||||||
ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \
|
|
||||||
p = restorestack(L, t__)) /* 'pos' part: restore 'p' */
|
|
||||||
|
|
||||||
|
|
||||||
/* macro to check stack size and GC, preserving 'p' */
|
|
||||||
#define checkstackGCp(L,n,p) \
|
|
||||||
luaD_checkstackaux(L, n, \
|
|
||||||
ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \
|
|
||||||
luaC_checkGC(L), /* stack grow uses memory */ \
|
|
||||||
p = restorestack(L, t__)) /* 'pos' part: restore 'p' */
|
|
||||||
|
|
||||||
|
|
||||||
/* macro to check stack size and GC */
|
|
||||||
#define checkstackGC(L,fsize) \
|
|
||||||
luaD_checkstackaux(L, (fsize), luaC_checkGC(L), (void)0)
|
|
||||||
|
|
||||||
|
|
||||||
/* type of protected functions, to be ran by 'runprotected' */
|
|
||||||
typedef void (*Pfunc) (lua_State *L, void *ud);
|
|
||||||
|
|
||||||
LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);
|
|
||||||
LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
|
|
||||||
const char *mode);
|
|
||||||
LUAI_FUNC void luaD_hook (lua_State *L, int event, int line,
|
|
||||||
int fTransfer, int nTransfer);
|
|
||||||
LUAI_FUNC void luaD_hookcall (lua_State *L, CallInfo *ci);
|
|
||||||
LUAI_FUNC int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func,
|
|
||||||
int narg1, int delta);
|
|
||||||
LUAI_FUNC CallInfo *luaD_precall (lua_State *L, StkId func, int nResults);
|
|
||||||
LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
|
|
||||||
LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
|
|
||||||
LUAI_FUNC StkId luaD_tryfuncTM (lua_State *L, StkId func);
|
|
||||||
LUAI_FUNC int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status);
|
|
||||||
LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
|
|
||||||
ptrdiff_t oldtop, ptrdiff_t ef);
|
|
||||||
LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, int nres);
|
|
||||||
LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror);
|
|
||||||
LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror);
|
|
||||||
LUAI_FUNC void luaD_shrinkstack (lua_State *L);
|
|
||||||
LUAI_FUNC void luaD_inctop (lua_State *L);
|
|
||||||
|
|
||||||
LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
|
|
||||||
LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,230 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ldump.c $
|
|
||||||
** save precompiled Lua chunks
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define ldump_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
#include "lundump.h"
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct {
|
|
||||||
lua_State *L;
|
|
||||||
lua_Writer writer;
|
|
||||||
void *data;
|
|
||||||
int strip;
|
|
||||||
int status;
|
|
||||||
} DumpState;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** All high-level dumps go through dumpVector; you can change it to
|
|
||||||
** change the endianness of the result
|
|
||||||
*/
|
|
||||||
#define dumpVector(D,v,n) dumpBlock(D,v,(n)*sizeof((v)[0]))
|
|
||||||
|
|
||||||
#define dumpLiteral(D, s) dumpBlock(D,s,sizeof(s) - sizeof(char))
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpBlock (DumpState *D, const void *b, size_t size) {
|
|
||||||
if (D->status == 0 && size > 0) {
|
|
||||||
lua_unlock(D->L);
|
|
||||||
D->status = (*D->writer)(D->L, b, size, D->data);
|
|
||||||
lua_lock(D->L);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#define dumpVar(D,x) dumpVector(D,&x,1)
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpByte (DumpState *D, int y) {
|
|
||||||
lu_byte x = (lu_byte)y;
|
|
||||||
dumpVar(D, x);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'dumpSize' buffer size: each byte can store up to 7 bits. (The "+6"
|
|
||||||
** rounds up the division.)
|
|
||||||
*/
|
|
||||||
#define DIBS ((sizeof(size_t) * CHAR_BIT + 6) / 7)
|
|
||||||
|
|
||||||
static void dumpSize (DumpState *D, size_t x) {
|
|
||||||
lu_byte buff[DIBS];
|
|
||||||
int n = 0;
|
|
||||||
do {
|
|
||||||
buff[DIBS - (++n)] = x & 0x7f; /* fill buffer in reverse order */
|
|
||||||
x >>= 7;
|
|
||||||
} while (x != 0);
|
|
||||||
buff[DIBS - 1] |= 0x80; /* mark last byte */
|
|
||||||
dumpVector(D, buff + DIBS - n, n);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpInt (DumpState *D, int x) {
|
|
||||||
dumpSize(D, x);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpNumber (DumpState *D, lua_Number x) {
|
|
||||||
dumpVar(D, x);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpInteger (DumpState *D, lua_Integer x) {
|
|
||||||
dumpVar(D, x);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpString (DumpState *D, const TString *s) {
|
|
||||||
if (s == NULL)
|
|
||||||
dumpSize(D, 0);
|
|
||||||
else {
|
|
||||||
size_t size = tsslen(s);
|
|
||||||
const char *str = getstr(s);
|
|
||||||
dumpSize(D, size + 1);
|
|
||||||
dumpVector(D, str, size);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpCode (DumpState *D, const Proto *f) {
|
|
||||||
dumpInt(D, f->sizecode);
|
|
||||||
dumpVector(D, f->code, f->sizecode);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpFunction(DumpState *D, const Proto *f, TString *psource);
|
|
||||||
|
|
||||||
static void dumpConstants (DumpState *D, const Proto *f) {
|
|
||||||
int i;
|
|
||||||
int n = f->sizek;
|
|
||||||
dumpInt(D, n);
|
|
||||||
for (i = 0; i < n; i++) {
|
|
||||||
const TValue *o = &f->k[i];
|
|
||||||
int tt = ttypetag(o);
|
|
||||||
dumpByte(D, tt);
|
|
||||||
switch (tt) {
|
|
||||||
case LUA_VNUMFLT:
|
|
||||||
dumpNumber(D, fltvalue(o));
|
|
||||||
break;
|
|
||||||
case LUA_VNUMINT:
|
|
||||||
dumpInteger(D, ivalue(o));
|
|
||||||
break;
|
|
||||||
case LUA_VSHRSTR:
|
|
||||||
case LUA_VLNGSTR:
|
|
||||||
dumpString(D, tsvalue(o));
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
lua_assert(tt == LUA_VNIL || tt == LUA_VFALSE || tt == LUA_VTRUE);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpProtos (DumpState *D, const Proto *f) {
|
|
||||||
int i;
|
|
||||||
int n = f->sizep;
|
|
||||||
dumpInt(D, n);
|
|
||||||
for (i = 0; i < n; i++)
|
|
||||||
dumpFunction(D, f->p[i], f->source);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpUpvalues (DumpState *D, const Proto *f) {
|
|
||||||
int i, n = f->sizeupvalues;
|
|
||||||
dumpInt(D, n);
|
|
||||||
for (i = 0; i < n; i++) {
|
|
||||||
dumpByte(D, f->upvalues[i].instack);
|
|
||||||
dumpByte(D, f->upvalues[i].idx);
|
|
||||||
dumpByte(D, f->upvalues[i].kind);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpDebug (DumpState *D, const Proto *f) {
|
|
||||||
int i, n;
|
|
||||||
n = (D->strip) ? 0 : f->sizelineinfo;
|
|
||||||
dumpInt(D, n);
|
|
||||||
dumpVector(D, f->lineinfo, n);
|
|
||||||
n = (D->strip) ? 0 : f->sizeabslineinfo;
|
|
||||||
dumpInt(D, n);
|
|
||||||
for (i = 0; i < n; i++) {
|
|
||||||
dumpInt(D, f->abslineinfo[i].pc);
|
|
||||||
dumpInt(D, f->abslineinfo[i].line);
|
|
||||||
}
|
|
||||||
n = (D->strip) ? 0 : f->sizelocvars;
|
|
||||||
dumpInt(D, n);
|
|
||||||
for (i = 0; i < n; i++) {
|
|
||||||
dumpString(D, f->locvars[i].varname);
|
|
||||||
dumpInt(D, f->locvars[i].startpc);
|
|
||||||
dumpInt(D, f->locvars[i].endpc);
|
|
||||||
}
|
|
||||||
n = (D->strip) ? 0 : f->sizeupvalues;
|
|
||||||
dumpInt(D, n);
|
|
||||||
for (i = 0; i < n; i++)
|
|
||||||
dumpString(D, f->upvalues[i].name);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpFunction (DumpState *D, const Proto *f, TString *psource) {
|
|
||||||
if (D->strip || f->source == psource)
|
|
||||||
dumpString(D, NULL); /* no debug info or same source as its parent */
|
|
||||||
else
|
|
||||||
dumpString(D, f->source);
|
|
||||||
dumpInt(D, f->linedefined);
|
|
||||||
dumpInt(D, f->lastlinedefined);
|
|
||||||
dumpByte(D, f->numparams);
|
|
||||||
dumpByte(D, f->is_vararg);
|
|
||||||
dumpByte(D, f->maxstacksize);
|
|
||||||
dumpCode(D, f);
|
|
||||||
dumpConstants(D, f);
|
|
||||||
dumpUpvalues(D, f);
|
|
||||||
dumpProtos(D, f);
|
|
||||||
dumpDebug(D, f);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void dumpHeader (DumpState *D) {
|
|
||||||
dumpLiteral(D, LUA_SIGNATURE);
|
|
||||||
dumpByte(D, LUAC_VERSION);
|
|
||||||
dumpByte(D, LUAC_FORMAT);
|
|
||||||
dumpLiteral(D, LUAC_DATA);
|
|
||||||
dumpByte(D, sizeof(Instruction));
|
|
||||||
dumpByte(D, sizeof(lua_Integer));
|
|
||||||
dumpByte(D, sizeof(lua_Number));
|
|
||||||
dumpInteger(D, LUAC_INT);
|
|
||||||
dumpNumber(D, LUAC_NUM);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** dump Lua function as precompiled chunk
|
|
||||||
*/
|
|
||||||
int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data,
|
|
||||||
int strip) {
|
|
||||||
DumpState D;
|
|
||||||
D.L = L;
|
|
||||||
D.writer = w;
|
|
||||||
D.data = data;
|
|
||||||
D.strip = strip;
|
|
||||||
D.status = 0;
|
|
||||||
dumpHeader(&D);
|
|
||||||
dumpByte(&D, f->sizeupvalues);
|
|
||||||
dumpFunction(&D, f, NULL);
|
|
||||||
return D.status;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,294 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lfunc.c $
|
|
||||||
** Auxiliary functions to manipulate prototypes and closures
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lfunc_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "ldebug.h"
|
|
||||||
#include "ldo.h"
|
|
||||||
#include "lfunc.h"
|
|
||||||
#include "lgc.h"
|
|
||||||
#include "lmem.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
CClosure *luaF_newCclosure (lua_State *L, int nupvals) {
|
|
||||||
GCObject *o = luaC_newobj(L, LUA_VCCL, sizeCclosure(nupvals));
|
|
||||||
CClosure *c = gco2ccl(o);
|
|
||||||
c->nupvalues = cast_byte(nupvals);
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LClosure *luaF_newLclosure (lua_State *L, int nupvals) {
|
|
||||||
GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals));
|
|
||||||
LClosure *c = gco2lcl(o);
|
|
||||||
c->p = NULL;
|
|
||||||
c->nupvalues = cast_byte(nupvals);
|
|
||||||
while (nupvals--) c->upvals[nupvals] = NULL;
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** fill a closure with new closed upvalues
|
|
||||||
*/
|
|
||||||
void luaF_initupvals (lua_State *L, LClosure *cl) {
|
|
||||||
int i;
|
|
||||||
for (i = 0; i < cl->nupvalues; i++) {
|
|
||||||
GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
|
|
||||||
UpVal *uv = gco2upv(o);
|
|
||||||
uv->v.p = &uv->u.value; /* make it closed */
|
|
||||||
setnilvalue(uv->v.p);
|
|
||||||
cl->upvals[i] = uv;
|
|
||||||
luaC_objbarrier(L, cl, uv);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Create a new upvalue at the given level, and link it to the list of
|
|
||||||
** open upvalues of 'L' after entry 'prev'.
|
|
||||||
**/
|
|
||||||
static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) {
|
|
||||||
GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal));
|
|
||||||
UpVal *uv = gco2upv(o);
|
|
||||||
UpVal *next = *prev;
|
|
||||||
uv->v.p = s2v(level); /* current value lives in the stack */
|
|
||||||
uv->u.open.next = next; /* link it to list of open upvalues */
|
|
||||||
uv->u.open.previous = prev;
|
|
||||||
if (next)
|
|
||||||
next->u.open.previous = &uv->u.open.next;
|
|
||||||
*prev = uv;
|
|
||||||
if (!isintwups(L)) { /* thread not in list of threads with upvalues? */
|
|
||||||
L->twups = G(L)->twups; /* link it to the list */
|
|
||||||
G(L)->twups = L;
|
|
||||||
}
|
|
||||||
return uv;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Find and reuse, or create if it does not exist, an upvalue
|
|
||||||
** at the given level.
|
|
||||||
*/
|
|
||||||
UpVal *luaF_findupval (lua_State *L, StkId level) {
|
|
||||||
UpVal **pp = &L->openupval;
|
|
||||||
UpVal *p;
|
|
||||||
lua_assert(isintwups(L) || L->openupval == NULL);
|
|
||||||
while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */
|
|
||||||
lua_assert(!isdead(G(L), p));
|
|
||||||
if (uplevel(p) == level) /* corresponding upvalue? */
|
|
||||||
return p; /* return it */
|
|
||||||
pp = &p->u.open.next;
|
|
||||||
}
|
|
||||||
/* not found: create a new upvalue after 'pp' */
|
|
||||||
return newupval(L, level, pp);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Call closing method for object 'obj' with error message 'err'. The
|
|
||||||
** boolean 'yy' controls whether the call is yieldable.
|
|
||||||
** (This function assumes EXTRA_STACK.)
|
|
||||||
*/
|
|
||||||
static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) {
|
|
||||||
StkId top = L->top.p;
|
|
||||||
const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE);
|
|
||||||
setobj2s(L, top, tm); /* will call metamethod... */
|
|
||||||
setobj2s(L, top + 1, obj); /* with 'self' as the 1st argument */
|
|
||||||
setobj2s(L, top + 2, err); /* and error msg. as 2nd argument */
|
|
||||||
L->top.p = top + 3; /* add function and arguments */
|
|
||||||
if (yy)
|
|
||||||
luaD_call(L, top, 0);
|
|
||||||
else
|
|
||||||
luaD_callnoyield(L, top, 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether object at given level has a close metamethod and raise
|
|
||||||
** an error if not.
|
|
||||||
*/
|
|
||||||
static void checkclosemth (lua_State *L, StkId level) {
|
|
||||||
const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE);
|
|
||||||
if (ttisnil(tm)) { /* no metamethod? */
|
|
||||||
int idx = cast_int(level - L->ci->func.p); /* variable index */
|
|
||||||
const char *vname = luaG_findlocal(L, L->ci, idx, NULL);
|
|
||||||
if (vname == NULL) vname = "?";
|
|
||||||
luaG_runerror(L, "variable '%s' got a non-closable value", vname);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Prepare and call a closing method.
|
|
||||||
** If status is CLOSEKTOP, the call to the closing method will be pushed
|
|
||||||
** at the top of the stack. Otherwise, values can be pushed right after
|
|
||||||
** the 'level' of the upvalue being closed, as everything after that
|
|
||||||
** won't be used again.
|
|
||||||
*/
|
|
||||||
static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) {
|
|
||||||
TValue *uv = s2v(level); /* value being closed */
|
|
||||||
TValue *errobj;
|
|
||||||
if (status == CLOSEKTOP)
|
|
||||||
errobj = &G(L)->nilvalue; /* error object is nil */
|
|
||||||
else { /* 'luaD_seterrorobj' will set top to level + 2 */
|
|
||||||
errobj = s2v(level + 1); /* error object goes after 'uv' */
|
|
||||||
luaD_seterrorobj(L, status, level + 1); /* set error object */
|
|
||||||
}
|
|
||||||
callclosemethod(L, uv, errobj, yy);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Maximum value for deltas in 'tbclist', dependent on the type
|
|
||||||
** of delta. (This macro assumes that an 'L' is in scope where it
|
|
||||||
** is used.)
|
|
||||||
*/
|
|
||||||
#define MAXDELTA \
|
|
||||||
((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Insert a variable in the list of to-be-closed variables.
|
|
||||||
*/
|
|
||||||
void luaF_newtbcupval (lua_State *L, StkId level) {
|
|
||||||
lua_assert(level > L->tbclist.p);
|
|
||||||
if (l_isfalse(s2v(level)))
|
|
||||||
return; /* false doesn't need to be closed */
|
|
||||||
checkclosemth(L, level); /* value must have a close method */
|
|
||||||
while (cast_uint(level - L->tbclist.p) > MAXDELTA) {
|
|
||||||
L->tbclist.p += MAXDELTA; /* create a dummy node at maximum delta */
|
|
||||||
L->tbclist.p->tbclist.delta = 0;
|
|
||||||
}
|
|
||||||
level->tbclist.delta = cast(unsigned short, level - L->tbclist.p);
|
|
||||||
L->tbclist.p = level;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaF_unlinkupval (UpVal *uv) {
|
|
||||||
lua_assert(upisopen(uv));
|
|
||||||
*uv->u.open.previous = uv->u.open.next;
|
|
||||||
if (uv->u.open.next)
|
|
||||||
uv->u.open.next->u.open.previous = uv->u.open.previous;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Close all upvalues up to the given stack level.
|
|
||||||
*/
|
|
||||||
void luaF_closeupval (lua_State *L, StkId level) {
|
|
||||||
UpVal *uv;
|
|
||||||
StkId upl; /* stack index pointed by 'uv' */
|
|
||||||
while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) {
|
|
||||||
TValue *slot = &uv->u.value; /* new position for value */
|
|
||||||
lua_assert(uplevel(uv) < L->top.p);
|
|
||||||
luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */
|
|
||||||
setobj(L, slot, uv->v.p); /* move value to upvalue slot */
|
|
||||||
uv->v.p = slot; /* now current value lives here */
|
|
||||||
if (!iswhite(uv)) { /* neither white nor dead? */
|
|
||||||
nw2black(uv); /* closed upvalues cannot be gray */
|
|
||||||
luaC_barrier(L, uv, slot);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Remove first element from the tbclist plus its dummy nodes.
|
|
||||||
*/
|
|
||||||
static void poptbclist (lua_State *L) {
|
|
||||||
StkId tbc = L->tbclist.p;
|
|
||||||
lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */
|
|
||||||
tbc -= tbc->tbclist.delta;
|
|
||||||
while (tbc > L->stack.p && tbc->tbclist.delta == 0)
|
|
||||||
tbc -= MAXDELTA; /* remove dummy nodes */
|
|
||||||
L->tbclist.p = tbc;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Close all upvalues and to-be-closed variables up to the given stack
|
|
||||||
** level. Return restored 'level'.
|
|
||||||
*/
|
|
||||||
StkId luaF_close (lua_State *L, StkId level, int status, int yy) {
|
|
||||||
ptrdiff_t levelrel = savestack(L, level);
|
|
||||||
luaF_closeupval(L, level); /* first, close the upvalues */
|
|
||||||
while (L->tbclist.p >= level) { /* traverse tbc's down to that level */
|
|
||||||
StkId tbc = L->tbclist.p; /* get variable index */
|
|
||||||
poptbclist(L); /* remove it from list */
|
|
||||||
prepcallclosemth(L, tbc, status, yy); /* close variable */
|
|
||||||
level = restorestack(L, levelrel);
|
|
||||||
}
|
|
||||||
return level;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
Proto *luaF_newproto (lua_State *L) {
|
|
||||||
GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto));
|
|
||||||
Proto *f = gco2p(o);
|
|
||||||
f->k = NULL;
|
|
||||||
f->sizek = 0;
|
|
||||||
f->p = NULL;
|
|
||||||
f->sizep = 0;
|
|
||||||
f->code = NULL;
|
|
||||||
f->sizecode = 0;
|
|
||||||
f->lineinfo = NULL;
|
|
||||||
f->sizelineinfo = 0;
|
|
||||||
f->abslineinfo = NULL;
|
|
||||||
f->sizeabslineinfo = 0;
|
|
||||||
f->upvalues = NULL;
|
|
||||||
f->sizeupvalues = 0;
|
|
||||||
f->numparams = 0;
|
|
||||||
f->is_vararg = 0;
|
|
||||||
f->maxstacksize = 0;
|
|
||||||
f->locvars = NULL;
|
|
||||||
f->sizelocvars = 0;
|
|
||||||
f->linedefined = 0;
|
|
||||||
f->lastlinedefined = 0;
|
|
||||||
f->source = NULL;
|
|
||||||
return f;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaF_freeproto (lua_State *L, Proto *f) {
|
|
||||||
luaM_freearray(L, f->code, f->sizecode);
|
|
||||||
luaM_freearray(L, f->p, f->sizep);
|
|
||||||
luaM_freearray(L, f->k, f->sizek);
|
|
||||||
luaM_freearray(L, f->lineinfo, f->sizelineinfo);
|
|
||||||
luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
|
|
||||||
luaM_freearray(L, f->locvars, f->sizelocvars);
|
|
||||||
luaM_freearray(L, f->upvalues, f->sizeupvalues);
|
|
||||||
luaM_free(L, f);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Look for n-th local variable at line 'line' in function 'func'.
|
|
||||||
** Returns NULL if not found.
|
|
||||||
*/
|
|
||||||
const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
|
|
||||||
int i;
|
|
||||||
for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
|
|
||||||
if (pc < f->locvars[i].endpc) { /* is variable active? */
|
|
||||||
local_number--;
|
|
||||||
if (local_number == 0)
|
|
||||||
return getstr(f->locvars[i].varname);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return NULL; /* not found */
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,64 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lfunc.h $
|
|
||||||
** Auxiliary functions to manipulate prototypes and closures
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lfunc_h
|
|
||||||
#define lfunc_h
|
|
||||||
|
|
||||||
|
|
||||||
#include "lobject.h"
|
|
||||||
|
|
||||||
|
|
||||||
#define sizeCclosure(n) (cast_int(offsetof(CClosure, upvalue)) + \
|
|
||||||
cast_int(sizeof(TValue)) * (n))
|
|
||||||
|
|
||||||
#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \
|
|
||||||
cast_int(sizeof(TValue *)) * (n))
|
|
||||||
|
|
||||||
|
|
||||||
/* test whether thread is in 'twups' list */
|
|
||||||
#define isintwups(L) (L->twups != L)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** maximum number of upvalues in a closure (both C and Lua). (Value
|
|
||||||
** must fit in a VM register.)
|
|
||||||
*/
|
|
||||||
#define MAXUPVAL 255
|
|
||||||
|
|
||||||
|
|
||||||
#define upisopen(up) ((up)->v.p != &(up)->u.value)
|
|
||||||
|
|
||||||
|
|
||||||
#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** maximum number of misses before giving up the cache of closures
|
|
||||||
** in prototypes
|
|
||||||
*/
|
|
||||||
#define MAXMISS 10
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* special status to close upvalues preserving the top of the stack */
|
|
||||||
#define CLOSEKTOP (-1)
|
|
||||||
|
|
||||||
|
|
||||||
LUAI_FUNC Proto *luaF_newproto (lua_State *L);
|
|
||||||
LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nupvals);
|
|
||||||
LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nupvals);
|
|
||||||
LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
|
|
||||||
LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
|
|
||||||
LUAI_FUNC void luaF_newtbcupval (lua_State *L, StkId level);
|
|
||||||
LUAI_FUNC void luaF_closeupval (lua_State *L, StkId level);
|
|
||||||
LUAI_FUNC StkId luaF_close (lua_State *L, StkId level, int status, int yy);
|
|
||||||
LUAI_FUNC void luaF_unlinkupval (UpVal *uv);
|
|
||||||
LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
|
|
||||||
LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
|
|
||||||
int pc);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
1739
lua-5.4.5/src/lgc.c
1739
lua-5.4.5/src/lgc.c
File diff suppressed because it is too large
Load Diff
@ -1,202 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lgc.h $
|
|
||||||
** Garbage Collector
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lgc_h
|
|
||||||
#define lgc_h
|
|
||||||
|
|
||||||
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Collectable objects may have one of three colors: white, which means
|
|
||||||
** the object is not marked; gray, which means the object is marked, but
|
|
||||||
** its references may be not marked; and black, which means that the
|
|
||||||
** object and all its references are marked. The main invariant of the
|
|
||||||
** garbage collector, while marking objects, is that a black object can
|
|
||||||
** never point to a white one. Moreover, any gray object must be in a
|
|
||||||
** "gray list" (gray, grayagain, weak, allweak, ephemeron) so that it
|
|
||||||
** can be visited again before finishing the collection cycle. (Open
|
|
||||||
** upvalues are an exception to this rule.) These lists have no meaning
|
|
||||||
** when the invariant is not being enforced (e.g., sweep phase).
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Possible states of the Garbage Collector
|
|
||||||
*/
|
|
||||||
#define GCSpropagate 0
|
|
||||||
#define GCSenteratomic 1
|
|
||||||
#define GCSatomic 2
|
|
||||||
#define GCSswpallgc 3
|
|
||||||
#define GCSswpfinobj 4
|
|
||||||
#define GCSswptobefnz 5
|
|
||||||
#define GCSswpend 6
|
|
||||||
#define GCScallfin 7
|
|
||||||
#define GCSpause 8
|
|
||||||
|
|
||||||
|
|
||||||
#define issweepphase(g) \
|
|
||||||
(GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** macro to tell when main invariant (white objects cannot point to black
|
|
||||||
** ones) must be kept. During a collection, the sweep
|
|
||||||
** phase may break the invariant, as objects turned white may point to
|
|
||||||
** still-black objects. The invariant is restored when sweep ends and
|
|
||||||
** all objects are white again.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define keepinvariant(g) ((g)->gcstate <= GCSatomic)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** some useful bit tricks
|
|
||||||
*/
|
|
||||||
#define resetbits(x,m) ((x) &= cast_byte(~(m)))
|
|
||||||
#define setbits(x,m) ((x) |= (m))
|
|
||||||
#define testbits(x,m) ((x) & (m))
|
|
||||||
#define bitmask(b) (1<<(b))
|
|
||||||
#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
|
|
||||||
#define l_setbit(x,b) setbits(x, bitmask(b))
|
|
||||||
#define resetbit(x,b) resetbits(x, bitmask(b))
|
|
||||||
#define testbit(x,b) testbits(x, bitmask(b))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Layout for bit use in 'marked' field. First three bits are
|
|
||||||
** used for object "age" in generational mode. Last bit is used
|
|
||||||
** by tests.
|
|
||||||
*/
|
|
||||||
#define WHITE0BIT 3 /* object is white (type 0) */
|
|
||||||
#define WHITE1BIT 4 /* object is white (type 1) */
|
|
||||||
#define BLACKBIT 5 /* object is black */
|
|
||||||
#define FINALIZEDBIT 6 /* object has been marked for finalization */
|
|
||||||
|
|
||||||
#define TESTBIT 7
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
|
|
||||||
|
|
||||||
|
|
||||||
#define iswhite(x) testbits((x)->marked, WHITEBITS)
|
|
||||||
#define isblack(x) testbit((x)->marked, BLACKBIT)
|
|
||||||
#define isgray(x) /* neither white nor black */ \
|
|
||||||
(!testbits((x)->marked, WHITEBITS | bitmask(BLACKBIT)))
|
|
||||||
|
|
||||||
#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT)
|
|
||||||
|
|
||||||
#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS)
|
|
||||||
#define isdeadm(ow,m) ((m) & (ow))
|
|
||||||
#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked)
|
|
||||||
|
|
||||||
#define changewhite(x) ((x)->marked ^= WHITEBITS)
|
|
||||||
#define nw2black(x) \
|
|
||||||
check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT))
|
|
||||||
|
|
||||||
#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS)
|
|
||||||
|
|
||||||
|
|
||||||
/* object age in generational mode */
|
|
||||||
#define G_NEW 0 /* created in current cycle */
|
|
||||||
#define G_SURVIVAL 1 /* created in previous cycle */
|
|
||||||
#define G_OLD0 2 /* marked old by frw. barrier in this cycle */
|
|
||||||
#define G_OLD1 3 /* first full cycle as old */
|
|
||||||
#define G_OLD 4 /* really old object (not to be visited) */
|
|
||||||
#define G_TOUCHED1 5 /* old object touched this cycle */
|
|
||||||
#define G_TOUCHED2 6 /* old object touched in previous cycle */
|
|
||||||
|
|
||||||
#define AGEBITS 7 /* all age bits (111) */
|
|
||||||
|
|
||||||
#define getage(o) ((o)->marked & AGEBITS)
|
|
||||||
#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a))
|
|
||||||
#define isold(o) (getage(o) > G_SURVIVAL)
|
|
||||||
|
|
||||||
#define changeage(o,f,t) \
|
|
||||||
check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t)))
|
|
||||||
|
|
||||||
|
|
||||||
/* Default Values for GC parameters */
|
|
||||||
#define LUAI_GENMAJORMUL 100
|
|
||||||
#define LUAI_GENMINORMUL 20
|
|
||||||
|
|
||||||
/* wait memory to double before starting new cycle */
|
|
||||||
#define LUAI_GCPAUSE 200
|
|
||||||
|
|
||||||
/*
|
|
||||||
** some gc parameters are stored divided by 4 to allow a maximum value
|
|
||||||
** up to 1023 in a 'lu_byte'.
|
|
||||||
*/
|
|
||||||
#define getgcparam(p) ((p) * 4)
|
|
||||||
#define setgcparam(p,v) ((p) = (v) / 4)
|
|
||||||
|
|
||||||
#define LUAI_GCMUL 100
|
|
||||||
|
|
||||||
/* how much to allocate before next GC step (log2) */
|
|
||||||
#define LUAI_GCSTEPSIZE 13 /* 8 KB */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether the declared GC mode is generational. While in
|
|
||||||
** generational mode, the collector can go temporarily to incremental
|
|
||||||
** mode to improve performance. This is signaled by 'g->lastatomic != 0'.
|
|
||||||
*/
|
|
||||||
#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Control when GC is running:
|
|
||||||
*/
|
|
||||||
#define GCSTPUSR 1 /* bit true when GC stopped by user */
|
|
||||||
#define GCSTPGC 2 /* bit true when GC stopped by itself */
|
|
||||||
#define GCSTPCLS 4 /* bit true when closing Lua state */
|
|
||||||
#define gcrunning(g) ((g)->gcstp == 0)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Does one step of collection when debt becomes positive. 'pre'/'pos'
|
|
||||||
** allows some adjustments to be done only when needed. macro
|
|
||||||
** 'condchangemem' is used only for heavy tests (forcing a full
|
|
||||||
** GC cycle on every opportunity)
|
|
||||||
*/
|
|
||||||
#define luaC_condGC(L,pre,pos) \
|
|
||||||
{ if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \
|
|
||||||
condchangemem(L,pre,pos); }
|
|
||||||
|
|
||||||
/* more often than not, 'pre'/'pos' are empty */
|
|
||||||
#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0)
|
|
||||||
|
|
||||||
|
|
||||||
#define luaC_objbarrier(L,p,o) ( \
|
|
||||||
(isblack(p) && iswhite(o)) ? \
|
|
||||||
luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
|
|
||||||
|
|
||||||
#define luaC_barrier(L,p,v) ( \
|
|
||||||
iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0))
|
|
||||||
|
|
||||||
#define luaC_objbarrierback(L,p,o) ( \
|
|
||||||
(isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0))
|
|
||||||
|
|
||||||
#define luaC_barrierback(L,p,v) ( \
|
|
||||||
iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0))
|
|
||||||
|
|
||||||
LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
|
|
||||||
LUAI_FUNC void luaC_freeallobjects (lua_State *L);
|
|
||||||
LUAI_FUNC void luaC_step (lua_State *L);
|
|
||||||
LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
|
|
||||||
LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
|
|
||||||
LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
|
|
||||||
LUAI_FUNC GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz,
|
|
||||||
size_t offset);
|
|
||||||
LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
|
|
||||||
LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
|
|
||||||
LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
|
|
||||||
LUAI_FUNC void luaC_changemode (lua_State *L, int newmode);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,65 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: linit.c $
|
|
||||||
** Initialization of libraries for lua.c and other clients
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#define linit_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
/*
|
|
||||||
** If you embed Lua in your program and need to open the standard
|
|
||||||
** libraries, call luaL_openlibs in your program. If you need a
|
|
||||||
** different set of libraries, copy this file to your project and edit
|
|
||||||
** it to suit your needs.
|
|
||||||
**
|
|
||||||
** You can also *preload* libraries, so that a later 'require' can
|
|
||||||
** open the library, which is already linked to the application.
|
|
||||||
** For that, do the following code:
|
|
||||||
**
|
|
||||||
** luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
|
|
||||||
** lua_pushcfunction(L, luaopen_modname);
|
|
||||||
** lua_setfield(L, -2, modname);
|
|
||||||
** lua_pop(L, 1); // remove PRELOAD table
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lualib.h"
|
|
||||||
#include "lauxlib.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** these libs are loaded by lua.c and are readily available to any Lua
|
|
||||||
** program
|
|
||||||
*/
|
|
||||||
static const luaL_Reg loadedlibs[] = {
|
|
||||||
{LUA_GNAME, luaopen_base},
|
|
||||||
{LUA_LOADLIBNAME, luaopen_package},
|
|
||||||
{LUA_COLIBNAME, luaopen_coroutine},
|
|
||||||
{LUA_TABLIBNAME, luaopen_table},
|
|
||||||
{LUA_IOLIBNAME, luaopen_io},
|
|
||||||
{LUA_OSLIBNAME, luaopen_os},
|
|
||||||
{LUA_STRLIBNAME, luaopen_string},
|
|
||||||
{LUA_MATHLIBNAME, luaopen_math},
|
|
||||||
{LUA_UTF8LIBNAME, luaopen_utf8},
|
|
||||||
{LUA_DBLIBNAME, luaopen_debug},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
LUALIB_API void luaL_openlibs (lua_State *L) {
|
|
||||||
const luaL_Reg *lib;
|
|
||||||
/* "require" functions from 'loadedlibs' and set results to global table */
|
|
||||||
for (lib = loadedlibs; lib->func; lib++) {
|
|
||||||
luaL_requiref(L, lib->name, lib->func, 1);
|
|
||||||
lua_pop(L, 1); /* remove lib */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,828 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: liolib.c $
|
|
||||||
** Standard I/O (and system) library
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define liolib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <ctype.h>
|
|
||||||
#include <errno.h>
|
|
||||||
#include <locale.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Change this macro to accept other modes for 'fopen' besides
|
|
||||||
** the standard ones.
|
|
||||||
*/
|
|
||||||
#if !defined(l_checkmode)
|
|
||||||
|
|
||||||
/* accepted extensions to 'mode' in 'fopen' */
|
|
||||||
#if !defined(L_MODEEXT)
|
|
||||||
#define L_MODEEXT "b"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* Check whether 'mode' matches '[rwa]%+?[L_MODEEXT]*' */
|
|
||||||
static int l_checkmode (const char *mode) {
|
|
||||||
return (*mode != '\0' && strchr("rwa", *(mode++)) != NULL &&
|
|
||||||
(*mode != '+' || ((void)(++mode), 1)) && /* skip if char is '+' */
|
|
||||||
(strspn(mode, L_MODEEXT) == strlen(mode))); /* check extensions */
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** l_popen spawns a new process connected to the current
|
|
||||||
** one through the file streams.
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if !defined(l_popen) /* { */
|
|
||||||
|
|
||||||
#if defined(LUA_USE_POSIX) /* { */
|
|
||||||
|
|
||||||
#define l_popen(L,c,m) (fflush(NULL), popen(c,m))
|
|
||||||
#define l_pclose(L,file) (pclose(file))
|
|
||||||
|
|
||||||
#elif defined(LUA_USE_WINDOWS) /* }{ */
|
|
||||||
|
|
||||||
#define l_popen(L,c,m) (_popen(c,m))
|
|
||||||
#define l_pclose(L,file) (_pclose(file))
|
|
||||||
|
|
||||||
#if !defined(l_checkmodep)
|
|
||||||
/* Windows accepts "[rw][bt]?" as valid modes */
|
|
||||||
#define l_checkmodep(m) ((m[0] == 'r' || m[0] == 'w') && \
|
|
||||||
(m[1] == '\0' || ((m[1] == 'b' || m[1] == 't') && m[2] == '\0')))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
/* ISO C definitions */
|
|
||||||
#define l_popen(L,c,m) \
|
|
||||||
((void)c, (void)m, \
|
|
||||||
luaL_error(L, "'popen' not supported"), \
|
|
||||||
(FILE*)0)
|
|
||||||
#define l_pclose(L,file) ((void)L, (void)file, -1)
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
#if !defined(l_checkmodep)
|
|
||||||
/* By default, Lua accepts only "r" or "w" as valid modes */
|
|
||||||
#define l_checkmodep(m) ((m[0] == 'r' || m[0] == 'w') && m[1] == '\0')
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
#if !defined(l_getc) /* { */
|
|
||||||
|
|
||||||
#if defined(LUA_USE_POSIX)
|
|
||||||
#define l_getc(f) getc_unlocked(f)
|
|
||||||
#define l_lockfile(f) flockfile(f)
|
|
||||||
#define l_unlockfile(f) funlockfile(f)
|
|
||||||
#else
|
|
||||||
#define l_getc(f) getc(f)
|
|
||||||
#define l_lockfile(f) ((void)0)
|
|
||||||
#define l_unlockfile(f) ((void)0)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** l_fseek: configuration for longer offsets
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if !defined(l_fseek) /* { */
|
|
||||||
|
|
||||||
#if defined(LUA_USE_POSIX) /* { */
|
|
||||||
|
|
||||||
#include <sys/types.h>
|
|
||||||
|
|
||||||
#define l_fseek(f,o,w) fseeko(f,o,w)
|
|
||||||
#define l_ftell(f) ftello(f)
|
|
||||||
#define l_seeknum off_t
|
|
||||||
|
|
||||||
#elif defined(LUA_USE_WINDOWS) && !defined(_CRTIMP_TYPEINFO) \
|
|
||||||
&& defined(_MSC_VER) && (_MSC_VER >= 1400) /* }{ */
|
|
||||||
|
|
||||||
/* Windows (but not DDK) and Visual C++ 2005 or higher */
|
|
||||||
#define l_fseek(f,o,w) _fseeki64(f,o,w)
|
|
||||||
#define l_ftell(f) _ftelli64(f)
|
|
||||||
#define l_seeknum __int64
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
/* ISO C definitions */
|
|
||||||
#define l_fseek(f,o,w) fseek(f,o,w)
|
|
||||||
#define l_ftell(f) ftell(f)
|
|
||||||
#define l_seeknum long
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define IO_PREFIX "_IO_"
|
|
||||||
#define IOPREF_LEN (sizeof(IO_PREFIX)/sizeof(char) - 1)
|
|
||||||
#define IO_INPUT (IO_PREFIX "input")
|
|
||||||
#define IO_OUTPUT (IO_PREFIX "output")
|
|
||||||
|
|
||||||
|
|
||||||
typedef luaL_Stream LStream;
|
|
||||||
|
|
||||||
|
|
||||||
#define tolstream(L) ((LStream *)luaL_checkudata(L, 1, LUA_FILEHANDLE))
|
|
||||||
|
|
||||||
#define isclosed(p) ((p)->closef == NULL)
|
|
||||||
|
|
||||||
|
|
||||||
static int io_type (lua_State *L) {
|
|
||||||
LStream *p;
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
p = (LStream *)luaL_testudata(L, 1, LUA_FILEHANDLE);
|
|
||||||
if (p == NULL)
|
|
||||||
luaL_pushfail(L); /* not a file */
|
|
||||||
else if (isclosed(p))
|
|
||||||
lua_pushliteral(L, "closed file");
|
|
||||||
else
|
|
||||||
lua_pushliteral(L, "file");
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_tostring (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
if (isclosed(p))
|
|
||||||
lua_pushliteral(L, "file (closed)");
|
|
||||||
else
|
|
||||||
lua_pushfstring(L, "file (%p)", p->f);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static FILE *tofile (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
if (l_unlikely(isclosed(p)))
|
|
||||||
luaL_error(L, "attempt to use a closed file");
|
|
||||||
lua_assert(p->f);
|
|
||||||
return p->f;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** When creating file handles, always creates a 'closed' file handle
|
|
||||||
** before opening the actual file; so, if there is a memory error, the
|
|
||||||
** handle is in a consistent state.
|
|
||||||
*/
|
|
||||||
static LStream *newprefile (lua_State *L) {
|
|
||||||
LStream *p = (LStream *)lua_newuserdatauv(L, sizeof(LStream), 0);
|
|
||||||
p->closef = NULL; /* mark file handle as 'closed' */
|
|
||||||
luaL_setmetatable(L, LUA_FILEHANDLE);
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Calls the 'close' function from a file handle. The 'volatile' avoids
|
|
||||||
** a bug in some versions of the Clang compiler (e.g., clang 3.0 for
|
|
||||||
** 32 bits).
|
|
||||||
*/
|
|
||||||
static int aux_close (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
volatile lua_CFunction cf = p->closef;
|
|
||||||
p->closef = NULL; /* mark stream as closed */
|
|
||||||
return (*cf)(L); /* close it */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_close (lua_State *L) {
|
|
||||||
tofile(L); /* make sure argument is an open stream */
|
|
||||||
return aux_close(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_close (lua_State *L) {
|
|
||||||
if (lua_isnone(L, 1)) /* no argument? */
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT); /* use default output */
|
|
||||||
return f_close(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_gc (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
if (!isclosed(p) && p->f != NULL)
|
|
||||||
aux_close(L); /* ignore closed and incompletely open files */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** function to close regular files
|
|
||||||
*/
|
|
||||||
static int io_fclose (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
int res = fclose(p->f);
|
|
||||||
return luaL_fileresult(L, (res == 0), NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static LStream *newfile (lua_State *L) {
|
|
||||||
LStream *p = newprefile(L);
|
|
||||||
p->f = NULL;
|
|
||||||
p->closef = &io_fclose;
|
|
||||||
return p;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void opencheck (lua_State *L, const char *fname, const char *mode) {
|
|
||||||
LStream *p = newfile(L);
|
|
||||||
p->f = fopen(fname, mode);
|
|
||||||
if (l_unlikely(p->f == NULL))
|
|
||||||
luaL_error(L, "cannot open file '%s' (%s)", fname, strerror(errno));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_open (lua_State *L) {
|
|
||||||
const char *filename = luaL_checkstring(L, 1);
|
|
||||||
const char *mode = luaL_optstring(L, 2, "r");
|
|
||||||
LStream *p = newfile(L);
|
|
||||||
const char *md = mode; /* to traverse/check mode */
|
|
||||||
luaL_argcheck(L, l_checkmode(md), 2, "invalid mode");
|
|
||||||
p->f = fopen(filename, mode);
|
|
||||||
return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** function to close 'popen' files
|
|
||||||
*/
|
|
||||||
static int io_pclose (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
errno = 0;
|
|
||||||
return luaL_execresult(L, l_pclose(L, p->f));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_popen (lua_State *L) {
|
|
||||||
const char *filename = luaL_checkstring(L, 1);
|
|
||||||
const char *mode = luaL_optstring(L, 2, "r");
|
|
||||||
LStream *p = newprefile(L);
|
|
||||||
luaL_argcheck(L, l_checkmodep(mode), 2, "invalid mode");
|
|
||||||
p->f = l_popen(L, filename, mode);
|
|
||||||
p->closef = &io_pclose;
|
|
||||||
return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_tmpfile (lua_State *L) {
|
|
||||||
LStream *p = newfile(L);
|
|
||||||
p->f = tmpfile();
|
|
||||||
return (p->f == NULL) ? luaL_fileresult(L, 0, NULL) : 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static FILE *getiofile (lua_State *L, const char *findex) {
|
|
||||||
LStream *p;
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, findex);
|
|
||||||
p = (LStream *)lua_touserdata(L, -1);
|
|
||||||
if (l_unlikely(isclosed(p)))
|
|
||||||
luaL_error(L, "default %s file is closed", findex + IOPREF_LEN);
|
|
||||||
return p->f;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int g_iofile (lua_State *L, const char *f, const char *mode) {
|
|
||||||
if (!lua_isnoneornil(L, 1)) {
|
|
||||||
const char *filename = lua_tostring(L, 1);
|
|
||||||
if (filename)
|
|
||||||
opencheck(L, filename, mode);
|
|
||||||
else {
|
|
||||||
tofile(L); /* check that it's a valid file handle */
|
|
||||||
lua_pushvalue(L, 1);
|
|
||||||
}
|
|
||||||
lua_setfield(L, LUA_REGISTRYINDEX, f);
|
|
||||||
}
|
|
||||||
/* return current value */
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, f);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_input (lua_State *L) {
|
|
||||||
return g_iofile(L, IO_INPUT, "r");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_output (lua_State *L) {
|
|
||||||
return g_iofile(L, IO_OUTPUT, "w");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_readline (lua_State *L);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** maximum number of arguments to 'f:lines'/'io.lines' (it + 3 must fit
|
|
||||||
** in the limit for upvalues of a closure)
|
|
||||||
*/
|
|
||||||
#define MAXARGLINE 250
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Auxiliary function to create the iteration function for 'lines'.
|
|
||||||
** The iteration function is a closure over 'io_readline', with
|
|
||||||
** the following upvalues:
|
|
||||||
** 1) The file being read (first value in the stack)
|
|
||||||
** 2) the number of arguments to read
|
|
||||||
** 3) a boolean, true iff file has to be closed when finished ('toclose')
|
|
||||||
** *) a variable number of format arguments (rest of the stack)
|
|
||||||
*/
|
|
||||||
static void aux_lines (lua_State *L, int toclose) {
|
|
||||||
int n = lua_gettop(L) - 1; /* number of arguments to read */
|
|
||||||
luaL_argcheck(L, n <= MAXARGLINE, MAXARGLINE + 2, "too many arguments");
|
|
||||||
lua_pushvalue(L, 1); /* file */
|
|
||||||
lua_pushinteger(L, n); /* number of arguments to read */
|
|
||||||
lua_pushboolean(L, toclose); /* close/not close file when finished */
|
|
||||||
lua_rotate(L, 2, 3); /* move the three values to their positions */
|
|
||||||
lua_pushcclosure(L, io_readline, 3 + n);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_lines (lua_State *L) {
|
|
||||||
tofile(L); /* check that it's a valid file handle */
|
|
||||||
aux_lines(L, 0);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Return an iteration function for 'io.lines'. If file has to be
|
|
||||||
** closed, also returns the file itself as a second result (to be
|
|
||||||
** closed as the state at the exit of a generic for).
|
|
||||||
*/
|
|
||||||
static int io_lines (lua_State *L) {
|
|
||||||
int toclose;
|
|
||||||
if (lua_isnone(L, 1)) lua_pushnil(L); /* at least one argument */
|
|
||||||
if (lua_isnil(L, 1)) { /* no file name? */
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, IO_INPUT); /* get default input */
|
|
||||||
lua_replace(L, 1); /* put it at index 1 */
|
|
||||||
tofile(L); /* check that it's a valid file handle */
|
|
||||||
toclose = 0; /* do not close it after iteration */
|
|
||||||
}
|
|
||||||
else { /* open a new file */
|
|
||||||
const char *filename = luaL_checkstring(L, 1);
|
|
||||||
opencheck(L, filename, "r");
|
|
||||||
lua_replace(L, 1); /* put file at index 1 */
|
|
||||||
toclose = 1; /* close it after iteration */
|
|
||||||
}
|
|
||||||
aux_lines(L, toclose); /* push iteration function */
|
|
||||||
if (toclose) {
|
|
||||||
lua_pushnil(L); /* state */
|
|
||||||
lua_pushnil(L); /* control */
|
|
||||||
lua_pushvalue(L, 1); /* file is the to-be-closed variable (4th result) */
|
|
||||||
return 4;
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** READ
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/* maximum length of a numeral */
|
|
||||||
#if !defined (L_MAXLENNUM)
|
|
||||||
#define L_MAXLENNUM 200
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/* auxiliary structure used by 'read_number' */
|
|
||||||
typedef struct {
|
|
||||||
FILE *f; /* file being read */
|
|
||||||
int c; /* current character (look ahead) */
|
|
||||||
int n; /* number of elements in buffer 'buff' */
|
|
||||||
char buff[L_MAXLENNUM + 1]; /* +1 for ending '\0' */
|
|
||||||
} RN;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Add current char to buffer (if not out of space) and read next one
|
|
||||||
*/
|
|
||||||
static int nextc (RN *rn) {
|
|
||||||
if (l_unlikely(rn->n >= L_MAXLENNUM)) { /* buffer overflow? */
|
|
||||||
rn->buff[0] = '\0'; /* invalidate result */
|
|
||||||
return 0; /* fail */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
rn->buff[rn->n++] = rn->c; /* save current char */
|
|
||||||
rn->c = l_getc(rn->f); /* read next one */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Accept current char if it is in 'set' (of size 2)
|
|
||||||
*/
|
|
||||||
static int test2 (RN *rn, const char *set) {
|
|
||||||
if (rn->c == set[0] || rn->c == set[1])
|
|
||||||
return nextc(rn);
|
|
||||||
else return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Read a sequence of (hex)digits
|
|
||||||
*/
|
|
||||||
static int readdigits (RN *rn, int hex) {
|
|
||||||
int count = 0;
|
|
||||||
while ((hex ? isxdigit(rn->c) : isdigit(rn->c)) && nextc(rn))
|
|
||||||
count++;
|
|
||||||
return count;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Read a number: first reads a valid prefix of a numeral into a buffer.
|
|
||||||
** Then it calls 'lua_stringtonumber' to check whether the format is
|
|
||||||
** correct and to convert it to a Lua number.
|
|
||||||
*/
|
|
||||||
static int read_number (lua_State *L, FILE *f) {
|
|
||||||
RN rn;
|
|
||||||
int count = 0;
|
|
||||||
int hex = 0;
|
|
||||||
char decp[2];
|
|
||||||
rn.f = f; rn.n = 0;
|
|
||||||
decp[0] = lua_getlocaledecpoint(); /* get decimal point from locale */
|
|
||||||
decp[1] = '.'; /* always accept a dot */
|
|
||||||
l_lockfile(rn.f);
|
|
||||||
do { rn.c = l_getc(rn.f); } while (isspace(rn.c)); /* skip spaces */
|
|
||||||
test2(&rn, "-+"); /* optional sign */
|
|
||||||
if (test2(&rn, "00")) {
|
|
||||||
if (test2(&rn, "xX")) hex = 1; /* numeral is hexadecimal */
|
|
||||||
else count = 1; /* count initial '0' as a valid digit */
|
|
||||||
}
|
|
||||||
count += readdigits(&rn, hex); /* integral part */
|
|
||||||
if (test2(&rn, decp)) /* decimal point? */
|
|
||||||
count += readdigits(&rn, hex); /* fractional part */
|
|
||||||
if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) { /* exponent mark? */
|
|
||||||
test2(&rn, "-+"); /* exponent sign */
|
|
||||||
readdigits(&rn, 0); /* exponent digits */
|
|
||||||
}
|
|
||||||
ungetc(rn.c, rn.f); /* unread look-ahead char */
|
|
||||||
l_unlockfile(rn.f);
|
|
||||||
rn.buff[rn.n] = '\0'; /* finish string */
|
|
||||||
if (l_likely(lua_stringtonumber(L, rn.buff)))
|
|
||||||
return 1; /* ok, it is a valid number */
|
|
||||||
else { /* invalid format */
|
|
||||||
lua_pushnil(L); /* "result" to be removed */
|
|
||||||
return 0; /* read fails */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int test_eof (lua_State *L, FILE *f) {
|
|
||||||
int c = getc(f);
|
|
||||||
ungetc(c, f); /* no-op when c == EOF */
|
|
||||||
lua_pushliteral(L, "");
|
|
||||||
return (c != EOF);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int read_line (lua_State *L, FILE *f, int chop) {
|
|
||||||
luaL_Buffer b;
|
|
||||||
int c;
|
|
||||||
luaL_buffinit(L, &b);
|
|
||||||
do { /* may need to read several chunks to get whole line */
|
|
||||||
char *buff = luaL_prepbuffer(&b); /* preallocate buffer space */
|
|
||||||
int i = 0;
|
|
||||||
l_lockfile(f); /* no memory errors can happen inside the lock */
|
|
||||||
while (i < LUAL_BUFFERSIZE && (c = l_getc(f)) != EOF && c != '\n')
|
|
||||||
buff[i++] = c; /* read up to end of line or buffer limit */
|
|
||||||
l_unlockfile(f);
|
|
||||||
luaL_addsize(&b, i);
|
|
||||||
} while (c != EOF && c != '\n'); /* repeat until end of line */
|
|
||||||
if (!chop && c == '\n') /* want a newline and have one? */
|
|
||||||
luaL_addchar(&b, c); /* add ending newline to result */
|
|
||||||
luaL_pushresult(&b); /* close buffer */
|
|
||||||
/* return ok if read something (either a newline or something else) */
|
|
||||||
return (c == '\n' || lua_rawlen(L, -1) > 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void read_all (lua_State *L, FILE *f) {
|
|
||||||
size_t nr;
|
|
||||||
luaL_Buffer b;
|
|
||||||
luaL_buffinit(L, &b);
|
|
||||||
do { /* read file in chunks of LUAL_BUFFERSIZE bytes */
|
|
||||||
char *p = luaL_prepbuffer(&b);
|
|
||||||
nr = fread(p, sizeof(char), LUAL_BUFFERSIZE, f);
|
|
||||||
luaL_addsize(&b, nr);
|
|
||||||
} while (nr == LUAL_BUFFERSIZE);
|
|
||||||
luaL_pushresult(&b); /* close buffer */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int read_chars (lua_State *L, FILE *f, size_t n) {
|
|
||||||
size_t nr; /* number of chars actually read */
|
|
||||||
char *p;
|
|
||||||
luaL_Buffer b;
|
|
||||||
luaL_buffinit(L, &b);
|
|
||||||
p = luaL_prepbuffsize(&b, n); /* prepare buffer to read whole block */
|
|
||||||
nr = fread(p, sizeof(char), n, f); /* try to read 'n' chars */
|
|
||||||
luaL_addsize(&b, nr);
|
|
||||||
luaL_pushresult(&b); /* close buffer */
|
|
||||||
return (nr > 0); /* true iff read something */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int g_read (lua_State *L, FILE *f, int first) {
|
|
||||||
int nargs = lua_gettop(L) - 1;
|
|
||||||
int n, success;
|
|
||||||
clearerr(f);
|
|
||||||
if (nargs == 0) { /* no arguments? */
|
|
||||||
success = read_line(L, f, 1);
|
|
||||||
n = first + 1; /* to return 1 result */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
/* ensure stack space for all results and for auxlib's buffer */
|
|
||||||
luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
|
|
||||||
success = 1;
|
|
||||||
for (n = first; nargs-- && success; n++) {
|
|
||||||
if (lua_type(L, n) == LUA_TNUMBER) {
|
|
||||||
size_t l = (size_t)luaL_checkinteger(L, n);
|
|
||||||
success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
const char *p = luaL_checkstring(L, n);
|
|
||||||
if (*p == '*') p++; /* skip optional '*' (for compatibility) */
|
|
||||||
switch (*p) {
|
|
||||||
case 'n': /* number */
|
|
||||||
success = read_number(L, f);
|
|
||||||
break;
|
|
||||||
case 'l': /* line */
|
|
||||||
success = read_line(L, f, 1);
|
|
||||||
break;
|
|
||||||
case 'L': /* line with end-of-line */
|
|
||||||
success = read_line(L, f, 0);
|
|
||||||
break;
|
|
||||||
case 'a': /* file */
|
|
||||||
read_all(L, f); /* read entire file */
|
|
||||||
success = 1; /* always success */
|
|
||||||
break;
|
|
||||||
default:
|
|
||||||
return luaL_argerror(L, n, "invalid format");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (ferror(f))
|
|
||||||
return luaL_fileresult(L, 0, NULL);
|
|
||||||
if (!success) {
|
|
||||||
lua_pop(L, 1); /* remove last result */
|
|
||||||
luaL_pushfail(L); /* push nil instead */
|
|
||||||
}
|
|
||||||
return n - first;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_read (lua_State *L) {
|
|
||||||
return g_read(L, getiofile(L, IO_INPUT), 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_read (lua_State *L) {
|
|
||||||
return g_read(L, tofile(L), 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Iteration function for 'lines'.
|
|
||||||
*/
|
|
||||||
static int io_readline (lua_State *L) {
|
|
||||||
LStream *p = (LStream *)lua_touserdata(L, lua_upvalueindex(1));
|
|
||||||
int i;
|
|
||||||
int n = (int)lua_tointeger(L, lua_upvalueindex(2));
|
|
||||||
if (isclosed(p)) /* file is already closed? */
|
|
||||||
return luaL_error(L, "file is already closed");
|
|
||||||
lua_settop(L , 1);
|
|
||||||
luaL_checkstack(L, n, "too many arguments");
|
|
||||||
for (i = 1; i <= n; i++) /* push arguments to 'g_read' */
|
|
||||||
lua_pushvalue(L, lua_upvalueindex(3 + i));
|
|
||||||
n = g_read(L, p->f, 2); /* 'n' is number of results */
|
|
||||||
lua_assert(n > 0); /* should return at least a nil */
|
|
||||||
if (lua_toboolean(L, -n)) /* read at least one value? */
|
|
||||||
return n; /* return them */
|
|
||||||
else { /* first result is false: EOF or error */
|
|
||||||
if (n > 1) { /* is there error information? */
|
|
||||||
/* 2nd result is error message */
|
|
||||||
return luaL_error(L, "%s", lua_tostring(L, -n + 1));
|
|
||||||
}
|
|
||||||
if (lua_toboolean(L, lua_upvalueindex(3))) { /* generator created file? */
|
|
||||||
lua_settop(L, 0); /* clear stack */
|
|
||||||
lua_pushvalue(L, lua_upvalueindex(1)); /* push file at index 1 */
|
|
||||||
aux_close(L); /* close it */
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
static int g_write (lua_State *L, FILE *f, int arg) {
|
|
||||||
int nargs = lua_gettop(L) - arg;
|
|
||||||
int status = 1;
|
|
||||||
for (; nargs--; arg++) {
|
|
||||||
if (lua_type(L, arg) == LUA_TNUMBER) {
|
|
||||||
/* optimization: could be done exactly as for strings */
|
|
||||||
int len = lua_isinteger(L, arg)
|
|
||||||
? fprintf(f, LUA_INTEGER_FMT,
|
|
||||||
(LUAI_UACINT)lua_tointeger(L, arg))
|
|
||||||
: fprintf(f, LUA_NUMBER_FMT,
|
|
||||||
(LUAI_UACNUMBER)lua_tonumber(L, arg));
|
|
||||||
status = status && (len > 0);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
size_t l;
|
|
||||||
const char *s = luaL_checklstring(L, arg, &l);
|
|
||||||
status = status && (fwrite(s, sizeof(char), l, f) == l);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
if (l_likely(status))
|
|
||||||
return 1; /* file handle already on stack top */
|
|
||||||
else return luaL_fileresult(L, status, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int io_write (lua_State *L) {
|
|
||||||
return g_write(L, getiofile(L, IO_OUTPUT), 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_write (lua_State *L) {
|
|
||||||
FILE *f = tofile(L);
|
|
||||||
lua_pushvalue(L, 1); /* push file at the stack top (to be returned) */
|
|
||||||
return g_write(L, f, 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_seek (lua_State *L) {
|
|
||||||
static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
|
|
||||||
static const char *const modenames[] = {"set", "cur", "end", NULL};
|
|
||||||
FILE *f = tofile(L);
|
|
||||||
int op = luaL_checkoption(L, 2, "cur", modenames);
|
|
||||||
lua_Integer p3 = luaL_optinteger(L, 3, 0);
|
|
||||||
l_seeknum offset = (l_seeknum)p3;
|
|
||||||
luaL_argcheck(L, (lua_Integer)offset == p3, 3,
|
|
||||||
"not an integer in proper range");
|
|
||||||
op = l_fseek(f, offset, mode[op]);
|
|
||||||
if (l_unlikely(op))
|
|
||||||
return luaL_fileresult(L, 0, NULL); /* error */
|
|
||||||
else {
|
|
||||||
lua_pushinteger(L, (lua_Integer)l_ftell(f));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_setvbuf (lua_State *L) {
|
|
||||||
static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
|
|
||||||
static const char *const modenames[] = {"no", "full", "line", NULL};
|
|
||||||
FILE *f = tofile(L);
|
|
||||||
int op = luaL_checkoption(L, 2, NULL, modenames);
|
|
||||||
lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
|
|
||||||
int res = setvbuf(f, NULL, mode[op], (size_t)sz);
|
|
||||||
return luaL_fileresult(L, res == 0, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
static int io_flush (lua_State *L) {
|
|
||||||
return luaL_fileresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int f_flush (lua_State *L) {
|
|
||||||
return luaL_fileresult(L, fflush(tofile(L)) == 0, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** functions for 'io' library
|
|
||||||
*/
|
|
||||||
static const luaL_Reg iolib[] = {
|
|
||||||
{"close", io_close},
|
|
||||||
{"flush", io_flush},
|
|
||||||
{"input", io_input},
|
|
||||||
{"lines", io_lines},
|
|
||||||
{"open", io_open},
|
|
||||||
{"output", io_output},
|
|
||||||
{"popen", io_popen},
|
|
||||||
{"read", io_read},
|
|
||||||
{"tmpfile", io_tmpfile},
|
|
||||||
{"type", io_type},
|
|
||||||
{"write", io_write},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** methods for file handles
|
|
||||||
*/
|
|
||||||
static const luaL_Reg meth[] = {
|
|
||||||
{"read", f_read},
|
|
||||||
{"write", f_write},
|
|
||||||
{"lines", f_lines},
|
|
||||||
{"flush", f_flush},
|
|
||||||
{"seek", f_seek},
|
|
||||||
{"close", f_close},
|
|
||||||
{"setvbuf", f_setvbuf},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** metamethods for file handles
|
|
||||||
*/
|
|
||||||
static const luaL_Reg metameth[] = {
|
|
||||||
{"__index", NULL}, /* place holder */
|
|
||||||
{"__gc", f_gc},
|
|
||||||
{"__close", f_gc},
|
|
||||||
{"__tostring", f_tostring},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
static void createmeta (lua_State *L) {
|
|
||||||
luaL_newmetatable(L, LUA_FILEHANDLE); /* metatable for file handles */
|
|
||||||
luaL_setfuncs(L, metameth, 0); /* add metamethods to new metatable */
|
|
||||||
luaL_newlibtable(L, meth); /* create method table */
|
|
||||||
luaL_setfuncs(L, meth, 0); /* add file methods to method table */
|
|
||||||
lua_setfield(L, -2, "__index"); /* metatable.__index = method table */
|
|
||||||
lua_pop(L, 1); /* pop metatable */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** function to (not) close the standard files stdin, stdout, and stderr
|
|
||||||
*/
|
|
||||||
static int io_noclose (lua_State *L) {
|
|
||||||
LStream *p = tolstream(L);
|
|
||||||
p->closef = &io_noclose; /* keep file opened */
|
|
||||||
luaL_pushfail(L);
|
|
||||||
lua_pushliteral(L, "cannot close standard file");
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void createstdfile (lua_State *L, FILE *f, const char *k,
|
|
||||||
const char *fname) {
|
|
||||||
LStream *p = newprefile(L);
|
|
||||||
p->f = f;
|
|
||||||
p->closef = &io_noclose;
|
|
||||||
if (k != NULL) {
|
|
||||||
lua_pushvalue(L, -1);
|
|
||||||
lua_setfield(L, LUA_REGISTRYINDEX, k); /* add file to registry */
|
|
||||||
}
|
|
||||||
lua_setfield(L, -2, fname); /* add file to module */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_io (lua_State *L) {
|
|
||||||
luaL_newlib(L, iolib); /* new module */
|
|
||||||
createmeta(L);
|
|
||||||
/* create (and set) default files */
|
|
||||||
createstdfile(L, stdin, IO_INPUT, "stdin");
|
|
||||||
createstdfile(L, stdout, IO_OUTPUT, "stdout");
|
|
||||||
createstdfile(L, stderr, NULL, "stderr");
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,112 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: ljumptab.h $
|
|
||||||
** Jump Table for the Lua interpreter
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#undef vmdispatch
|
|
||||||
#undef vmcase
|
|
||||||
#undef vmbreak
|
|
||||||
|
|
||||||
#define vmdispatch(x) goto *disptab[x];
|
|
||||||
|
|
||||||
#define vmcase(l) L_##l:
|
|
||||||
|
|
||||||
#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i));
|
|
||||||
|
|
||||||
|
|
||||||
static const void *const disptab[NUM_OPCODES] = {
|
|
||||||
|
|
||||||
#if 0
|
|
||||||
** you can update the following list with this command:
|
|
||||||
**
|
|
||||||
** sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p' lopcodes.h
|
|
||||||
**
|
|
||||||
#endif
|
|
||||||
|
|
||||||
&&L_OP_MOVE,
|
|
||||||
&&L_OP_LOADI,
|
|
||||||
&&L_OP_LOADF,
|
|
||||||
&&L_OP_LOADK,
|
|
||||||
&&L_OP_LOADKX,
|
|
||||||
&&L_OP_LOADFALSE,
|
|
||||||
&&L_OP_LFALSESKIP,
|
|
||||||
&&L_OP_LOADTRUE,
|
|
||||||
&&L_OP_LOADNIL,
|
|
||||||
&&L_OP_GETUPVAL,
|
|
||||||
&&L_OP_SETUPVAL,
|
|
||||||
&&L_OP_GETTABUP,
|
|
||||||
&&L_OP_GETTABLE,
|
|
||||||
&&L_OP_GETI,
|
|
||||||
&&L_OP_GETFIELD,
|
|
||||||
&&L_OP_SETTABUP,
|
|
||||||
&&L_OP_SETTABLE,
|
|
||||||
&&L_OP_SETI,
|
|
||||||
&&L_OP_SETFIELD,
|
|
||||||
&&L_OP_NEWTABLE,
|
|
||||||
&&L_OP_SELF,
|
|
||||||
&&L_OP_ADDI,
|
|
||||||
&&L_OP_ADDK,
|
|
||||||
&&L_OP_SUBK,
|
|
||||||
&&L_OP_MULK,
|
|
||||||
&&L_OP_MODK,
|
|
||||||
&&L_OP_POWK,
|
|
||||||
&&L_OP_DIVK,
|
|
||||||
&&L_OP_IDIVK,
|
|
||||||
&&L_OP_BANDK,
|
|
||||||
&&L_OP_BORK,
|
|
||||||
&&L_OP_BXORK,
|
|
||||||
&&L_OP_SHRI,
|
|
||||||
&&L_OP_SHLI,
|
|
||||||
&&L_OP_ADD,
|
|
||||||
&&L_OP_SUB,
|
|
||||||
&&L_OP_MUL,
|
|
||||||
&&L_OP_MOD,
|
|
||||||
&&L_OP_POW,
|
|
||||||
&&L_OP_DIV,
|
|
||||||
&&L_OP_IDIV,
|
|
||||||
&&L_OP_BAND,
|
|
||||||
&&L_OP_BOR,
|
|
||||||
&&L_OP_BXOR,
|
|
||||||
&&L_OP_SHL,
|
|
||||||
&&L_OP_SHR,
|
|
||||||
&&L_OP_MMBIN,
|
|
||||||
&&L_OP_MMBINI,
|
|
||||||
&&L_OP_MMBINK,
|
|
||||||
&&L_OP_UNM,
|
|
||||||
&&L_OP_BNOT,
|
|
||||||
&&L_OP_NOT,
|
|
||||||
&&L_OP_LEN,
|
|
||||||
&&L_OP_CONCAT,
|
|
||||||
&&L_OP_CLOSE,
|
|
||||||
&&L_OP_TBC,
|
|
||||||
&&L_OP_JMP,
|
|
||||||
&&L_OP_EQ,
|
|
||||||
&&L_OP_LT,
|
|
||||||
&&L_OP_LE,
|
|
||||||
&&L_OP_EQK,
|
|
||||||
&&L_OP_EQI,
|
|
||||||
&&L_OP_LTI,
|
|
||||||
&&L_OP_LEI,
|
|
||||||
&&L_OP_GTI,
|
|
||||||
&&L_OP_GEI,
|
|
||||||
&&L_OP_TEST,
|
|
||||||
&&L_OP_TESTSET,
|
|
||||||
&&L_OP_CALL,
|
|
||||||
&&L_OP_TAILCALL,
|
|
||||||
&&L_OP_RETURN,
|
|
||||||
&&L_OP_RETURN0,
|
|
||||||
&&L_OP_RETURN1,
|
|
||||||
&&L_OP_FORLOOP,
|
|
||||||
&&L_OP_FORPREP,
|
|
||||||
&&L_OP_TFORPREP,
|
|
||||||
&&L_OP_TFORCALL,
|
|
||||||
&&L_OP_TFORLOOP,
|
|
||||||
&&L_OP_SETLIST,
|
|
||||||
&&L_OP_CLOSURE,
|
|
||||||
&&L_OP_VARARG,
|
|
||||||
&&L_OP_VARARGPREP,
|
|
||||||
&&L_OP_EXTRAARG
|
|
||||||
|
|
||||||
};
|
|
||||||
@ -1,581 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: llex.c $
|
|
||||||
** Lexical Analyzer
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define llex_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <locale.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lctype.h"
|
|
||||||
#include "ldebug.h"
|
|
||||||
#include "ldo.h"
|
|
||||||
#include "lgc.h"
|
|
||||||
#include "llex.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lparser.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
#include "lstring.h"
|
|
||||||
#include "ltable.h"
|
|
||||||
#include "lzio.h"
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define next(ls) (ls->current = zgetc(ls->z))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
|
|
||||||
|
|
||||||
|
|
||||||
/* ORDER RESERVED */
|
|
||||||
static const char *const luaX_tokens [] = {
|
|
||||||
"and", "break", "do", "else", "elseif",
|
|
||||||
"end", "false", "for", "function", "goto", "if",
|
|
||||||
"in", "local", "nil", "not", "or", "repeat",
|
|
||||||
"return", "then", "true", "until", "while",
|
|
||||||
"//", "..", "...", "==", ">=", "<=", "~=",
|
|
||||||
"<<", ">>", "::", "<eof>",
|
|
||||||
"<number>", "<integer>", "<name>", "<string>"
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
#define save_and_next(ls) (save(ls, ls->current), next(ls))
|
|
||||||
|
|
||||||
|
|
||||||
static l_noret lexerror (LexState *ls, const char *msg, int token);
|
|
||||||
|
|
||||||
|
|
||||||
static void save (LexState *ls, int c) {
|
|
||||||
Mbuffer *b = ls->buff;
|
|
||||||
if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) {
|
|
||||||
size_t newsize;
|
|
||||||
if (luaZ_sizebuffer(b) >= MAX_SIZE/2)
|
|
||||||
lexerror(ls, "lexical element too long", 0);
|
|
||||||
newsize = luaZ_sizebuffer(b) * 2;
|
|
||||||
luaZ_resizebuffer(ls->L, b, newsize);
|
|
||||||
}
|
|
||||||
b->buffer[luaZ_bufflen(b)++] = cast_char(c);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaX_init (lua_State *L) {
|
|
||||||
int i;
|
|
||||||
TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */
|
|
||||||
luaC_fix(L, obj2gco(e)); /* never collect this name */
|
|
||||||
for (i=0; i<NUM_RESERVED; i++) {
|
|
||||||
TString *ts = luaS_new(L, luaX_tokens[i]);
|
|
||||||
luaC_fix(L, obj2gco(ts)); /* reserved words are never collected */
|
|
||||||
ts->extra = cast_byte(i+1); /* reserved word */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
const char *luaX_token2str (LexState *ls, int token) {
|
|
||||||
if (token < FIRST_RESERVED) { /* single-byte symbols? */
|
|
||||||
if (lisprint(token))
|
|
||||||
return luaO_pushfstring(ls->L, "'%c'", token);
|
|
||||||
else /* control character */
|
|
||||||
return luaO_pushfstring(ls->L, "'<\\%d>'", token);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
const char *s = luaX_tokens[token - FIRST_RESERVED];
|
|
||||||
if (token < TK_EOS) /* fixed format (symbols and reserved words)? */
|
|
||||||
return luaO_pushfstring(ls->L, "'%s'", s);
|
|
||||||
else /* names, strings, and numerals */
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *txtToken (LexState *ls, int token) {
|
|
||||||
switch (token) {
|
|
||||||
case TK_NAME: case TK_STRING:
|
|
||||||
case TK_FLT: case TK_INT:
|
|
||||||
save(ls, '\0');
|
|
||||||
return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff));
|
|
||||||
default:
|
|
||||||
return luaX_token2str(ls, token);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static l_noret lexerror (LexState *ls, const char *msg, int token) {
|
|
||||||
msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber);
|
|
||||||
if (token)
|
|
||||||
luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token));
|
|
||||||
luaD_throw(ls->L, LUA_ERRSYNTAX);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaX_syntaxerror (LexState *ls, const char *msg) {
|
|
||||||
lexerror(ls, msg, ls->t.token);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Creates a new string and anchors it in scanner's table so that it
|
|
||||||
** will not be collected until the end of the compilation; by that time
|
|
||||||
** it should be anchored somewhere. It also internalizes long strings,
|
|
||||||
** ensuring there is only one copy of each unique string. The table
|
|
||||||
** here is used as a set: the string enters as the key, while its value
|
|
||||||
** is irrelevant. We use the string itself as the value only because it
|
|
||||||
** is a TValue readily available. Later, the code generation can change
|
|
||||||
** this value.
|
|
||||||
*/
|
|
||||||
TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
|
|
||||||
lua_State *L = ls->L;
|
|
||||||
TString *ts = luaS_newlstr(L, str, l); /* create new string */
|
|
||||||
const TValue *o = luaH_getstr(ls->h, ts);
|
|
||||||
if (!ttisnil(o)) /* string already present? */
|
|
||||||
ts = keystrval(nodefromval(o)); /* get saved copy */
|
|
||||||
else { /* not in use yet */
|
|
||||||
TValue *stv = s2v(L->top.p++); /* reserve stack space for string */
|
|
||||||
setsvalue(L, stv, ts); /* temporarily anchor the string */
|
|
||||||
luaH_finishset(L, ls->h, stv, o, stv); /* t[string] = string */
|
|
||||||
/* table is not a metatable, so it does not need to invalidate cache */
|
|
||||||
luaC_checkGC(L);
|
|
||||||
L->top.p--; /* remove string from stack */
|
|
||||||
}
|
|
||||||
return ts;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** increment line number and skips newline sequence (any of
|
|
||||||
** \n, \r, \n\r, or \r\n)
|
|
||||||
*/
|
|
||||||
static void inclinenumber (LexState *ls) {
|
|
||||||
int old = ls->current;
|
|
||||||
lua_assert(currIsNewline(ls));
|
|
||||||
next(ls); /* skip '\n' or '\r' */
|
|
||||||
if (currIsNewline(ls) && ls->current != old)
|
|
||||||
next(ls); /* skip '\n\r' or '\r\n' */
|
|
||||||
if (++ls->linenumber >= MAX_INT)
|
|
||||||
lexerror(ls, "chunk has too many lines", 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source,
|
|
||||||
int firstchar) {
|
|
||||||
ls->t.token = 0;
|
|
||||||
ls->L = L;
|
|
||||||
ls->current = firstchar;
|
|
||||||
ls->lookahead.token = TK_EOS; /* no look-ahead token */
|
|
||||||
ls->z = z;
|
|
||||||
ls->fs = NULL;
|
|
||||||
ls->linenumber = 1;
|
|
||||||
ls->lastline = 1;
|
|
||||||
ls->source = source;
|
|
||||||
ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */
|
|
||||||
luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** =======================================================
|
|
||||||
** LEXICAL ANALYZER
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
static int check_next1 (LexState *ls, int c) {
|
|
||||||
if (ls->current == c) {
|
|
||||||
next(ls);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Check whether current char is in set 'set' (with two chars) and
|
|
||||||
** saves it
|
|
||||||
*/
|
|
||||||
static int check_next2 (LexState *ls, const char *set) {
|
|
||||||
lua_assert(set[2] == '\0');
|
|
||||||
if (ls->current == set[0] || ls->current == set[1]) {
|
|
||||||
save_and_next(ls);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* LUA_NUMBER */
|
|
||||||
/*
|
|
||||||
** This function is quite liberal in what it accepts, as 'luaO_str2num'
|
|
||||||
** will reject ill-formed numerals. Roughly, it accepts the following
|
|
||||||
** pattern:
|
|
||||||
**
|
|
||||||
** %d(%x|%.|([Ee][+-]?))* | 0[Xx](%x|%.|([Pp][+-]?))*
|
|
||||||
**
|
|
||||||
** The only tricky part is to accept [+-] only after a valid exponent
|
|
||||||
** mark, to avoid reading '3-4' or '0xe+1' as a single number.
|
|
||||||
**
|
|
||||||
** The caller might have already read an initial dot.
|
|
||||||
*/
|
|
||||||
static int read_numeral (LexState *ls, SemInfo *seminfo) {
|
|
||||||
TValue obj;
|
|
||||||
const char *expo = "Ee";
|
|
||||||
int first = ls->current;
|
|
||||||
lua_assert(lisdigit(ls->current));
|
|
||||||
save_and_next(ls);
|
|
||||||
if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */
|
|
||||||
expo = "Pp";
|
|
||||||
for (;;) {
|
|
||||||
if (check_next2(ls, expo)) /* exponent mark? */
|
|
||||||
check_next2(ls, "-+"); /* optional exponent sign */
|
|
||||||
else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */
|
|
||||||
save_and_next(ls);
|
|
||||||
else break;
|
|
||||||
}
|
|
||||||
if (lislalpha(ls->current)) /* is numeral touching a letter? */
|
|
||||||
save_and_next(ls); /* force an error */
|
|
||||||
save(ls, '\0');
|
|
||||||
if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */
|
|
||||||
lexerror(ls, "malformed number", TK_FLT);
|
|
||||||
if (ttisinteger(&obj)) {
|
|
||||||
seminfo->i = ivalue(&obj);
|
|
||||||
return TK_INT;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_assert(ttisfloat(&obj));
|
|
||||||
seminfo->r = fltvalue(&obj);
|
|
||||||
return TK_FLT;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** read a sequence '[=*[' or ']=*]', leaving the last bracket. If
|
|
||||||
** sequence is well formed, return its number of '='s + 2; otherwise,
|
|
||||||
** return 1 if it is a single bracket (no '='s and no 2nd bracket);
|
|
||||||
** otherwise (an unfinished '[==...') return 0.
|
|
||||||
*/
|
|
||||||
static size_t skip_sep (LexState *ls) {
|
|
||||||
size_t count = 0;
|
|
||||||
int s = ls->current;
|
|
||||||
lua_assert(s == '[' || s == ']');
|
|
||||||
save_and_next(ls);
|
|
||||||
while (ls->current == '=') {
|
|
||||||
save_and_next(ls);
|
|
||||||
count++;
|
|
||||||
}
|
|
||||||
return (ls->current == s) ? count + 2
|
|
||||||
: (count == 0) ? 1
|
|
||||||
: 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
|
|
||||||
int line = ls->linenumber; /* initial line (for error message) */
|
|
||||||
save_and_next(ls); /* skip 2nd '[' */
|
|
||||||
if (currIsNewline(ls)) /* string starts with a newline? */
|
|
||||||
inclinenumber(ls); /* skip it */
|
|
||||||
for (;;) {
|
|
||||||
switch (ls->current) {
|
|
||||||
case EOZ: { /* error */
|
|
||||||
const char *what = (seminfo ? "string" : "comment");
|
|
||||||
const char *msg = luaO_pushfstring(ls->L,
|
|
||||||
"unfinished long %s (starting at line %d)", what, line);
|
|
||||||
lexerror(ls, msg, TK_EOS);
|
|
||||||
break; /* to avoid warnings */
|
|
||||||
}
|
|
||||||
case ']': {
|
|
||||||
if (skip_sep(ls) == sep) {
|
|
||||||
save_and_next(ls); /* skip 2nd ']' */
|
|
||||||
goto endloop;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case '\n': case '\r': {
|
|
||||||
save(ls, '\n');
|
|
||||||
inclinenumber(ls);
|
|
||||||
if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
default: {
|
|
||||||
if (seminfo) save_and_next(ls);
|
|
||||||
else next(ls);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
} endloop:
|
|
||||||
if (seminfo)
|
|
||||||
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,
|
|
||||||
luaZ_bufflen(ls->buff) - 2 * sep);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void esccheck (LexState *ls, int c, const char *msg) {
|
|
||||||
if (!c) {
|
|
||||||
if (ls->current != EOZ)
|
|
||||||
save_and_next(ls); /* add current to buffer for error message */
|
|
||||||
lexerror(ls, msg, TK_STRING);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int gethexa (LexState *ls) {
|
|
||||||
save_and_next(ls);
|
|
||||||
esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected");
|
|
||||||
return luaO_hexavalue(ls->current);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int readhexaesc (LexState *ls) {
|
|
||||||
int r = gethexa(ls);
|
|
||||||
r = (r << 4) + gethexa(ls);
|
|
||||||
luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static unsigned long readutf8esc (LexState *ls) {
|
|
||||||
unsigned long r;
|
|
||||||
int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */
|
|
||||||
save_and_next(ls); /* skip 'u' */
|
|
||||||
esccheck(ls, ls->current == '{', "missing '{'");
|
|
||||||
r = gethexa(ls); /* must have at least one digit */
|
|
||||||
while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) {
|
|
||||||
i++;
|
|
||||||
esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large");
|
|
||||||
r = (r << 4) + luaO_hexavalue(ls->current);
|
|
||||||
}
|
|
||||||
esccheck(ls, ls->current == '}', "missing '}'");
|
|
||||||
next(ls); /* skip '}' */
|
|
||||||
luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void utf8esc (LexState *ls) {
|
|
||||||
char buff[UTF8BUFFSZ];
|
|
||||||
int n = luaO_utf8esc(buff, readutf8esc(ls));
|
|
||||||
for (; n > 0; n--) /* add 'buff' to string */
|
|
||||||
save(ls, buff[UTF8BUFFSZ - n]);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int readdecesc (LexState *ls) {
|
|
||||||
int i;
|
|
||||||
int r = 0; /* result accumulator */
|
|
||||||
for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */
|
|
||||||
r = 10*r + ls->current - '0';
|
|
||||||
save_and_next(ls);
|
|
||||||
}
|
|
||||||
esccheck(ls, r <= UCHAR_MAX, "decimal escape too large");
|
|
||||||
luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */
|
|
||||||
return r;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void read_string (LexState *ls, int del, SemInfo *seminfo) {
|
|
||||||
save_and_next(ls); /* keep delimiter (for error messages) */
|
|
||||||
while (ls->current != del) {
|
|
||||||
switch (ls->current) {
|
|
||||||
case EOZ:
|
|
||||||
lexerror(ls, "unfinished string", TK_EOS);
|
|
||||||
break; /* to avoid warnings */
|
|
||||||
case '\n':
|
|
||||||
case '\r':
|
|
||||||
lexerror(ls, "unfinished string", TK_STRING);
|
|
||||||
break; /* to avoid warnings */
|
|
||||||
case '\\': { /* escape sequences */
|
|
||||||
int c; /* final character to be saved */
|
|
||||||
save_and_next(ls); /* keep '\\' for error messages */
|
|
||||||
switch (ls->current) {
|
|
||||||
case 'a': c = '\a'; goto read_save;
|
|
||||||
case 'b': c = '\b'; goto read_save;
|
|
||||||
case 'f': c = '\f'; goto read_save;
|
|
||||||
case 'n': c = '\n'; goto read_save;
|
|
||||||
case 'r': c = '\r'; goto read_save;
|
|
||||||
case 't': c = '\t'; goto read_save;
|
|
||||||
case 'v': c = '\v'; goto read_save;
|
|
||||||
case 'x': c = readhexaesc(ls); goto read_save;
|
|
||||||
case 'u': utf8esc(ls); goto no_save;
|
|
||||||
case '\n': case '\r':
|
|
||||||
inclinenumber(ls); c = '\n'; goto only_save;
|
|
||||||
case '\\': case '\"': case '\'':
|
|
||||||
c = ls->current; goto read_save;
|
|
||||||
case EOZ: goto no_save; /* will raise an error next loop */
|
|
||||||
case 'z': { /* zap following span of spaces */
|
|
||||||
luaZ_buffremove(ls->buff, 1); /* remove '\\' */
|
|
||||||
next(ls); /* skip the 'z' */
|
|
||||||
while (lisspace(ls->current)) {
|
|
||||||
if (currIsNewline(ls)) inclinenumber(ls);
|
|
||||||
else next(ls);
|
|
||||||
}
|
|
||||||
goto no_save;
|
|
||||||
}
|
|
||||||
default: {
|
|
||||||
esccheck(ls, lisdigit(ls->current), "invalid escape sequence");
|
|
||||||
c = readdecesc(ls); /* digital escape '\ddd' */
|
|
||||||
goto only_save;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
read_save:
|
|
||||||
next(ls);
|
|
||||||
/* go through */
|
|
||||||
only_save:
|
|
||||||
luaZ_buffremove(ls->buff, 1); /* remove '\\' */
|
|
||||||
save(ls, c);
|
|
||||||
/* go through */
|
|
||||||
no_save: break;
|
|
||||||
}
|
|
||||||
default:
|
|
||||||
save_and_next(ls);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
save_and_next(ls); /* skip delimiter */
|
|
||||||
seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
|
|
||||||
luaZ_bufflen(ls->buff) - 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int llex (LexState *ls, SemInfo *seminfo) {
|
|
||||||
luaZ_resetbuffer(ls->buff);
|
|
||||||
for (;;) {
|
|
||||||
switch (ls->current) {
|
|
||||||
case '\n': case '\r': { /* line breaks */
|
|
||||||
inclinenumber(ls);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case ' ': case '\f': case '\t': case '\v': { /* spaces */
|
|
||||||
next(ls);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case '-': { /* '-' or '--' (comment) */
|
|
||||||
next(ls);
|
|
||||||
if (ls->current != '-') return '-';
|
|
||||||
/* else is a comment */
|
|
||||||
next(ls);
|
|
||||||
if (ls->current == '[') { /* long comment? */
|
|
||||||
size_t sep = skip_sep(ls);
|
|
||||||
luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */
|
|
||||||
if (sep >= 2) {
|
|
||||||
read_long_string(ls, NULL, sep); /* skip long comment */
|
|
||||||
luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
/* else short comment */
|
|
||||||
while (!currIsNewline(ls) && ls->current != EOZ)
|
|
||||||
next(ls); /* skip until end of line (or end of file) */
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case '[': { /* long string or simply '[' */
|
|
||||||
size_t sep = skip_sep(ls);
|
|
||||||
if (sep >= 2) {
|
|
||||||
read_long_string(ls, seminfo, sep);
|
|
||||||
return TK_STRING;
|
|
||||||
}
|
|
||||||
else if (sep == 0) /* '[=...' missing second bracket? */
|
|
||||||
lexerror(ls, "invalid long string delimiter", TK_STRING);
|
|
||||||
return '[';
|
|
||||||
}
|
|
||||||
case '=': {
|
|
||||||
next(ls);
|
|
||||||
if (check_next1(ls, '=')) return TK_EQ; /* '==' */
|
|
||||||
else return '=';
|
|
||||||
}
|
|
||||||
case '<': {
|
|
||||||
next(ls);
|
|
||||||
if (check_next1(ls, '=')) return TK_LE; /* '<=' */
|
|
||||||
else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */
|
|
||||||
else return '<';
|
|
||||||
}
|
|
||||||
case '>': {
|
|
||||||
next(ls);
|
|
||||||
if (check_next1(ls, '=')) return TK_GE; /* '>=' */
|
|
||||||
else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */
|
|
||||||
else return '>';
|
|
||||||
}
|
|
||||||
case '/': {
|
|
||||||
next(ls);
|
|
||||||
if (check_next1(ls, '/')) return TK_IDIV; /* '//' */
|
|
||||||
else return '/';
|
|
||||||
}
|
|
||||||
case '~': {
|
|
||||||
next(ls);
|
|
||||||
if (check_next1(ls, '=')) return TK_NE; /* '~=' */
|
|
||||||
else return '~';
|
|
||||||
}
|
|
||||||
case ':': {
|
|
||||||
next(ls);
|
|
||||||
if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */
|
|
||||||
else return ':';
|
|
||||||
}
|
|
||||||
case '"': case '\'': { /* short literal strings */
|
|
||||||
read_string(ls, ls->current, seminfo);
|
|
||||||
return TK_STRING;
|
|
||||||
}
|
|
||||||
case '.': { /* '.', '..', '...', or number */
|
|
||||||
save_and_next(ls);
|
|
||||||
if (check_next1(ls, '.')) {
|
|
||||||
if (check_next1(ls, '.'))
|
|
||||||
return TK_DOTS; /* '...' */
|
|
||||||
else return TK_CONCAT; /* '..' */
|
|
||||||
}
|
|
||||||
else if (!lisdigit(ls->current)) return '.';
|
|
||||||
else return read_numeral(ls, seminfo);
|
|
||||||
}
|
|
||||||
case '0': case '1': case '2': case '3': case '4':
|
|
||||||
case '5': case '6': case '7': case '8': case '9': {
|
|
||||||
return read_numeral(ls, seminfo);
|
|
||||||
}
|
|
||||||
case EOZ: {
|
|
||||||
return TK_EOS;
|
|
||||||
}
|
|
||||||
default: {
|
|
||||||
if (lislalpha(ls->current)) { /* identifier or reserved word? */
|
|
||||||
TString *ts;
|
|
||||||
do {
|
|
||||||
save_and_next(ls);
|
|
||||||
} while (lislalnum(ls->current));
|
|
||||||
ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
|
|
||||||
luaZ_bufflen(ls->buff));
|
|
||||||
seminfo->ts = ts;
|
|
||||||
if (isreserved(ts)) /* reserved word? */
|
|
||||||
return ts->extra - 1 + FIRST_RESERVED;
|
|
||||||
else {
|
|
||||||
return TK_NAME;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */
|
|
||||||
int c = ls->current;
|
|
||||||
next(ls);
|
|
||||||
return c;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaX_next (LexState *ls) {
|
|
||||||
ls->lastline = ls->linenumber;
|
|
||||||
if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */
|
|
||||||
ls->t = ls->lookahead; /* use this one */
|
|
||||||
ls->lookahead.token = TK_EOS; /* and discharge it */
|
|
||||||
}
|
|
||||||
else
|
|
||||||
ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int luaX_lookahead (LexState *ls) {
|
|
||||||
lua_assert(ls->lookahead.token == TK_EOS);
|
|
||||||
ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
|
|
||||||
return ls->lookahead.token;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,91 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: llex.h $
|
|
||||||
** Lexical Analyzer
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef llex_h
|
|
||||||
#define llex_h
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lzio.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Single-char tokens (terminal symbols) are represented by their own
|
|
||||||
** numeric code. Other tokens start at the following value.
|
|
||||||
*/
|
|
||||||
#define FIRST_RESERVED (UCHAR_MAX + 1)
|
|
||||||
|
|
||||||
|
|
||||||
#if !defined(LUA_ENV)
|
|
||||||
#define LUA_ENV "_ENV"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
* WARNING: if you change the order of this enumeration,
|
|
||||||
* grep "ORDER RESERVED"
|
|
||||||
*/
|
|
||||||
enum RESERVED {
|
|
||||||
/* terminal symbols denoted by reserved words */
|
|
||||||
TK_AND = FIRST_RESERVED, TK_BREAK,
|
|
||||||
TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
|
|
||||||
TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
|
|
||||||
TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
|
|
||||||
/* other terminal symbols */
|
|
||||||
TK_IDIV, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE,
|
|
||||||
TK_SHL, TK_SHR,
|
|
||||||
TK_DBCOLON, TK_EOS,
|
|
||||||
TK_FLT, TK_INT, TK_NAME, TK_STRING
|
|
||||||
};
|
|
||||||
|
|
||||||
/* number of reserved words */
|
|
||||||
#define NUM_RESERVED (cast_int(TK_WHILE-FIRST_RESERVED + 1))
|
|
||||||
|
|
||||||
|
|
||||||
typedef union {
|
|
||||||
lua_Number r;
|
|
||||||
lua_Integer i;
|
|
||||||
TString *ts;
|
|
||||||
} SemInfo; /* semantics information */
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct Token {
|
|
||||||
int token;
|
|
||||||
SemInfo seminfo;
|
|
||||||
} Token;
|
|
||||||
|
|
||||||
|
|
||||||
/* state of the lexer plus state of the parser when shared by all
|
|
||||||
functions */
|
|
||||||
typedef struct LexState {
|
|
||||||
int current; /* current character (charint) */
|
|
||||||
int linenumber; /* input line counter */
|
|
||||||
int lastline; /* line of last token 'consumed' */
|
|
||||||
Token t; /* current token */
|
|
||||||
Token lookahead; /* look ahead token */
|
|
||||||
struct FuncState *fs; /* current function (parser) */
|
|
||||||
struct lua_State *L;
|
|
||||||
ZIO *z; /* input stream */
|
|
||||||
Mbuffer *buff; /* buffer for tokens */
|
|
||||||
Table *h; /* to avoid collection/reuse strings */
|
|
||||||
struct Dyndata *dyd; /* dynamic structures used by the parser */
|
|
||||||
TString *source; /* current source name */
|
|
||||||
TString *envn; /* environment variable name */
|
|
||||||
} LexState;
|
|
||||||
|
|
||||||
|
|
||||||
LUAI_FUNC void luaX_init (lua_State *L);
|
|
||||||
LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
|
|
||||||
TString *source, int firstchar);
|
|
||||||
LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
|
|
||||||
LUAI_FUNC void luaX_next (LexState *ls);
|
|
||||||
LUAI_FUNC int luaX_lookahead (LexState *ls);
|
|
||||||
LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
|
|
||||||
LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,380 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: llimits.h $
|
|
||||||
** Limits, basic types, and some other 'installation-dependent' definitions
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef llimits_h
|
|
||||||
#define llimits_h
|
|
||||||
|
|
||||||
|
|
||||||
#include <limits.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'lu_mem' and 'l_mem' are unsigned/signed integers big enough to count
|
|
||||||
** the total memory used by Lua (in bytes). Usually, 'size_t' and
|
|
||||||
** 'ptrdiff_t' should work, but we use 'long' for 16-bit machines.
|
|
||||||
*/
|
|
||||||
#if defined(LUAI_MEM) /* { external definitions? */
|
|
||||||
typedef LUAI_UMEM lu_mem;
|
|
||||||
typedef LUAI_MEM l_mem;
|
|
||||||
#elif LUAI_IS32INT /* }{ */
|
|
||||||
typedef size_t lu_mem;
|
|
||||||
typedef ptrdiff_t l_mem;
|
|
||||||
#else /* 16-bit ints */ /* }{ */
|
|
||||||
typedef unsigned long lu_mem;
|
|
||||||
typedef long l_mem;
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/* chars used as small naturals (so that 'char' is reserved for characters) */
|
|
||||||
typedef unsigned char lu_byte;
|
|
||||||
typedef signed char ls_byte;
|
|
||||||
|
|
||||||
|
|
||||||
/* maximum value for size_t */
|
|
||||||
#define MAX_SIZET ((size_t)(~(size_t)0))
|
|
||||||
|
|
||||||
/* maximum size visible for Lua (must be representable in a lua_Integer) */
|
|
||||||
#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \
|
|
||||||
: (size_t)(LUA_MAXINTEGER))
|
|
||||||
|
|
||||||
|
|
||||||
#define MAX_LUMEM ((lu_mem)(~(lu_mem)0))
|
|
||||||
|
|
||||||
#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1))
|
|
||||||
|
|
||||||
|
|
||||||
#define MAX_INT INT_MAX /* maximum value of an int */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** floor of the log2 of the maximum signed value for integral type 't'.
|
|
||||||
** (That is, maximum 'n' such that '2^n' fits in the given signed type.)
|
|
||||||
*/
|
|
||||||
#define log2maxs(t) (sizeof(t) * 8 - 2)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** test whether an unsigned value is a power of 2 (or zero)
|
|
||||||
*/
|
|
||||||
#define ispow2(x) (((x) & ((x) - 1)) == 0)
|
|
||||||
|
|
||||||
|
|
||||||
/* number of chars of a literal string without the ending \0 */
|
|
||||||
#define LL(x) (sizeof(x)/sizeof(char) - 1)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** conversion of pointer to unsigned integer: this is for hashing only;
|
|
||||||
** there is no problem if the integer cannot hold the whole pointer
|
|
||||||
** value. (In strict ISO C this may cause undefined behavior, but no
|
|
||||||
** actual machine seems to bother.)
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \
|
|
||||||
__STDC_VERSION__ >= 199901L
|
|
||||||
#include <stdint.h>
|
|
||||||
#if defined(UINTPTR_MAX) /* even in C99 this type is optional */
|
|
||||||
#define L_P2I uintptr_t
|
|
||||||
#else /* no 'intptr'? */
|
|
||||||
#define L_P2I uintmax_t /* use the largest available integer */
|
|
||||||
#endif
|
|
||||||
#else /* C89 option */
|
|
||||||
#define L_P2I size_t
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define point2uint(p) ((unsigned int)((L_P2I)(p) & UINT_MAX))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* types of 'usual argument conversions' for lua_Number and lua_Integer */
|
|
||||||
typedef LUAI_UACNUMBER l_uacNumber;
|
|
||||||
typedef LUAI_UACINT l_uacInt;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Internal assertions for in-house debugging
|
|
||||||
*/
|
|
||||||
#if defined LUAI_ASSERT
|
|
||||||
#undef NDEBUG
|
|
||||||
#include <assert.h>
|
|
||||||
#define lua_assert(c) assert(c)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if defined(lua_assert)
|
|
||||||
#define check_exp(c,e) (lua_assert(c), (e))
|
|
||||||
/* to avoid problems with conditions too long */
|
|
||||||
#define lua_longassert(c) ((c) ? (void)0 : lua_assert(0))
|
|
||||||
#else
|
|
||||||
#define lua_assert(c) ((void)0)
|
|
||||||
#define check_exp(c,e) (e)
|
|
||||||
#define lua_longassert(c) ((void)0)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** assertion for checking API calls
|
|
||||||
*/
|
|
||||||
#if !defined(luai_apicheck)
|
|
||||||
#define luai_apicheck(l,e) ((void)l, lua_assert(e))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define api_check(l,e,msg) luai_apicheck(l,(e) && msg)
|
|
||||||
|
|
||||||
|
|
||||||
/* macro to avoid warnings about unused variables */
|
|
||||||
#if !defined(UNUSED)
|
|
||||||
#define UNUSED(x) ((void)(x))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/* type casts (a macro highlights casts in the code) */
|
|
||||||
#define cast(t, exp) ((t)(exp))
|
|
||||||
|
|
||||||
#define cast_void(i) cast(void, (i))
|
|
||||||
#define cast_voidp(i) cast(void *, (i))
|
|
||||||
#define cast_num(i) cast(lua_Number, (i))
|
|
||||||
#define cast_int(i) cast(int, (i))
|
|
||||||
#define cast_uint(i) cast(unsigned int, (i))
|
|
||||||
#define cast_byte(i) cast(lu_byte, (i))
|
|
||||||
#define cast_uchar(i) cast(unsigned char, (i))
|
|
||||||
#define cast_char(i) cast(char, (i))
|
|
||||||
#define cast_charp(i) cast(char *, (i))
|
|
||||||
#define cast_sizet(i) cast(size_t, (i))
|
|
||||||
|
|
||||||
|
|
||||||
/* cast a signed lua_Integer to lua_Unsigned */
|
|
||||||
#if !defined(l_castS2U)
|
|
||||||
#define l_castS2U(i) ((lua_Unsigned)(i))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** cast a lua_Unsigned to a signed lua_Integer; this cast is
|
|
||||||
** not strict ISO C, but two-complement architectures should
|
|
||||||
** work fine.
|
|
||||||
*/
|
|
||||||
#if !defined(l_castU2S)
|
|
||||||
#define l_castU2S(i) ((lua_Integer)(i))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** non-return type
|
|
||||||
*/
|
|
||||||
#if !defined(l_noret)
|
|
||||||
|
|
||||||
#if defined(__GNUC__)
|
|
||||||
#define l_noret void __attribute__((noreturn))
|
|
||||||
#elif defined(_MSC_VER) && _MSC_VER >= 1200
|
|
||||||
#define l_noret void __declspec(noreturn)
|
|
||||||
#else
|
|
||||||
#define l_noret void
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Inline functions
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89)
|
|
||||||
#define l_inline inline
|
|
||||||
#elif defined(__GNUC__)
|
|
||||||
#define l_inline __inline__
|
|
||||||
#else
|
|
||||||
#define l_inline /* empty */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define l_sinline static l_inline
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** type for virtual-machine instructions;
|
|
||||||
** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
|
|
||||||
*/
|
|
||||||
#if LUAI_IS32INT
|
|
||||||
typedef unsigned int l_uint32;
|
|
||||||
#else
|
|
||||||
typedef unsigned long l_uint32;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
typedef l_uint32 Instruction;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Maximum length for short strings, that is, strings that are
|
|
||||||
** internalized. (Cannot be smaller than reserved words or tags for
|
|
||||||
** metamethods, as these strings must be internalized;
|
|
||||||
** #("function") = 8, #("__newindex") = 10.)
|
|
||||||
*/
|
|
||||||
#if !defined(LUAI_MAXSHORTLEN)
|
|
||||||
#define LUAI_MAXSHORTLEN 40
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Initial size for the string table (must be power of 2).
|
|
||||||
** The Lua core alone registers ~50 strings (reserved words +
|
|
||||||
** metaevent keys + a few others). Libraries would typically add
|
|
||||||
** a few dozens more.
|
|
||||||
*/
|
|
||||||
#if !defined(MINSTRTABSIZE)
|
|
||||||
#define MINSTRTABSIZE 128
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Size of cache for strings in the API. 'N' is the number of
|
|
||||||
** sets (better be a prime) and "M" is the size of each set (M == 1
|
|
||||||
** makes a direct cache.)
|
|
||||||
*/
|
|
||||||
#if !defined(STRCACHE_N)
|
|
||||||
#define STRCACHE_N 53
|
|
||||||
#define STRCACHE_M 2
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/* minimum size for string buffer */
|
|
||||||
#if !defined(LUA_MINBUFFER)
|
|
||||||
#define LUA_MINBUFFER 32
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Maximum depth for nested C calls, syntactical nested non-terminals,
|
|
||||||
** and other features implemented through recursion in C. (Value must
|
|
||||||
** fit in a 16-bit unsigned integer. It must also be compatible with
|
|
||||||
** the size of the C stack.)
|
|
||||||
*/
|
|
||||||
#if !defined(LUAI_MAXCCALLS)
|
|
||||||
#define LUAI_MAXCCALLS 200
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** macros that are executed whenever program enters the Lua core
|
|
||||||
** ('lua_lock') and leaves the core ('lua_unlock')
|
|
||||||
*/
|
|
||||||
#if !defined(lua_lock)
|
|
||||||
#define lua_lock(L) ((void) 0)
|
|
||||||
#define lua_unlock(L) ((void) 0)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** macro executed during Lua functions at points where the
|
|
||||||
** function can yield.
|
|
||||||
*/
|
|
||||||
#if !defined(luai_threadyield)
|
|
||||||
#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** these macros allow user-specific actions when a thread is
|
|
||||||
** created/deleted/resumed/yielded.
|
|
||||||
*/
|
|
||||||
#if !defined(luai_userstateopen)
|
|
||||||
#define luai_userstateopen(L) ((void)L)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(luai_userstateclose)
|
|
||||||
#define luai_userstateclose(L) ((void)L)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(luai_userstatethread)
|
|
||||||
#define luai_userstatethread(L,L1) ((void)L)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(luai_userstatefree)
|
|
||||||
#define luai_userstatefree(L,L1) ((void)L)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(luai_userstateresume)
|
|
||||||
#define luai_userstateresume(L,n) ((void)L)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(luai_userstateyield)
|
|
||||||
#define luai_userstateyield(L,n) ((void)L)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** The luai_num* macros define the primitive operations over numbers.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* floor division (defined as 'floor(a/b)') */
|
|
||||||
#if !defined(luai_numidiv)
|
|
||||||
#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b)))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* float division */
|
|
||||||
#if !defined(luai_numdiv)
|
|
||||||
#define luai_numdiv(L,a,b) ((a)/(b))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** modulo: defined as 'a - floor(a/b)*b'; the direct computation
|
|
||||||
** using this definition has several problems with rounding errors,
|
|
||||||
** so it is better to use 'fmod'. 'fmod' gives the result of
|
|
||||||
** 'a - trunc(a/b)*b', and therefore must be corrected when
|
|
||||||
** 'trunc(a/b) ~= floor(a/b)'. That happens when the division has a
|
|
||||||
** non-integer negative result: non-integer result is equivalent to
|
|
||||||
** a non-zero remainder 'm'; negative result is equivalent to 'a' and
|
|
||||||
** 'b' with different signs, or 'm' and 'b' with different signs
|
|
||||||
** (as the result 'm' of 'fmod' has the same sign of 'a').
|
|
||||||
*/
|
|
||||||
#if !defined(luai_nummod)
|
|
||||||
#define luai_nummod(L,a,b,m) \
|
|
||||||
{ (void)L; (m) = l_mathop(fmod)(a,b); \
|
|
||||||
if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); }
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* exponentiation */
|
|
||||||
#if !defined(luai_numpow)
|
|
||||||
#define luai_numpow(L,a,b) \
|
|
||||||
((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/* the others are quite standard operations */
|
|
||||||
#if !defined(luai_numadd)
|
|
||||||
#define luai_numadd(L,a,b) ((a)+(b))
|
|
||||||
#define luai_numsub(L,a,b) ((a)-(b))
|
|
||||||
#define luai_nummul(L,a,b) ((a)*(b))
|
|
||||||
#define luai_numunm(L,a) (-(a))
|
|
||||||
#define luai_numeq(a,b) ((a)==(b))
|
|
||||||
#define luai_numlt(a,b) ((a)<(b))
|
|
||||||
#define luai_numle(a,b) ((a)<=(b))
|
|
||||||
#define luai_numgt(a,b) ((a)>(b))
|
|
||||||
#define luai_numge(a,b) ((a)>=(b))
|
|
||||||
#define luai_numisnan(a) (!luai_numeq((a), (a)))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** macro to control inclusion of some hard tests on stack reallocation
|
|
||||||
*/
|
|
||||||
#if !defined(HARDSTACKTESTS)
|
|
||||||
#define condmovestack(L,pre,pos) ((void)0)
|
|
||||||
#else
|
|
||||||
/* realloc stack keeping its size */
|
|
||||||
#define condmovestack(L,pre,pos) \
|
|
||||||
{ int sz_ = stacksize(L); pre; luaD_reallocstack((L), sz_, 0); pos; }
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(HARDMEMTESTS)
|
|
||||||
#define condchangemem(L,pre,pos) ((void)0)
|
|
||||||
#else
|
|
||||||
#define condchangemem(L,pre,pos) \
|
|
||||||
{ if (gcrunning(G(L))) { pre; luaC_fullgc(L, 0); pos; } }
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,764 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lmathlib.c $
|
|
||||||
** Standard mathematical library
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lmathlib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <float.h>
|
|
||||||
#include <limits.h>
|
|
||||||
#include <math.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <time.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
#undef PI
|
|
||||||
#define PI (l_mathop(3.141592653589793238462643383279502884))
|
|
||||||
|
|
||||||
|
|
||||||
static int math_abs (lua_State *L) {
|
|
||||||
if (lua_isinteger(L, 1)) {
|
|
||||||
lua_Integer n = lua_tointeger(L, 1);
|
|
||||||
if (n < 0) n = (lua_Integer)(0u - (lua_Unsigned)n);
|
|
||||||
lua_pushinteger(L, n);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_sin (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_cos (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_tan (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_asin (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_acos (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_atan (lua_State *L) {
|
|
||||||
lua_Number y = luaL_checknumber(L, 1);
|
|
||||||
lua_Number x = luaL_optnumber(L, 2, 1);
|
|
||||||
lua_pushnumber(L, l_mathop(atan2)(y, x));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_toint (lua_State *L) {
|
|
||||||
int valid;
|
|
||||||
lua_Integer n = lua_tointegerx(L, 1, &valid);
|
|
||||||
if (l_likely(valid))
|
|
||||||
lua_pushinteger(L, n);
|
|
||||||
else {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
luaL_pushfail(L); /* value is not convertible to integer */
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void pushnumint (lua_State *L, lua_Number d) {
|
|
||||||
lua_Integer n;
|
|
||||||
if (lua_numbertointeger(d, &n)) /* does 'd' fit in an integer? */
|
|
||||||
lua_pushinteger(L, n); /* result is integer */
|
|
||||||
else
|
|
||||||
lua_pushnumber(L, d); /* result is float */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_floor (lua_State *L) {
|
|
||||||
if (lua_isinteger(L, 1))
|
|
||||||
lua_settop(L, 1); /* integer is its own floor */
|
|
||||||
else {
|
|
||||||
lua_Number d = l_mathop(floor)(luaL_checknumber(L, 1));
|
|
||||||
pushnumint(L, d);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_ceil (lua_State *L) {
|
|
||||||
if (lua_isinteger(L, 1))
|
|
||||||
lua_settop(L, 1); /* integer is its own ceil */
|
|
||||||
else {
|
|
||||||
lua_Number d = l_mathop(ceil)(luaL_checknumber(L, 1));
|
|
||||||
pushnumint(L, d);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_fmod (lua_State *L) {
|
|
||||||
if (lua_isinteger(L, 1) && lua_isinteger(L, 2)) {
|
|
||||||
lua_Integer d = lua_tointeger(L, 2);
|
|
||||||
if ((lua_Unsigned)d + 1u <= 1u) { /* special cases: -1 or 0 */
|
|
||||||
luaL_argcheck(L, d != 0, 2, "zero");
|
|
||||||
lua_pushinteger(L, 0); /* avoid overflow with 0x80000... / -1 */
|
|
||||||
}
|
|
||||||
else
|
|
||||||
lua_pushinteger(L, lua_tointeger(L, 1) % d);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
|
|
||||||
luaL_checknumber(L, 2)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** next function does not use 'modf', avoiding problems with 'double*'
|
|
||||||
** (which is not compatible with 'float*') when lua_Number is not
|
|
||||||
** 'double'.
|
|
||||||
*/
|
|
||||||
static int math_modf (lua_State *L) {
|
|
||||||
if (lua_isinteger(L ,1)) {
|
|
||||||
lua_settop(L, 1); /* number is its own integer part */
|
|
||||||
lua_pushnumber(L, 0); /* no fractional part */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_Number n = luaL_checknumber(L, 1);
|
|
||||||
/* integer part (rounds toward zero) */
|
|
||||||
lua_Number ip = (n < 0) ? l_mathop(ceil)(n) : l_mathop(floor)(n);
|
|
||||||
pushnumint(L, ip);
|
|
||||||
/* fractional part (test needed for inf/-inf) */
|
|
||||||
lua_pushnumber(L, (n == ip) ? l_mathop(0.0) : (n - ip));
|
|
||||||
}
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_sqrt (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_ult (lua_State *L) {
|
|
||||||
lua_Integer a = luaL_checkinteger(L, 1);
|
|
||||||
lua_Integer b = luaL_checkinteger(L, 2);
|
|
||||||
lua_pushboolean(L, (lua_Unsigned)a < (lua_Unsigned)b);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_log (lua_State *L) {
|
|
||||||
lua_Number x = luaL_checknumber(L, 1);
|
|
||||||
lua_Number res;
|
|
||||||
if (lua_isnoneornil(L, 2))
|
|
||||||
res = l_mathop(log)(x);
|
|
||||||
else {
|
|
||||||
lua_Number base = luaL_checknumber(L, 2);
|
|
||||||
#if !defined(LUA_USE_C89)
|
|
||||||
if (base == l_mathop(2.0))
|
|
||||||
res = l_mathop(log2)(x);
|
|
||||||
else
|
|
||||||
#endif
|
|
||||||
if (base == l_mathop(10.0))
|
|
||||||
res = l_mathop(log10)(x);
|
|
||||||
else
|
|
||||||
res = l_mathop(log)(x)/l_mathop(log)(base);
|
|
||||||
}
|
|
||||||
lua_pushnumber(L, res);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_exp (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_deg (lua_State *L) {
|
|
||||||
lua_pushnumber(L, luaL_checknumber(L, 1) * (l_mathop(180.0) / PI));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_rad (lua_State *L) {
|
|
||||||
lua_pushnumber(L, luaL_checknumber(L, 1) * (PI / l_mathop(180.0)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_min (lua_State *L) {
|
|
||||||
int n = lua_gettop(L); /* number of arguments */
|
|
||||||
int imin = 1; /* index of current minimum value */
|
|
||||||
int i;
|
|
||||||
luaL_argcheck(L, n >= 1, 1, "value expected");
|
|
||||||
for (i = 2; i <= n; i++) {
|
|
||||||
if (lua_compare(L, i, imin, LUA_OPLT))
|
|
||||||
imin = i;
|
|
||||||
}
|
|
||||||
lua_pushvalue(L, imin);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_max (lua_State *L) {
|
|
||||||
int n = lua_gettop(L); /* number of arguments */
|
|
||||||
int imax = 1; /* index of current maximum value */
|
|
||||||
int i;
|
|
||||||
luaL_argcheck(L, n >= 1, 1, "value expected");
|
|
||||||
for (i = 2; i <= n; i++) {
|
|
||||||
if (lua_compare(L, imax, i, LUA_OPLT))
|
|
||||||
imax = i;
|
|
||||||
}
|
|
||||||
lua_pushvalue(L, imax);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_type (lua_State *L) {
|
|
||||||
if (lua_type(L, 1) == LUA_TNUMBER)
|
|
||||||
lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float");
|
|
||||||
else {
|
|
||||||
luaL_checkany(L, 1);
|
|
||||||
luaL_pushfail(L);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Pseudo-Random Number Generator based on 'xoshiro256**'.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* number of binary digits in the mantissa of a float */
|
|
||||||
#define FIGS l_floatatt(MANT_DIG)
|
|
||||||
|
|
||||||
#if FIGS > 64
|
|
||||||
/* there are only 64 random bits; use them all */
|
|
||||||
#undef FIGS
|
|
||||||
#define FIGS 64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** LUA_RAND32 forces the use of 32-bit integers in the implementation
|
|
||||||
** of the PRN generator (mainly for testing).
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_RAND32) && !defined(Rand64)
|
|
||||||
|
|
||||||
/* try to find an integer type with at least 64 bits */
|
|
||||||
|
|
||||||
#if ((ULONG_MAX >> 31) >> 31) >= 3
|
|
||||||
|
|
||||||
/* 'long' has at least 64 bits */
|
|
||||||
#define Rand64 unsigned long
|
|
||||||
|
|
||||||
#elif !defined(LUA_USE_C89) && defined(LLONG_MAX)
|
|
||||||
|
|
||||||
/* there is a 'long long' type (which must have at least 64 bits) */
|
|
||||||
#define Rand64 unsigned long long
|
|
||||||
|
|
||||||
#elif ((LUA_MAXUNSIGNED >> 31) >> 31) >= 3
|
|
||||||
|
|
||||||
/* 'lua_Unsigned' has at least 64 bits */
|
|
||||||
#define Rand64 lua_Unsigned
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(Rand64) /* { */
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Standard implementation, using 64-bit integers.
|
|
||||||
** If 'Rand64' has more than 64 bits, the extra bits do not interfere
|
|
||||||
** with the 64 initial bits, except in a right shift. Moreover, the
|
|
||||||
** final result has to discard the extra bits.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* avoid using extra bits when needed */
|
|
||||||
#define trim64(x) ((x) & 0xffffffffffffffffu)
|
|
||||||
|
|
||||||
|
|
||||||
/* rotate left 'x' by 'n' bits */
|
|
||||||
static Rand64 rotl (Rand64 x, int n) {
|
|
||||||
return (x << n) | (trim64(x) >> (64 - n));
|
|
||||||
}
|
|
||||||
|
|
||||||
static Rand64 nextrand (Rand64 *state) {
|
|
||||||
Rand64 state0 = state[0];
|
|
||||||
Rand64 state1 = state[1];
|
|
||||||
Rand64 state2 = state[2] ^ state0;
|
|
||||||
Rand64 state3 = state[3] ^ state1;
|
|
||||||
Rand64 res = rotl(state1 * 5, 7) * 9;
|
|
||||||
state[0] = state0 ^ state3;
|
|
||||||
state[1] = state1 ^ state2;
|
|
||||||
state[2] = state2 ^ (state1 << 17);
|
|
||||||
state[3] = rotl(state3, 45);
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* must take care to not shift stuff by more than 63 slots */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert bits from a random integer into a float in the
|
|
||||||
** interval [0,1), getting the higher FIG bits from the
|
|
||||||
** random unsigned integer and converting that to a float.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* must throw out the extra (64 - FIGS) bits */
|
|
||||||
#define shift64_FIG (64 - FIGS)
|
|
||||||
|
|
||||||
/* to scale to [0, 1), multiply by scaleFIG = 2^(-FIGS) */
|
|
||||||
#define scaleFIG (l_mathop(0.5) / ((Rand64)1 << (FIGS - 1)))
|
|
||||||
|
|
||||||
static lua_Number I2d (Rand64 x) {
|
|
||||||
return (lua_Number)(trim64(x) >> shift64_FIG) * scaleFIG;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* convert a 'Rand64' to a 'lua_Unsigned' */
|
|
||||||
#define I2UInt(x) ((lua_Unsigned)trim64(x))
|
|
||||||
|
|
||||||
/* convert a 'lua_Unsigned' to a 'Rand64' */
|
|
||||||
#define Int2I(x) ((Rand64)(x))
|
|
||||||
|
|
||||||
|
|
||||||
#else /* no 'Rand64' }{ */
|
|
||||||
|
|
||||||
/* get an integer with at least 32 bits */
|
|
||||||
#if LUAI_IS32INT
|
|
||||||
typedef unsigned int lu_int32;
|
|
||||||
#else
|
|
||||||
typedef unsigned long lu_int32;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Use two 32-bit integers to represent a 64-bit quantity.
|
|
||||||
*/
|
|
||||||
typedef struct Rand64 {
|
|
||||||
lu_int32 h; /* higher half */
|
|
||||||
lu_int32 l; /* lower half */
|
|
||||||
} Rand64;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** If 'lu_int32' has more than 32 bits, the extra bits do not interfere
|
|
||||||
** with the 32 initial bits, except in a right shift and comparisons.
|
|
||||||
** Moreover, the final result has to discard the extra bits.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* avoid using extra bits when needed */
|
|
||||||
#define trim32(x) ((x) & 0xffffffffu)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** basic operations on 'Rand64' values
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* build a new Rand64 value */
|
|
||||||
static Rand64 packI (lu_int32 h, lu_int32 l) {
|
|
||||||
Rand64 result;
|
|
||||||
result.h = h;
|
|
||||||
result.l = l;
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return i << n */
|
|
||||||
static Rand64 Ishl (Rand64 i, int n) {
|
|
||||||
lua_assert(n > 0 && n < 32);
|
|
||||||
return packI((i.h << n) | (trim32(i.l) >> (32 - n)), i.l << n);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* i1 ^= i2 */
|
|
||||||
static void Ixor (Rand64 *i1, Rand64 i2) {
|
|
||||||
i1->h ^= i2.h;
|
|
||||||
i1->l ^= i2.l;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return i1 + i2 */
|
|
||||||
static Rand64 Iadd (Rand64 i1, Rand64 i2) {
|
|
||||||
Rand64 result = packI(i1.h + i2.h, i1.l + i2.l);
|
|
||||||
if (trim32(result.l) < trim32(i1.l)) /* carry? */
|
|
||||||
result.h++;
|
|
||||||
return result;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return i * 5 */
|
|
||||||
static Rand64 times5 (Rand64 i) {
|
|
||||||
return Iadd(Ishl(i, 2), i); /* i * 5 == (i << 2) + i */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return i * 9 */
|
|
||||||
static Rand64 times9 (Rand64 i) {
|
|
||||||
return Iadd(Ishl(i, 3), i); /* i * 9 == (i << 3) + i */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* return 'i' rotated left 'n' bits */
|
|
||||||
static Rand64 rotl (Rand64 i, int n) {
|
|
||||||
lua_assert(n > 0 && n < 32);
|
|
||||||
return packI((i.h << n) | (trim32(i.l) >> (32 - n)),
|
|
||||||
(trim32(i.h) >> (32 - n)) | (i.l << n));
|
|
||||||
}
|
|
||||||
|
|
||||||
/* for offsets larger than 32, rotate right by 64 - offset */
|
|
||||||
static Rand64 rotl1 (Rand64 i, int n) {
|
|
||||||
lua_assert(n > 32 && n < 64);
|
|
||||||
n = 64 - n;
|
|
||||||
return packI((trim32(i.h) >> n) | (i.l << (32 - n)),
|
|
||||||
(i.h << (32 - n)) | (trim32(i.l) >> n));
|
|
||||||
}
|
|
||||||
|
|
||||||
/*
|
|
||||||
** implementation of 'xoshiro256**' algorithm on 'Rand64' values
|
|
||||||
*/
|
|
||||||
static Rand64 nextrand (Rand64 *state) {
|
|
||||||
Rand64 res = times9(rotl(times5(state[1]), 7));
|
|
||||||
Rand64 t = Ishl(state[1], 17);
|
|
||||||
Ixor(&state[2], state[0]);
|
|
||||||
Ixor(&state[3], state[1]);
|
|
||||||
Ixor(&state[1], state[2]);
|
|
||||||
Ixor(&state[0], state[3]);
|
|
||||||
Ixor(&state[2], t);
|
|
||||||
state[3] = rotl1(state[3], 45);
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Converts a 'Rand64' into a float.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* an unsigned 1 with proper type */
|
|
||||||
#define UONE ((lu_int32)1)
|
|
||||||
|
|
||||||
|
|
||||||
#if FIGS <= 32
|
|
||||||
|
|
||||||
/* 2^(-FIGS) */
|
|
||||||
#define scaleFIG (l_mathop(0.5) / (UONE << (FIGS - 1)))
|
|
||||||
|
|
||||||
/*
|
|
||||||
** get up to 32 bits from higher half, shifting right to
|
|
||||||
** throw out the extra bits.
|
|
||||||
*/
|
|
||||||
static lua_Number I2d (Rand64 x) {
|
|
||||||
lua_Number h = (lua_Number)(trim32(x.h) >> (32 - FIGS));
|
|
||||||
return h * scaleFIG;
|
|
||||||
}
|
|
||||||
|
|
||||||
#else /* 32 < FIGS <= 64 */
|
|
||||||
|
|
||||||
/* must take care to not shift stuff by more than 31 slots */
|
|
||||||
|
|
||||||
/* 2^(-FIGS) = 1.0 / 2^30 / 2^3 / 2^(FIGS-33) */
|
|
||||||
#define scaleFIG \
|
|
||||||
(l_mathop(1.0) / (UONE << 30) / l_mathop(8.0) / (UONE << (FIGS - 33)))
|
|
||||||
|
|
||||||
/*
|
|
||||||
** use FIGS - 32 bits from lower half, throwing out the other
|
|
||||||
** (32 - (FIGS - 32)) = (64 - FIGS) bits
|
|
||||||
*/
|
|
||||||
#define shiftLOW (64 - FIGS)
|
|
||||||
|
|
||||||
/*
|
|
||||||
** higher 32 bits go after those (FIGS - 32) bits: shiftHI = 2^(FIGS - 32)
|
|
||||||
*/
|
|
||||||
#define shiftHI ((lua_Number)(UONE << (FIGS - 33)) * l_mathop(2.0))
|
|
||||||
|
|
||||||
|
|
||||||
static lua_Number I2d (Rand64 x) {
|
|
||||||
lua_Number h = (lua_Number)trim32(x.h) * shiftHI;
|
|
||||||
lua_Number l = (lua_Number)(trim32(x.l) >> shiftLOW);
|
|
||||||
return (h + l) * scaleFIG;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/* convert a 'Rand64' to a 'lua_Unsigned' */
|
|
||||||
static lua_Unsigned I2UInt (Rand64 x) {
|
|
||||||
return (((lua_Unsigned)trim32(x.h) << 31) << 1) | (lua_Unsigned)trim32(x.l);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* convert a 'lua_Unsigned' to a 'Rand64' */
|
|
||||||
static Rand64 Int2I (lua_Unsigned n) {
|
|
||||||
return packI((lu_int32)((n >> 31) >> 1), (lu_int32)n);
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** A state uses four 'Rand64' values.
|
|
||||||
*/
|
|
||||||
typedef struct {
|
|
||||||
Rand64 s[4];
|
|
||||||
} RanState;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Project the random integer 'ran' into the interval [0, n].
|
|
||||||
** Because 'ran' has 2^B possible values, the projection can only be
|
|
||||||
** uniform when the size of the interval is a power of 2 (exact
|
|
||||||
** division). Otherwise, to get a uniform projection into [0, n], we
|
|
||||||
** first compute 'lim', the smallest Mersenne number not smaller than
|
|
||||||
** 'n'. We then project 'ran' into the interval [0, lim]. If the result
|
|
||||||
** is inside [0, n], we are done. Otherwise, we try with another 'ran',
|
|
||||||
** until we have a result inside the interval.
|
|
||||||
*/
|
|
||||||
static lua_Unsigned project (lua_Unsigned ran, lua_Unsigned n,
|
|
||||||
RanState *state) {
|
|
||||||
if ((n & (n + 1)) == 0) /* is 'n + 1' a power of 2? */
|
|
||||||
return ran & n; /* no bias */
|
|
||||||
else {
|
|
||||||
lua_Unsigned lim = n;
|
|
||||||
/* compute the smallest (2^b - 1) not smaller than 'n' */
|
|
||||||
lim |= (lim >> 1);
|
|
||||||
lim |= (lim >> 2);
|
|
||||||
lim |= (lim >> 4);
|
|
||||||
lim |= (lim >> 8);
|
|
||||||
lim |= (lim >> 16);
|
|
||||||
#if (LUA_MAXUNSIGNED >> 31) >= 3
|
|
||||||
lim |= (lim >> 32); /* integer type has more than 32 bits */
|
|
||||||
#endif
|
|
||||||
lua_assert((lim & (lim + 1)) == 0 /* 'lim + 1' is a power of 2, */
|
|
||||||
&& lim >= n /* not smaller than 'n', */
|
|
||||||
&& (lim >> 1) < n); /* and it is the smallest one */
|
|
||||||
while ((ran &= lim) > n) /* project 'ran' into [0..lim] */
|
|
||||||
ran = I2UInt(nextrand(state->s)); /* not inside [0..n]? try again */
|
|
||||||
return ran;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_random (lua_State *L) {
|
|
||||||
lua_Integer low, up;
|
|
||||||
lua_Unsigned p;
|
|
||||||
RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
|
|
||||||
Rand64 rv = nextrand(state->s); /* next pseudo-random value */
|
|
||||||
switch (lua_gettop(L)) { /* check number of arguments */
|
|
||||||
case 0: { /* no arguments */
|
|
||||||
lua_pushnumber(L, I2d(rv)); /* float between 0 and 1 */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
case 1: { /* only upper limit */
|
|
||||||
low = 1;
|
|
||||||
up = luaL_checkinteger(L, 1);
|
|
||||||
if (up == 0) { /* single 0 as argument? */
|
|
||||||
lua_pushinteger(L, I2UInt(rv)); /* full random integer */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 2: { /* lower and upper limits */
|
|
||||||
low = luaL_checkinteger(L, 1);
|
|
||||||
up = luaL_checkinteger(L, 2);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
default: return luaL_error(L, "wrong number of arguments");
|
|
||||||
}
|
|
||||||
/* random integer in the interval [low, up] */
|
|
||||||
luaL_argcheck(L, low <= up, 1, "interval is empty");
|
|
||||||
/* project random integer into the interval [0, up - low] */
|
|
||||||
p = project(I2UInt(rv), (lua_Unsigned)up - (lua_Unsigned)low, state);
|
|
||||||
lua_pushinteger(L, p + (lua_Unsigned)low);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void setseed (lua_State *L, Rand64 *state,
|
|
||||||
lua_Unsigned n1, lua_Unsigned n2) {
|
|
||||||
int i;
|
|
||||||
state[0] = Int2I(n1);
|
|
||||||
state[1] = Int2I(0xff); /* avoid a zero state */
|
|
||||||
state[2] = Int2I(n2);
|
|
||||||
state[3] = Int2I(0);
|
|
||||||
for (i = 0; i < 16; i++)
|
|
||||||
nextrand(state); /* discard initial values to "spread" seed */
|
|
||||||
lua_pushinteger(L, n1);
|
|
||||||
lua_pushinteger(L, n2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Set a "random" seed. To get some randomness, use the current time
|
|
||||||
** and the address of 'L' (in case the machine does address space layout
|
|
||||||
** randomization).
|
|
||||||
*/
|
|
||||||
static void randseed (lua_State *L, RanState *state) {
|
|
||||||
lua_Unsigned seed1 = (lua_Unsigned)time(NULL);
|
|
||||||
lua_Unsigned seed2 = (lua_Unsigned)(size_t)L;
|
|
||||||
setseed(L, state->s, seed1, seed2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int math_randomseed (lua_State *L) {
|
|
||||||
RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
|
|
||||||
if (lua_isnone(L, 1)) {
|
|
||||||
randseed(L, state);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_Integer n1 = luaL_checkinteger(L, 1);
|
|
||||||
lua_Integer n2 = luaL_optinteger(L, 2, 0);
|
|
||||||
setseed(L, state->s, n1, n2);
|
|
||||||
}
|
|
||||||
return 2; /* return seeds */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg randfuncs[] = {
|
|
||||||
{"random", math_random},
|
|
||||||
{"randomseed", math_randomseed},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Register the random functions and initialize their state.
|
|
||||||
*/
|
|
||||||
static void setrandfunc (lua_State *L) {
|
|
||||||
RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0);
|
|
||||||
randseed(L, state); /* initialize with a "random" seed */
|
|
||||||
lua_pop(L, 2); /* remove pushed seeds */
|
|
||||||
luaL_setfuncs(L, randfuncs, 1);
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Deprecated functions (for compatibility only)
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
#if defined(LUA_COMPAT_MATHLIB)
|
|
||||||
|
|
||||||
static int math_cosh (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_sinh (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_tanh (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_pow (lua_State *L) {
|
|
||||||
lua_Number x = luaL_checknumber(L, 1);
|
|
||||||
lua_Number y = luaL_checknumber(L, 2);
|
|
||||||
lua_pushnumber(L, l_mathop(pow)(x, y));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_frexp (lua_State *L) {
|
|
||||||
int e;
|
|
||||||
lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
|
|
||||||
lua_pushinteger(L, e);
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_ldexp (lua_State *L) {
|
|
||||||
lua_Number x = luaL_checknumber(L, 1);
|
|
||||||
int ep = (int)luaL_checkinteger(L, 2);
|
|
||||||
lua_pushnumber(L, l_mathop(ldexp)(x, ep));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
static int math_log10 (lua_State *L) {
|
|
||||||
lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg mathlib[] = {
|
|
||||||
{"abs", math_abs},
|
|
||||||
{"acos", math_acos},
|
|
||||||
{"asin", math_asin},
|
|
||||||
{"atan", math_atan},
|
|
||||||
{"ceil", math_ceil},
|
|
||||||
{"cos", math_cos},
|
|
||||||
{"deg", math_deg},
|
|
||||||
{"exp", math_exp},
|
|
||||||
{"tointeger", math_toint},
|
|
||||||
{"floor", math_floor},
|
|
||||||
{"fmod", math_fmod},
|
|
||||||
{"ult", math_ult},
|
|
||||||
{"log", math_log},
|
|
||||||
{"max", math_max},
|
|
||||||
{"min", math_min},
|
|
||||||
{"modf", math_modf},
|
|
||||||
{"rad", math_rad},
|
|
||||||
{"sin", math_sin},
|
|
||||||
{"sqrt", math_sqrt},
|
|
||||||
{"tan", math_tan},
|
|
||||||
{"type", math_type},
|
|
||||||
#if defined(LUA_COMPAT_MATHLIB)
|
|
||||||
{"atan2", math_atan},
|
|
||||||
{"cosh", math_cosh},
|
|
||||||
{"sinh", math_sinh},
|
|
||||||
{"tanh", math_tanh},
|
|
||||||
{"pow", math_pow},
|
|
||||||
{"frexp", math_frexp},
|
|
||||||
{"ldexp", math_ldexp},
|
|
||||||
{"log10", math_log10},
|
|
||||||
#endif
|
|
||||||
/* placeholders */
|
|
||||||
{"random", NULL},
|
|
||||||
{"randomseed", NULL},
|
|
||||||
{"pi", NULL},
|
|
||||||
{"huge", NULL},
|
|
||||||
{"maxinteger", NULL},
|
|
||||||
{"mininteger", NULL},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Open math library
|
|
||||||
*/
|
|
||||||
LUAMOD_API int luaopen_math (lua_State *L) {
|
|
||||||
luaL_newlib(L, mathlib);
|
|
||||||
lua_pushnumber(L, PI);
|
|
||||||
lua_setfield(L, -2, "pi");
|
|
||||||
lua_pushnumber(L, (lua_Number)HUGE_VAL);
|
|
||||||
lua_setfield(L, -2, "huge");
|
|
||||||
lua_pushinteger(L, LUA_MAXINTEGER);
|
|
||||||
lua_setfield(L, -2, "maxinteger");
|
|
||||||
lua_pushinteger(L, LUA_MININTEGER);
|
|
||||||
lua_setfield(L, -2, "mininteger");
|
|
||||||
setrandfunc(L);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,215 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lmem.c $
|
|
||||||
** Interface to Memory Manager
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lmem_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "ldebug.h"
|
|
||||||
#include "ldo.h"
|
|
||||||
#include "lgc.h"
|
|
||||||
#include "lmem.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** About the realloc function:
|
|
||||||
** void *frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
|
|
||||||
** ('osize' is the old size, 'nsize' is the new size)
|
|
||||||
**
|
|
||||||
** - frealloc(ud, p, x, 0) frees the block 'p' and returns NULL.
|
|
||||||
** Particularly, frealloc(ud, NULL, 0, 0) does nothing,
|
|
||||||
** which is equivalent to free(NULL) in ISO C.
|
|
||||||
**
|
|
||||||
** - frealloc(ud, NULL, x, s) creates a new block of size 's'
|
|
||||||
** (no matter 'x'). Returns NULL if it cannot create the new block.
|
|
||||||
**
|
|
||||||
** - otherwise, frealloc(ud, b, x, y) reallocates the block 'b' from
|
|
||||||
** size 'x' to size 'y'. Returns NULL if it cannot reallocate the
|
|
||||||
** block to the new size.
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Macro to call the allocation function.
|
|
||||||
*/
|
|
||||||
#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** When an allocation fails, it will try again after an emergency
|
|
||||||
** collection, except when it cannot run a collection. The GC should
|
|
||||||
** not be called while the state is not fully built, as the collector
|
|
||||||
** is not yet fully initialized. Also, it should not be called when
|
|
||||||
** 'gcstopem' is true, because then the interpreter is in the middle of
|
|
||||||
** a collection step.
|
|
||||||
*/
|
|
||||||
#define cantryagain(g) (completestate(g) && !g->gcstopem)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(EMERGENCYGCTESTS)
|
|
||||||
/*
|
|
||||||
** First allocation will fail except when freeing a block (frees never
|
|
||||||
** fail) and when it cannot try again; this fail will trigger 'tryagain'
|
|
||||||
** and a full GC cycle at every allocation.
|
|
||||||
*/
|
|
||||||
static void *firsttry (global_State *g, void *block, size_t os, size_t ns) {
|
|
||||||
if (ns > 0 && cantryagain(g))
|
|
||||||
return NULL; /* fail */
|
|
||||||
else /* normal allocation */
|
|
||||||
return callfrealloc(g, block, os, ns);
|
|
||||||
}
|
|
||||||
#else
|
|
||||||
#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Functions to allocate/deallocate arrays for the Parser
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Minimum size for arrays during parsing, to avoid overhead of
|
|
||||||
** reallocating to size 1, then 2, and then 4. All these arrays
|
|
||||||
** will be reallocated to exact sizes or erased when parsing ends.
|
|
||||||
*/
|
|
||||||
#define MINSIZEARRAY 4
|
|
||||||
|
|
||||||
|
|
||||||
void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
|
|
||||||
int size_elems, int limit, const char *what) {
|
|
||||||
void *newblock;
|
|
||||||
int size = *psize;
|
|
||||||
if (nelems + 1 <= size) /* does one extra element still fit? */
|
|
||||||
return block; /* nothing to be done */
|
|
||||||
if (size >= limit / 2) { /* cannot double it? */
|
|
||||||
if (l_unlikely(size >= limit)) /* cannot grow even a little? */
|
|
||||||
luaG_runerror(L, "too many %s (limit is %d)", what, limit);
|
|
||||||
size = limit; /* still have at least one free place */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
size *= 2;
|
|
||||||
if (size < MINSIZEARRAY)
|
|
||||||
size = MINSIZEARRAY; /* minimum size */
|
|
||||||
}
|
|
||||||
lua_assert(nelems + 1 <= size && size <= limit);
|
|
||||||
/* 'limit' ensures that multiplication will not overflow */
|
|
||||||
newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems,
|
|
||||||
cast_sizet(size) * size_elems);
|
|
||||||
*psize = size; /* update only when everything else is OK */
|
|
||||||
return newblock;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** In prototypes, the size of the array is also its number of
|
|
||||||
** elements (to save memory). So, if it cannot shrink an array
|
|
||||||
** to its number of elements, the only option is to raise an
|
|
||||||
** error.
|
|
||||||
*/
|
|
||||||
void *luaM_shrinkvector_ (lua_State *L, void *block, int *size,
|
|
||||||
int final_n, int size_elem) {
|
|
||||||
void *newblock;
|
|
||||||
size_t oldsize = cast_sizet((*size) * size_elem);
|
|
||||||
size_t newsize = cast_sizet(final_n * size_elem);
|
|
||||||
lua_assert(newsize <= oldsize);
|
|
||||||
newblock = luaM_saferealloc_(L, block, oldsize, newsize);
|
|
||||||
*size = final_n;
|
|
||||||
return newblock;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
l_noret luaM_toobig (lua_State *L) {
|
|
||||||
luaG_runerror(L, "memory allocation error: block too big");
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Free memory
|
|
||||||
*/
|
|
||||||
void luaM_free_ (lua_State *L, void *block, size_t osize) {
|
|
||||||
global_State *g = G(L);
|
|
||||||
lua_assert((osize == 0) == (block == NULL));
|
|
||||||
callfrealloc(g, block, osize, 0);
|
|
||||||
g->GCdebt -= osize;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** In case of allocation fail, this function will do an emergency
|
|
||||||
** collection to free some memory and then try the allocation again.
|
|
||||||
*/
|
|
||||||
static void *tryagain (lua_State *L, void *block,
|
|
||||||
size_t osize, size_t nsize) {
|
|
||||||
global_State *g = G(L);
|
|
||||||
if (cantryagain(g)) {
|
|
||||||
luaC_fullgc(L, 1); /* try to free some memory... */
|
|
||||||
return callfrealloc(g, block, osize, nsize); /* try again */
|
|
||||||
}
|
|
||||||
else return NULL; /* cannot run an emergency collection */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Generic allocation routine.
|
|
||||||
*/
|
|
||||||
void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
|
|
||||||
void *newblock;
|
|
||||||
global_State *g = G(L);
|
|
||||||
lua_assert((osize == 0) == (block == NULL));
|
|
||||||
newblock = firsttry(g, block, osize, nsize);
|
|
||||||
if (l_unlikely(newblock == NULL && nsize > 0)) {
|
|
||||||
newblock = tryagain(L, block, osize, nsize);
|
|
||||||
if (newblock == NULL) /* still no memory? */
|
|
||||||
return NULL; /* do not update 'GCdebt' */
|
|
||||||
}
|
|
||||||
lua_assert((nsize == 0) == (newblock == NULL));
|
|
||||||
g->GCdebt = (g->GCdebt + nsize) - osize;
|
|
||||||
return newblock;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize,
|
|
||||||
size_t nsize) {
|
|
||||||
void *newblock = luaM_realloc_(L, block, osize, nsize);
|
|
||||||
if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */
|
|
||||||
luaM_error(L);
|
|
||||||
return newblock;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
|
|
||||||
if (size == 0)
|
|
||||||
return NULL; /* that's all */
|
|
||||||
else {
|
|
||||||
global_State *g = G(L);
|
|
||||||
void *newblock = firsttry(g, NULL, tag, size);
|
|
||||||
if (l_unlikely(newblock == NULL)) {
|
|
||||||
newblock = tryagain(L, NULL, tag, size);
|
|
||||||
if (newblock == NULL)
|
|
||||||
luaM_error(L);
|
|
||||||
}
|
|
||||||
g->GCdebt += size;
|
|
||||||
return newblock;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
@ -1,93 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lmem.h $
|
|
||||||
** Interface to Memory Manager
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lmem_h
|
|
||||||
#define lmem_h
|
|
||||||
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
#define luaM_error(L) luaD_throw(L, LUA_ERRMEM)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** This macro tests whether it is safe to multiply 'n' by the size of
|
|
||||||
** type 't' without overflows. Because 'e' is always constant, it avoids
|
|
||||||
** the runtime division MAX_SIZET/(e).
|
|
||||||
** (The macro is somewhat complex to avoid warnings: The 'sizeof'
|
|
||||||
** comparison avoids a runtime comparison when overflow cannot occur.
|
|
||||||
** The compiler should be able to optimize the real test by itself, but
|
|
||||||
** when it does it, it may give a warning about "comparison is always
|
|
||||||
** false due to limited range of data type"; the +1 tricks the compiler,
|
|
||||||
** avoiding this warning but also this optimization.)
|
|
||||||
*/
|
|
||||||
#define luaM_testsize(n,e) \
|
|
||||||
(sizeof(n) >= sizeof(size_t) && cast_sizet((n)) + 1 > MAX_SIZET/(e))
|
|
||||||
|
|
||||||
#define luaM_checksize(L,n,e) \
|
|
||||||
(luaM_testsize(n,e) ? luaM_toobig(L) : cast_void(0))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Computes the minimum between 'n' and 'MAX_SIZET/sizeof(t)', so that
|
|
||||||
** the result is not larger than 'n' and cannot overflow a 'size_t'
|
|
||||||
** when multiplied by the size of type 't'. (Assumes that 'n' is an
|
|
||||||
** 'int' or 'unsigned int' and that 'int' is not larger than 'size_t'.)
|
|
||||||
*/
|
|
||||||
#define luaM_limitN(n,t) \
|
|
||||||
((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \
|
|
||||||
cast_uint((MAX_SIZET/sizeof(t))))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Arrays of chars do not need any test
|
|
||||||
*/
|
|
||||||
#define luaM_reallocvchar(L,b,on,n) \
|
|
||||||
cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
|
|
||||||
|
|
||||||
#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s))
|
|
||||||
#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b)))
|
|
||||||
#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b)))
|
|
||||||
|
|
||||||
#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0))
|
|
||||||
#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0))
|
|
||||||
#define luaM_newvectorchecked(L,n,t) \
|
|
||||||
(luaM_checksize(L,n,sizeof(t)), luaM_newvector(L,n,t))
|
|
||||||
|
|
||||||
#define luaM_newobject(L,tag,s) luaM_malloc_(L, (s), tag)
|
|
||||||
|
|
||||||
#define luaM_growvector(L,v,nelems,size,t,limit,e) \
|
|
||||||
((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \
|
|
||||||
luaM_limitN(limit,t),e)))
|
|
||||||
|
|
||||||
#define luaM_reallocvector(L, v,oldn,n,t) \
|
|
||||||
(cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \
|
|
||||||
cast_sizet(n) * sizeof(t))))
|
|
||||||
|
|
||||||
#define luaM_shrinkvector(L,v,size,fs,t) \
|
|
||||||
((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t))))
|
|
||||||
|
|
||||||
LUAI_FUNC l_noret luaM_toobig (lua_State *L);
|
|
||||||
|
|
||||||
/* not to be called directly */
|
|
||||||
LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
|
|
||||||
size_t size);
|
|
||||||
LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize,
|
|
||||||
size_t size);
|
|
||||||
LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize);
|
|
||||||
LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems,
|
|
||||||
int *size, int size_elem, int limit,
|
|
||||||
const char *what);
|
|
||||||
LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem,
|
|
||||||
int final_n, int size_elem);
|
|
||||||
LUAI_FUNC void *luaM_malloc_ (lua_State *L, size_t size, int tag);
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,767 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: loadlib.c $
|
|
||||||
** Dynamic library loader for Lua
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
**
|
|
||||||
** This module contains an implementation of loadlib for Unix systems
|
|
||||||
** that have dlfcn, an implementation for Windows, and a stub for other
|
|
||||||
** systems.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define loadlib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** LUA_IGMARK is a mark to ignore all before it when building the
|
|
||||||
** luaopen_ function name.
|
|
||||||
*/
|
|
||||||
#if !defined (LUA_IGMARK)
|
|
||||||
#define LUA_IGMARK "-"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** LUA_CSUBSEP is the character that replaces dots in submodule names
|
|
||||||
** when searching for a C loader.
|
|
||||||
** LUA_LSUBSEP is the character that replaces dots in submodule names
|
|
||||||
** when searching for a Lua loader.
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_CSUBSEP)
|
|
||||||
#define LUA_CSUBSEP LUA_DIRSEP
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(LUA_LSUBSEP)
|
|
||||||
#define LUA_LSUBSEP LUA_DIRSEP
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/* prefix for open functions in C libraries */
|
|
||||||
#define LUA_POF "luaopen_"
|
|
||||||
|
|
||||||
/* separator for open functions in C libraries */
|
|
||||||
#define LUA_OFSEP "_"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** key for table in the registry that keeps handles
|
|
||||||
** for all loaded C libraries
|
|
||||||
*/
|
|
||||||
static const char *const CLIBS = "_CLIBS";
|
|
||||||
|
|
||||||
#define LIB_FAIL "open"
|
|
||||||
|
|
||||||
|
|
||||||
#define setprogdir(L) ((void)0)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Special type equivalent to '(void*)' for functions in gcc
|
|
||||||
** (to suppress warnings when converting function pointers)
|
|
||||||
*/
|
|
||||||
typedef void (*voidf)(void);
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** system-dependent functions
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** unload library 'lib'
|
|
||||||
*/
|
|
||||||
static void lsys_unloadlib (void *lib);
|
|
||||||
|
|
||||||
/*
|
|
||||||
** load C library in file 'path'. If 'seeglb', load with all names in
|
|
||||||
** the library global.
|
|
||||||
** Returns the library; in case of error, returns NULL plus an
|
|
||||||
** error string in the stack.
|
|
||||||
*/
|
|
||||||
static void *lsys_load (lua_State *L, const char *path, int seeglb);
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Try to find a function named 'sym' in library 'lib'.
|
|
||||||
** Returns the function; in case of error, returns NULL plus an
|
|
||||||
** error string in the stack.
|
|
||||||
*/
|
|
||||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym);
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#if defined(LUA_USE_DLOPEN) /* { */
|
|
||||||
/*
|
|
||||||
** {========================================================================
|
|
||||||
** This is an implementation of loadlib based on the dlfcn interface.
|
|
||||||
** The dlfcn interface is available in Linux, SunOS, Solaris, IRIX, FreeBSD,
|
|
||||||
** NetBSD, AIX 4.2, HPUX 11, and probably most other Unix flavors, at least
|
|
||||||
** as an emulation layer on top of native functions.
|
|
||||||
** =========================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <dlfcn.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Macro to convert pointer-to-void* to pointer-to-function. This cast
|
|
||||||
** is undefined according to ISO C, but POSIX assumes that it works.
|
|
||||||
** (The '__extension__' in gnu compilers is only to avoid warnings.)
|
|
||||||
*/
|
|
||||||
#if defined(__GNUC__)
|
|
||||||
#define cast_func(p) (__extension__ (lua_CFunction)(p))
|
|
||||||
#else
|
|
||||||
#define cast_func(p) ((lua_CFunction)(p))
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
static void lsys_unloadlib (void *lib) {
|
|
||||||
dlclose(lib);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void *lsys_load (lua_State *L, const char *path, int seeglb) {
|
|
||||||
void *lib = dlopen(path, RTLD_NOW | (seeglb ? RTLD_GLOBAL : RTLD_LOCAL));
|
|
||||||
if (l_unlikely(lib == NULL))
|
|
||||||
lua_pushstring(L, dlerror());
|
|
||||||
return lib;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
|
|
||||||
lua_CFunction f = cast_func(dlsym(lib, sym));
|
|
||||||
if (l_unlikely(f == NULL))
|
|
||||||
lua_pushstring(L, dlerror());
|
|
||||||
return f;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#elif defined(LUA_DL_DLL) /* }{ */
|
|
||||||
/*
|
|
||||||
** {======================================================================
|
|
||||||
** This is an implementation of loadlib for Windows using native functions.
|
|
||||||
** =======================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#include <windows.h>
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** optional flags for LoadLibraryEx
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_LLE_FLAGS)
|
|
||||||
#define LUA_LLE_FLAGS 0
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
#undef setprogdir
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Replace in the path (on the top of the stack) any occurrence
|
|
||||||
** of LUA_EXEC_DIR with the executable's path.
|
|
||||||
*/
|
|
||||||
static void setprogdir (lua_State *L) {
|
|
||||||
char buff[MAX_PATH + 1];
|
|
||||||
char *lb;
|
|
||||||
DWORD nsize = sizeof(buff)/sizeof(char);
|
|
||||||
DWORD n = GetModuleFileNameA(NULL, buff, nsize); /* get exec. name */
|
|
||||||
if (n == 0 || n == nsize || (lb = strrchr(buff, '\\')) == NULL)
|
|
||||||
luaL_error(L, "unable to get ModuleFileName");
|
|
||||||
else {
|
|
||||||
*lb = '\0'; /* cut name on the last '\\' to get the path */
|
|
||||||
luaL_gsub(L, lua_tostring(L, -1), LUA_EXEC_DIR, buff);
|
|
||||||
lua_remove(L, -2); /* remove original string */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
static void pusherror (lua_State *L) {
|
|
||||||
int error = GetLastError();
|
|
||||||
char buffer[128];
|
|
||||||
if (FormatMessageA(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
||||||
NULL, error, 0, buffer, sizeof(buffer)/sizeof(char), NULL))
|
|
||||||
lua_pushstring(L, buffer);
|
|
||||||
else
|
|
||||||
lua_pushfstring(L, "system error %d\n", error);
|
|
||||||
}
|
|
||||||
|
|
||||||
static void lsys_unloadlib (void *lib) {
|
|
||||||
FreeLibrary((HMODULE)lib);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void *lsys_load (lua_State *L, const char *path, int seeglb) {
|
|
||||||
HMODULE lib = LoadLibraryExA(path, NULL, LUA_LLE_FLAGS);
|
|
||||||
(void)(seeglb); /* not used: symbols are 'global' by default */
|
|
||||||
if (lib == NULL) pusherror(L);
|
|
||||||
return lib;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
|
|
||||||
lua_CFunction f = (lua_CFunction)(voidf)GetProcAddress((HMODULE)lib, sym);
|
|
||||||
if (f == NULL) pusherror(L);
|
|
||||||
return f;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** Fallback for other systems
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#undef LIB_FAIL
|
|
||||||
#define LIB_FAIL "absent"
|
|
||||||
|
|
||||||
|
|
||||||
#define DLMSG "dynamic libraries not enabled; check your Lua installation"
|
|
||||||
|
|
||||||
|
|
||||||
static void lsys_unloadlib (void *lib) {
|
|
||||||
(void)(lib); /* not used */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void *lsys_load (lua_State *L, const char *path, int seeglb) {
|
|
||||||
(void)(path); (void)(seeglb); /* not used */
|
|
||||||
lua_pushliteral(L, DLMSG);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static lua_CFunction lsys_sym (lua_State *L, void *lib, const char *sym) {
|
|
||||||
(void)(lib); (void)(sym); /* not used */
|
|
||||||
lua_pushliteral(L, DLMSG);
|
|
||||||
return NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Set Paths
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** LUA_PATH_VAR and LUA_CPATH_VAR are the names of the environment
|
|
||||||
** variables that Lua check to set its paths.
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_PATH_VAR)
|
|
||||||
#define LUA_PATH_VAR "LUA_PATH"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if !defined(LUA_CPATH_VAR)
|
|
||||||
#define LUA_CPATH_VAR "LUA_CPATH"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** return registry.LUA_NOENV as a boolean
|
|
||||||
*/
|
|
||||||
static int noenv (lua_State *L) {
|
|
||||||
int b;
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, "LUA_NOENV");
|
|
||||||
b = lua_toboolean(L, -1);
|
|
||||||
lua_pop(L, 1); /* remove value */
|
|
||||||
return b;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Set a path
|
|
||||||
*/
|
|
||||||
static void setpath (lua_State *L, const char *fieldname,
|
|
||||||
const char *envname,
|
|
||||||
const char *dft) {
|
|
||||||
const char *dftmark;
|
|
||||||
const char *nver = lua_pushfstring(L, "%s%s", envname, LUA_VERSUFFIX);
|
|
||||||
const char *path = getenv(nver); /* try versioned name */
|
|
||||||
if (path == NULL) /* no versioned environment variable? */
|
|
||||||
path = getenv(envname); /* try unversioned name */
|
|
||||||
if (path == NULL || noenv(L)) /* no environment variable? */
|
|
||||||
lua_pushstring(L, dft); /* use default */
|
|
||||||
else if ((dftmark = strstr(path, LUA_PATH_SEP LUA_PATH_SEP)) == NULL)
|
|
||||||
lua_pushstring(L, path); /* nothing to change */
|
|
||||||
else { /* path contains a ";;": insert default path in its place */
|
|
||||||
size_t len = strlen(path);
|
|
||||||
luaL_Buffer b;
|
|
||||||
luaL_buffinit(L, &b);
|
|
||||||
if (path < dftmark) { /* is there a prefix before ';;'? */
|
|
||||||
luaL_addlstring(&b, path, dftmark - path); /* add it */
|
|
||||||
luaL_addchar(&b, *LUA_PATH_SEP);
|
|
||||||
}
|
|
||||||
luaL_addstring(&b, dft); /* add default */
|
|
||||||
if (dftmark < path + len - 2) { /* is there a suffix after ';;'? */
|
|
||||||
luaL_addchar(&b, *LUA_PATH_SEP);
|
|
||||||
luaL_addlstring(&b, dftmark + 2, (path + len - 2) - dftmark);
|
|
||||||
}
|
|
||||||
luaL_pushresult(&b);
|
|
||||||
}
|
|
||||||
setprogdir(L);
|
|
||||||
lua_setfield(L, -3, fieldname); /* package[fieldname] = path value */
|
|
||||||
lua_pop(L, 1); /* pop versioned variable name ('nver') */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** return registry.CLIBS[path]
|
|
||||||
*/
|
|
||||||
static void *checkclib (lua_State *L, const char *path) {
|
|
||||||
void *plib;
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
|
|
||||||
lua_getfield(L, -1, path);
|
|
||||||
plib = lua_touserdata(L, -1); /* plib = CLIBS[path] */
|
|
||||||
lua_pop(L, 2); /* pop CLIBS table and 'plib' */
|
|
||||||
return plib;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** registry.CLIBS[path] = plib -- for queries
|
|
||||||
** registry.CLIBS[#CLIBS + 1] = plib -- also keep a list of all libraries
|
|
||||||
*/
|
|
||||||
static void addtoclib (lua_State *L, const char *path, void *plib) {
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, CLIBS);
|
|
||||||
lua_pushlightuserdata(L, plib);
|
|
||||||
lua_pushvalue(L, -1);
|
|
||||||
lua_setfield(L, -3, path); /* CLIBS[path] = plib */
|
|
||||||
lua_rawseti(L, -2, luaL_len(L, -2) + 1); /* CLIBS[#CLIBS + 1] = plib */
|
|
||||||
lua_pop(L, 1); /* pop CLIBS table */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** __gc tag method for CLIBS table: calls 'lsys_unloadlib' for all lib
|
|
||||||
** handles in list CLIBS
|
|
||||||
*/
|
|
||||||
static int gctm (lua_State *L) {
|
|
||||||
lua_Integer n = luaL_len(L, 1);
|
|
||||||
for (; n >= 1; n--) { /* for each handle, in reverse order */
|
|
||||||
lua_rawgeti(L, 1, n); /* get handle CLIBS[n] */
|
|
||||||
lsys_unloadlib(lua_touserdata(L, -1));
|
|
||||||
lua_pop(L, 1); /* pop handle */
|
|
||||||
}
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* error codes for 'lookforfunc' */
|
|
||||||
#define ERRLIB 1
|
|
||||||
#define ERRFUNC 2
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Look for a C function named 'sym' in a dynamically loaded library
|
|
||||||
** 'path'.
|
|
||||||
** First, check whether the library is already loaded; if not, try
|
|
||||||
** to load it.
|
|
||||||
** Then, if 'sym' is '*', return true (as library has been loaded).
|
|
||||||
** Otherwise, look for symbol 'sym' in the library and push a
|
|
||||||
** C function with that symbol.
|
|
||||||
** Return 0 and 'true' or a function in the stack; in case of
|
|
||||||
** errors, return an error code and an error message in the stack.
|
|
||||||
*/
|
|
||||||
static int lookforfunc (lua_State *L, const char *path, const char *sym) {
|
|
||||||
void *reg = checkclib(L, path); /* check loaded C libraries */
|
|
||||||
if (reg == NULL) { /* must load library? */
|
|
||||||
reg = lsys_load(L, path, *sym == '*'); /* global symbols if 'sym'=='*' */
|
|
||||||
if (reg == NULL) return ERRLIB; /* unable to load library */
|
|
||||||
addtoclib(L, path, reg);
|
|
||||||
}
|
|
||||||
if (*sym == '*') { /* loading only library (no function)? */
|
|
||||||
lua_pushboolean(L, 1); /* return 'true' */
|
|
||||||
return 0; /* no errors */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_CFunction f = lsys_sym(L, reg, sym);
|
|
||||||
if (f == NULL)
|
|
||||||
return ERRFUNC; /* unable to find function */
|
|
||||||
lua_pushcfunction(L, f); /* else create new function */
|
|
||||||
return 0; /* no errors */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int ll_loadlib (lua_State *L) {
|
|
||||||
const char *path = luaL_checkstring(L, 1);
|
|
||||||
const char *init = luaL_checkstring(L, 2);
|
|
||||||
int stat = lookforfunc(L, path, init);
|
|
||||||
if (l_likely(stat == 0)) /* no errors? */
|
|
||||||
return 1; /* return the loaded function */
|
|
||||||
else { /* error; error message is on stack top */
|
|
||||||
luaL_pushfail(L);
|
|
||||||
lua_insert(L, -2);
|
|
||||||
lua_pushstring(L, (stat == ERRLIB) ? LIB_FAIL : "init");
|
|
||||||
return 3; /* return fail, error message, and where */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** 'require' function
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
static int readable (const char *filename) {
|
|
||||||
FILE *f = fopen(filename, "r"); /* try to open file */
|
|
||||||
if (f == NULL) return 0; /* open failed */
|
|
||||||
fclose(f);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Get the next name in '*path' = 'name1;name2;name3;...', changing
|
|
||||||
** the ending ';' to '\0' to create a zero-terminated string. Return
|
|
||||||
** NULL when list ends.
|
|
||||||
*/
|
|
||||||
static const char *getnextfilename (char **path, char *end) {
|
|
||||||
char *sep;
|
|
||||||
char *name = *path;
|
|
||||||
if (name == end)
|
|
||||||
return NULL; /* no more names */
|
|
||||||
else if (*name == '\0') { /* from previous iteration? */
|
|
||||||
*name = *LUA_PATH_SEP; /* restore separator */
|
|
||||||
name++; /* skip it */
|
|
||||||
}
|
|
||||||
sep = strchr(name, *LUA_PATH_SEP); /* find next separator */
|
|
||||||
if (sep == NULL) /* separator not found? */
|
|
||||||
sep = end; /* name goes until the end */
|
|
||||||
*sep = '\0'; /* finish file name */
|
|
||||||
*path = sep; /* will start next search from here */
|
|
||||||
return name;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Given a path such as ";blabla.so;blublu.so", pushes the string
|
|
||||||
**
|
|
||||||
** no file 'blabla.so'
|
|
||||||
** no file 'blublu.so'
|
|
||||||
*/
|
|
||||||
static void pusherrornotfound (lua_State *L, const char *path) {
|
|
||||||
luaL_Buffer b;
|
|
||||||
luaL_buffinit(L, &b);
|
|
||||||
luaL_addstring(&b, "no file '");
|
|
||||||
luaL_addgsub(&b, path, LUA_PATH_SEP, "'\n\tno file '");
|
|
||||||
luaL_addstring(&b, "'");
|
|
||||||
luaL_pushresult(&b);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *searchpath (lua_State *L, const char *name,
|
|
||||||
const char *path,
|
|
||||||
const char *sep,
|
|
||||||
const char *dirsep) {
|
|
||||||
luaL_Buffer buff;
|
|
||||||
char *pathname; /* path with name inserted */
|
|
||||||
char *endpathname; /* its end */
|
|
||||||
const char *filename;
|
|
||||||
/* separator is non-empty and appears in 'name'? */
|
|
||||||
if (*sep != '\0' && strchr(name, *sep) != NULL)
|
|
||||||
name = luaL_gsub(L, name, sep, dirsep); /* replace it by 'dirsep' */
|
|
||||||
luaL_buffinit(L, &buff);
|
|
||||||
/* add path to the buffer, replacing marks ('?') with the file name */
|
|
||||||
luaL_addgsub(&buff, path, LUA_PATH_MARK, name);
|
|
||||||
luaL_addchar(&buff, '\0');
|
|
||||||
pathname = luaL_buffaddr(&buff); /* writable list of file names */
|
|
||||||
endpathname = pathname + luaL_bufflen(&buff) - 1;
|
|
||||||
while ((filename = getnextfilename(&pathname, endpathname)) != NULL) {
|
|
||||||
if (readable(filename)) /* does file exist and is readable? */
|
|
||||||
return lua_pushstring(L, filename); /* save and return name */
|
|
||||||
}
|
|
||||||
luaL_pushresult(&buff); /* push path to create error message */
|
|
||||||
pusherrornotfound(L, lua_tostring(L, -1)); /* create error message */
|
|
||||||
return NULL; /* not found */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int ll_searchpath (lua_State *L) {
|
|
||||||
const char *f = searchpath(L, luaL_checkstring(L, 1),
|
|
||||||
luaL_checkstring(L, 2),
|
|
||||||
luaL_optstring(L, 3, "."),
|
|
||||||
luaL_optstring(L, 4, LUA_DIRSEP));
|
|
||||||
if (f != NULL) return 1;
|
|
||||||
else { /* error message is on top of the stack */
|
|
||||||
luaL_pushfail(L);
|
|
||||||
lua_insert(L, -2);
|
|
||||||
return 2; /* return fail + error message */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *findfile (lua_State *L, const char *name,
|
|
||||||
const char *pname,
|
|
||||||
const char *dirsep) {
|
|
||||||
const char *path;
|
|
||||||
lua_getfield(L, lua_upvalueindex(1), pname);
|
|
||||||
path = lua_tostring(L, -1);
|
|
||||||
if (l_unlikely(path == NULL))
|
|
||||||
luaL_error(L, "'package.%s' must be a string", pname);
|
|
||||||
return searchpath(L, name, path, ".", dirsep);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int checkload (lua_State *L, int stat, const char *filename) {
|
|
||||||
if (l_likely(stat)) { /* module loaded successfully? */
|
|
||||||
lua_pushstring(L, filename); /* will be 2nd argument to module */
|
|
||||||
return 2; /* return open function and file name */
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return luaL_error(L, "error loading module '%s' from file '%s':\n\t%s",
|
|
||||||
lua_tostring(L, 1), filename, lua_tostring(L, -1));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int searcher_Lua (lua_State *L) {
|
|
||||||
const char *filename;
|
|
||||||
const char *name = luaL_checkstring(L, 1);
|
|
||||||
filename = findfile(L, name, "path", LUA_LSUBSEP);
|
|
||||||
if (filename == NULL) return 1; /* module not found in this path */
|
|
||||||
return checkload(L, (luaL_loadfile(L, filename) == LUA_OK), filename);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Try to find a load function for module 'modname' at file 'filename'.
|
|
||||||
** First, change '.' to '_' in 'modname'; then, if 'modname' has
|
|
||||||
** the form X-Y (that is, it has an "ignore mark"), build a function
|
|
||||||
** name "luaopen_X" and look for it. (For compatibility, if that
|
|
||||||
** fails, it also tries "luaopen_Y".) If there is no ignore mark,
|
|
||||||
** look for a function named "luaopen_modname".
|
|
||||||
*/
|
|
||||||
static int loadfunc (lua_State *L, const char *filename, const char *modname) {
|
|
||||||
const char *openfunc;
|
|
||||||
const char *mark;
|
|
||||||
modname = luaL_gsub(L, modname, ".", LUA_OFSEP);
|
|
||||||
mark = strchr(modname, *LUA_IGMARK);
|
|
||||||
if (mark) {
|
|
||||||
int stat;
|
|
||||||
openfunc = lua_pushlstring(L, modname, mark - modname);
|
|
||||||
openfunc = lua_pushfstring(L, LUA_POF"%s", openfunc);
|
|
||||||
stat = lookforfunc(L, filename, openfunc);
|
|
||||||
if (stat != ERRFUNC) return stat;
|
|
||||||
modname = mark + 1; /* else go ahead and try old-style name */
|
|
||||||
}
|
|
||||||
openfunc = lua_pushfstring(L, LUA_POF"%s", modname);
|
|
||||||
return lookforfunc(L, filename, openfunc);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int searcher_C (lua_State *L) {
|
|
||||||
const char *name = luaL_checkstring(L, 1);
|
|
||||||
const char *filename = findfile(L, name, "cpath", LUA_CSUBSEP);
|
|
||||||
if (filename == NULL) return 1; /* module not found in this path */
|
|
||||||
return checkload(L, (loadfunc(L, filename, name) == 0), filename);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int searcher_Croot (lua_State *L) {
|
|
||||||
const char *filename;
|
|
||||||
const char *name = luaL_checkstring(L, 1);
|
|
||||||
const char *p = strchr(name, '.');
|
|
||||||
int stat;
|
|
||||||
if (p == NULL) return 0; /* is root */
|
|
||||||
lua_pushlstring(L, name, p - name);
|
|
||||||
filename = findfile(L, lua_tostring(L, -1), "cpath", LUA_CSUBSEP);
|
|
||||||
if (filename == NULL) return 1; /* root not found */
|
|
||||||
if ((stat = loadfunc(L, filename, name)) != 0) {
|
|
||||||
if (stat != ERRFUNC)
|
|
||||||
return checkload(L, 0, filename); /* real error */
|
|
||||||
else { /* open function not found */
|
|
||||||
lua_pushfstring(L, "no module '%s' in file '%s'", name, filename);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
lua_pushstring(L, filename); /* will be 2nd argument to module */
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int searcher_preload (lua_State *L) {
|
|
||||||
const char *name = luaL_checkstring(L, 1);
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
|
|
||||||
if (lua_getfield(L, -1, name) == LUA_TNIL) { /* not found? */
|
|
||||||
lua_pushfstring(L, "no field package.preload['%s']", name);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
lua_pushliteral(L, ":preload:");
|
|
||||||
return 2;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void findloader (lua_State *L, const char *name) {
|
|
||||||
int i;
|
|
||||||
luaL_Buffer msg; /* to build error message */
|
|
||||||
/* push 'package.searchers' to index 3 in the stack */
|
|
||||||
if (l_unlikely(lua_getfield(L, lua_upvalueindex(1), "searchers")
|
|
||||||
!= LUA_TTABLE))
|
|
||||||
luaL_error(L, "'package.searchers' must be a table");
|
|
||||||
luaL_buffinit(L, &msg);
|
|
||||||
/* iterate over available searchers to find a loader */
|
|
||||||
for (i = 1; ; i++) {
|
|
||||||
luaL_addstring(&msg, "\n\t"); /* error-message prefix */
|
|
||||||
if (l_unlikely(lua_rawgeti(L, 3, i) == LUA_TNIL)) { /* no more searchers? */
|
|
||||||
lua_pop(L, 1); /* remove nil */
|
|
||||||
luaL_buffsub(&msg, 2); /* remove prefix */
|
|
||||||
luaL_pushresult(&msg); /* create error message */
|
|
||||||
luaL_error(L, "module '%s' not found:%s", name, lua_tostring(L, -1));
|
|
||||||
}
|
|
||||||
lua_pushstring(L, name);
|
|
||||||
lua_call(L, 1, 2); /* call it */
|
|
||||||
if (lua_isfunction(L, -2)) /* did it find a loader? */
|
|
||||||
return; /* module loader found */
|
|
||||||
else if (lua_isstring(L, -2)) { /* searcher returned error message? */
|
|
||||||
lua_pop(L, 1); /* remove extra return */
|
|
||||||
luaL_addvalue(&msg); /* concatenate error message */
|
|
||||||
}
|
|
||||||
else { /* no error message */
|
|
||||||
lua_pop(L, 2); /* remove both returns */
|
|
||||||
luaL_buffsub(&msg, 2); /* remove prefix */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int ll_require (lua_State *L) {
|
|
||||||
const char *name = luaL_checkstring(L, 1);
|
|
||||||
lua_settop(L, 1); /* LOADED table will be at index 2 */
|
|
||||||
lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
|
|
||||||
lua_getfield(L, 2, name); /* LOADED[name] */
|
|
||||||
if (lua_toboolean(L, -1)) /* is it there? */
|
|
||||||
return 1; /* package is already loaded */
|
|
||||||
/* else must load package */
|
|
||||||
lua_pop(L, 1); /* remove 'getfield' result */
|
|
||||||
findloader(L, name);
|
|
||||||
lua_rotate(L, -2, 1); /* function <-> loader data */
|
|
||||||
lua_pushvalue(L, 1); /* name is 1st argument to module loader */
|
|
||||||
lua_pushvalue(L, -3); /* loader data is 2nd argument */
|
|
||||||
/* stack: ...; loader data; loader function; mod. name; loader data */
|
|
||||||
lua_call(L, 2, 1); /* run loader to load module */
|
|
||||||
/* stack: ...; loader data; result from loader */
|
|
||||||
if (!lua_isnil(L, -1)) /* non-nil return? */
|
|
||||||
lua_setfield(L, 2, name); /* LOADED[name] = returned value */
|
|
||||||
else
|
|
||||||
lua_pop(L, 1); /* pop nil */
|
|
||||||
if (lua_getfield(L, 2, name) == LUA_TNIL) { /* module set no value? */
|
|
||||||
lua_pushboolean(L, 1); /* use true as result */
|
|
||||||
lua_copy(L, -1, -2); /* replace loader result */
|
|
||||||
lua_setfield(L, 2, name); /* LOADED[name] = true */
|
|
||||||
}
|
|
||||||
lua_rotate(L, -2, 1); /* loader data <-> module result */
|
|
||||||
return 2; /* return module result and loader data */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg pk_funcs[] = {
|
|
||||||
{"loadlib", ll_loadlib},
|
|
||||||
{"searchpath", ll_searchpath},
|
|
||||||
/* placeholders */
|
|
||||||
{"preload", NULL},
|
|
||||||
{"cpath", NULL},
|
|
||||||
{"path", NULL},
|
|
||||||
{"searchers", NULL},
|
|
||||||
{"loaded", NULL},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg ll_funcs[] = {
|
|
||||||
{"require", ll_require},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
static void createsearcherstable (lua_State *L) {
|
|
||||||
static const lua_CFunction searchers[] = {
|
|
||||||
searcher_preload,
|
|
||||||
searcher_Lua,
|
|
||||||
searcher_C,
|
|
||||||
searcher_Croot,
|
|
||||||
NULL
|
|
||||||
};
|
|
||||||
int i;
|
|
||||||
/* create 'searchers' table */
|
|
||||||
lua_createtable(L, sizeof(searchers)/sizeof(searchers[0]) - 1, 0);
|
|
||||||
/* fill it with predefined searchers */
|
|
||||||
for (i=0; searchers[i] != NULL; i++) {
|
|
||||||
lua_pushvalue(L, -2); /* set 'package' as upvalue for all searchers */
|
|
||||||
lua_pushcclosure(L, searchers[i], 1);
|
|
||||||
lua_rawseti(L, -2, i+1);
|
|
||||||
}
|
|
||||||
lua_setfield(L, -2, "searchers"); /* put it in field 'searchers' */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** create table CLIBS to keep track of loaded C libraries,
|
|
||||||
** setting a finalizer to close all libraries when closing state.
|
|
||||||
*/
|
|
||||||
static void createclibstable (lua_State *L) {
|
|
||||||
luaL_getsubtable(L, LUA_REGISTRYINDEX, CLIBS); /* create CLIBS table */
|
|
||||||
lua_createtable(L, 0, 1); /* create metatable for CLIBS */
|
|
||||||
lua_pushcfunction(L, gctm);
|
|
||||||
lua_setfield(L, -2, "__gc"); /* set finalizer for CLIBS table */
|
|
||||||
lua_setmetatable(L, -2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_package (lua_State *L) {
|
|
||||||
createclibstable(L);
|
|
||||||
luaL_newlib(L, pk_funcs); /* create 'package' table */
|
|
||||||
createsearcherstable(L);
|
|
||||||
/* set paths */
|
|
||||||
setpath(L, "path", LUA_PATH_VAR, LUA_PATH_DEFAULT);
|
|
||||||
setpath(L, "cpath", LUA_CPATH_VAR, LUA_CPATH_DEFAULT);
|
|
||||||
/* store config information */
|
|
||||||
lua_pushliteral(L, LUA_DIRSEP "\n" LUA_PATH_SEP "\n" LUA_PATH_MARK "\n"
|
|
||||||
LUA_EXEC_DIR "\n" LUA_IGMARK "\n");
|
|
||||||
lua_setfield(L, -2, "config");
|
|
||||||
/* set field 'loaded' */
|
|
||||||
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
|
|
||||||
lua_setfield(L, -2, "loaded");
|
|
||||||
/* set field 'preload' */
|
|
||||||
luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
|
|
||||||
lua_setfield(L, -2, "preload");
|
|
||||||
lua_pushglobaltable(L);
|
|
||||||
lua_pushvalue(L, -2); /* set 'package' as upvalue for next lib */
|
|
||||||
luaL_setfuncs(L, ll_funcs, 1); /* open lib into global table */
|
|
||||||
lua_pop(L, 1); /* pop global table */
|
|
||||||
return 1; /* return 'package' table */
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,602 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lobject.c $
|
|
||||||
** Some generic functions over Lua objects
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lobject_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <locale.h>
|
|
||||||
#include <math.h>
|
|
||||||
#include <stdarg.h>
|
|
||||||
#include <stdio.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lctype.h"
|
|
||||||
#include "ldebug.h"
|
|
||||||
#include "ldo.h"
|
|
||||||
#include "lmem.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
#include "lstring.h"
|
|
||||||
#include "lvm.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Computes ceil(log2(x))
|
|
||||||
*/
|
|
||||||
int luaO_ceillog2 (unsigned int x) {
|
|
||||||
static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */
|
|
||||||
0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
|
|
||||||
6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
|
|
||||||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
|
||||||
7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
|
|
||||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
||||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
||||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
|
|
||||||
8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
|
|
||||||
};
|
|
||||||
int l = 0;
|
|
||||||
x--;
|
|
||||||
while (x >= 256) { l += 8; x >>= 8; }
|
|
||||||
return l + log_2[x];
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static lua_Integer intarith (lua_State *L, int op, lua_Integer v1,
|
|
||||||
lua_Integer v2) {
|
|
||||||
switch (op) {
|
|
||||||
case LUA_OPADD: return intop(+, v1, v2);
|
|
||||||
case LUA_OPSUB:return intop(-, v1, v2);
|
|
||||||
case LUA_OPMUL:return intop(*, v1, v2);
|
|
||||||
case LUA_OPMOD: return luaV_mod(L, v1, v2);
|
|
||||||
case LUA_OPIDIV: return luaV_idiv(L, v1, v2);
|
|
||||||
case LUA_OPBAND: return intop(&, v1, v2);
|
|
||||||
case LUA_OPBOR: return intop(|, v1, v2);
|
|
||||||
case LUA_OPBXOR: return intop(^, v1, v2);
|
|
||||||
case LUA_OPSHL: return luaV_shiftl(v1, v2);
|
|
||||||
case LUA_OPSHR: return luaV_shiftr(v1, v2);
|
|
||||||
case LUA_OPUNM: return intop(-, 0, v1);
|
|
||||||
case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1);
|
|
||||||
default: lua_assert(0); return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static lua_Number numarith (lua_State *L, int op, lua_Number v1,
|
|
||||||
lua_Number v2) {
|
|
||||||
switch (op) {
|
|
||||||
case LUA_OPADD: return luai_numadd(L, v1, v2);
|
|
||||||
case LUA_OPSUB: return luai_numsub(L, v1, v2);
|
|
||||||
case LUA_OPMUL: return luai_nummul(L, v1, v2);
|
|
||||||
case LUA_OPDIV: return luai_numdiv(L, v1, v2);
|
|
||||||
case LUA_OPPOW: return luai_numpow(L, v1, v2);
|
|
||||||
case LUA_OPIDIV: return luai_numidiv(L, v1, v2);
|
|
||||||
case LUA_OPUNM: return luai_numunm(L, v1);
|
|
||||||
case LUA_OPMOD: return luaV_modf(L, v1, v2);
|
|
||||||
default: lua_assert(0); return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
|
||||||
TValue *res) {
|
|
||||||
switch (op) {
|
|
||||||
case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
|
|
||||||
case LUA_OPSHL: case LUA_OPSHR:
|
|
||||||
case LUA_OPBNOT: { /* operate only on integers */
|
|
||||||
lua_Integer i1; lua_Integer i2;
|
|
||||||
if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) {
|
|
||||||
setivalue(res, intarith(L, op, i1, i2));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else return 0; /* fail */
|
|
||||||
}
|
|
||||||
case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */
|
|
||||||
lua_Number n1; lua_Number n2;
|
|
||||||
if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
|
|
||||||
setfltvalue(res, numarith(L, op, n1, n2));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else return 0; /* fail */
|
|
||||||
}
|
|
||||||
default: { /* other operations */
|
|
||||||
lua_Number n1; lua_Number n2;
|
|
||||||
if (ttisinteger(p1) && ttisinteger(p2)) {
|
|
||||||
setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
|
|
||||||
setfltvalue(res, numarith(L, op, n1, n2));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
else return 0; /* fail */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
|
|
||||||
StkId res) {
|
|
||||||
if (!luaO_rawarith(L, op, p1, p2, s2v(res))) {
|
|
||||||
/* could not perform raw operation; try metamethod */
|
|
||||||
luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int luaO_hexavalue (int c) {
|
|
||||||
if (lisdigit(c)) return c - '0';
|
|
||||||
else return (ltolower(c) - 'a') + 10;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int isneg (const char **s) {
|
|
||||||
if (**s == '-') { (*s)++; return 1; }
|
|
||||||
else if (**s == '+') (*s)++;
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Lua's implementation for 'lua_strx2number'
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if !defined(lua_strx2number)
|
|
||||||
|
|
||||||
/* maximum number of significant digits to read (to avoid overflows
|
|
||||||
even with single floats) */
|
|
||||||
#define MAXSIGDIG 30
|
|
||||||
|
|
||||||
/*
|
|
||||||
** convert a hexadecimal numeric string to a number, following
|
|
||||||
** C99 specification for 'strtod'
|
|
||||||
*/
|
|
||||||
static lua_Number lua_strx2number (const char *s, char **endptr) {
|
|
||||||
int dot = lua_getlocaledecpoint();
|
|
||||||
lua_Number r = l_mathop(0.0); /* result (accumulator) */
|
|
||||||
int sigdig = 0; /* number of significant digits */
|
|
||||||
int nosigdig = 0; /* number of non-significant digits */
|
|
||||||
int e = 0; /* exponent correction */
|
|
||||||
int neg; /* 1 if number is negative */
|
|
||||||
int hasdot = 0; /* true after seen a dot */
|
|
||||||
*endptr = cast_charp(s); /* nothing is valid yet */
|
|
||||||
while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */
|
|
||||||
neg = isneg(&s); /* check sign */
|
|
||||||
if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X'))) /* check '0x' */
|
|
||||||
return l_mathop(0.0); /* invalid format (no '0x') */
|
|
||||||
for (s += 2; ; s++) { /* skip '0x' and read numeral */
|
|
||||||
if (*s == dot) {
|
|
||||||
if (hasdot) break; /* second dot? stop loop */
|
|
||||||
else hasdot = 1;
|
|
||||||
}
|
|
||||||
else if (lisxdigit(cast_uchar(*s))) {
|
|
||||||
if (sigdig == 0 && *s == '0') /* non-significant digit (zero)? */
|
|
||||||
nosigdig++;
|
|
||||||
else if (++sigdig <= MAXSIGDIG) /* can read it without overflow? */
|
|
||||||
r = (r * l_mathop(16.0)) + luaO_hexavalue(*s);
|
|
||||||
else e++; /* too many digits; ignore, but still count for exponent */
|
|
||||||
if (hasdot) e--; /* decimal digit? correct exponent */
|
|
||||||
}
|
|
||||||
else break; /* neither a dot nor a digit */
|
|
||||||
}
|
|
||||||
if (nosigdig + sigdig == 0) /* no digits? */
|
|
||||||
return l_mathop(0.0); /* invalid format */
|
|
||||||
*endptr = cast_charp(s); /* valid up to here */
|
|
||||||
e *= 4; /* each digit multiplies/divides value by 2^4 */
|
|
||||||
if (*s == 'p' || *s == 'P') { /* exponent part? */
|
|
||||||
int exp1 = 0; /* exponent value */
|
|
||||||
int neg1; /* exponent sign */
|
|
||||||
s++; /* skip 'p' */
|
|
||||||
neg1 = isneg(&s); /* sign */
|
|
||||||
if (!lisdigit(cast_uchar(*s)))
|
|
||||||
return l_mathop(0.0); /* invalid; must have at least one digit */
|
|
||||||
while (lisdigit(cast_uchar(*s))) /* read exponent */
|
|
||||||
exp1 = exp1 * 10 + *(s++) - '0';
|
|
||||||
if (neg1) exp1 = -exp1;
|
|
||||||
e += exp1;
|
|
||||||
*endptr = cast_charp(s); /* valid up to here */
|
|
||||||
}
|
|
||||||
if (neg) r = -r;
|
|
||||||
return l_mathop(ldexp)(r, e);
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/* maximum length of a numeral to be converted to a number */
|
|
||||||
#if !defined (L_MAXLENNUM)
|
|
||||||
#define L_MAXLENNUM 200
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert string 's' to a Lua number (put in 'result'). Return NULL on
|
|
||||||
** fail or the address of the ending '\0' on success. ('mode' == 'x')
|
|
||||||
** means a hexadecimal numeral.
|
|
||||||
*/
|
|
||||||
static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
|
|
||||||
char *endptr;
|
|
||||||
*result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */
|
|
||||||
: lua_str2number(s, &endptr);
|
|
||||||
if (endptr == s) return NULL; /* nothing recognized? */
|
|
||||||
while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */
|
|
||||||
return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert string 's' to a Lua number (put in 'result') handling the
|
|
||||||
** current locale.
|
|
||||||
** This function accepts both the current locale or a dot as the radix
|
|
||||||
** mark. If the conversion fails, it may mean number has a dot but
|
|
||||||
** locale accepts something else. In that case, the code copies 's'
|
|
||||||
** to a buffer (because 's' is read-only), changes the dot to the
|
|
||||||
** current locale radix mark, and tries to convert again.
|
|
||||||
** The variable 'mode' checks for special characters in the string:
|
|
||||||
** - 'n' means 'inf' or 'nan' (which should be rejected)
|
|
||||||
** - 'x' means a hexadecimal numeral
|
|
||||||
** - '.' just optimizes the search for the common case (no special chars)
|
|
||||||
*/
|
|
||||||
static const char *l_str2d (const char *s, lua_Number *result) {
|
|
||||||
const char *endptr;
|
|
||||||
const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */
|
|
||||||
int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0;
|
|
||||||
if (mode == 'n') /* reject 'inf' and 'nan' */
|
|
||||||
return NULL;
|
|
||||||
endptr = l_str2dloc(s, result, mode); /* try to convert */
|
|
||||||
if (endptr == NULL) { /* failed? may be a different locale */
|
|
||||||
char buff[L_MAXLENNUM + 1];
|
|
||||||
const char *pdot = strchr(s, '.');
|
|
||||||
if (pdot == NULL || strlen(s) > L_MAXLENNUM)
|
|
||||||
return NULL; /* string too long or no dot; fail */
|
|
||||||
strcpy(buff, s); /* copy string to buffer */
|
|
||||||
buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */
|
|
||||||
endptr = l_str2dloc(buff, result, mode); /* try again */
|
|
||||||
if (endptr != NULL)
|
|
||||||
endptr = s + (endptr - buff); /* make relative to 's' */
|
|
||||||
}
|
|
||||||
return endptr;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10)
|
|
||||||
#define MAXLASTD cast_int(LUA_MAXINTEGER % 10)
|
|
||||||
|
|
||||||
static const char *l_str2int (const char *s, lua_Integer *result) {
|
|
||||||
lua_Unsigned a = 0;
|
|
||||||
int empty = 1;
|
|
||||||
int neg;
|
|
||||||
while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */
|
|
||||||
neg = isneg(&s);
|
|
||||||
if (s[0] == '0' &&
|
|
||||||
(s[1] == 'x' || s[1] == 'X')) { /* hex? */
|
|
||||||
s += 2; /* skip '0x' */
|
|
||||||
for (; lisxdigit(cast_uchar(*s)); s++) {
|
|
||||||
a = a * 16 + luaO_hexavalue(*s);
|
|
||||||
empty = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else { /* decimal */
|
|
||||||
for (; lisdigit(cast_uchar(*s)); s++) {
|
|
||||||
int d = *s - '0';
|
|
||||||
if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */
|
|
||||||
return NULL; /* do not accept it (as integer) */
|
|
||||||
a = a * 10 + d;
|
|
||||||
empty = 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */
|
|
||||||
if (empty || *s != '\0') return NULL; /* something wrong in the numeral */
|
|
||||||
else {
|
|
||||||
*result = l_castU2S((neg) ? 0u - a : a);
|
|
||||||
return s;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
size_t luaO_str2num (const char *s, TValue *o) {
|
|
||||||
lua_Integer i; lua_Number n;
|
|
||||||
const char *e;
|
|
||||||
if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */
|
|
||||||
setivalue(o, i);
|
|
||||||
}
|
|
||||||
else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */
|
|
||||||
setfltvalue(o, n);
|
|
||||||
}
|
|
||||||
else
|
|
||||||
return 0; /* conversion failed */
|
|
||||||
return (e - s) + 1; /* success; return string size */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int luaO_utf8esc (char *buff, unsigned long x) {
|
|
||||||
int n = 1; /* number of bytes put in buffer (backwards) */
|
|
||||||
lua_assert(x <= 0x7FFFFFFFu);
|
|
||||||
if (x < 0x80) /* ascii? */
|
|
||||||
buff[UTF8BUFFSZ - 1] = cast_char(x);
|
|
||||||
else { /* need continuation bytes */
|
|
||||||
unsigned int mfb = 0x3f; /* maximum that fits in first byte */
|
|
||||||
do { /* add continuation bytes */
|
|
||||||
buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f));
|
|
||||||
x >>= 6; /* remove added bits */
|
|
||||||
mfb >>= 1; /* now there is one less bit available in first byte */
|
|
||||||
} while (x > mfb); /* still needs continuation byte? */
|
|
||||||
buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */
|
|
||||||
}
|
|
||||||
return n;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Maximum length of the conversion of a number to a string. Must be
|
|
||||||
** enough to accommodate both LUA_INTEGER_FMT and LUA_NUMBER_FMT.
|
|
||||||
** (For a long long int, this is 19 digits plus a sign and a final '\0',
|
|
||||||
** adding to 21. For a long double, it can go to a sign, 33 digits,
|
|
||||||
** the dot, an exponent letter, an exponent sign, 5 exponent digits,
|
|
||||||
** and a final '\0', adding to 43.)
|
|
||||||
*/
|
|
||||||
#define MAXNUMBER2STR 44
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert a number object to a string, adding it to a buffer
|
|
||||||
*/
|
|
||||||
static int tostringbuff (TValue *obj, char *buff) {
|
|
||||||
int len;
|
|
||||||
lua_assert(ttisnumber(obj));
|
|
||||||
if (ttisinteger(obj))
|
|
||||||
len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj));
|
|
||||||
else {
|
|
||||||
len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj));
|
|
||||||
if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */
|
|
||||||
buff[len++] = lua_getlocaledecpoint();
|
|
||||||
buff[len++] = '0'; /* adds '.0' to result */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
return len;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Convert a number object to a Lua string, replacing the value at 'obj'
|
|
||||||
*/
|
|
||||||
void luaO_tostring (lua_State *L, TValue *obj) {
|
|
||||||
char buff[MAXNUMBER2STR];
|
|
||||||
int len = tostringbuff(obj, buff);
|
|
||||||
setsvalue(L, obj, luaS_newlstr(L, buff, len));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** 'luaO_pushvfstring'
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Size for buffer space used by 'luaO_pushvfstring'. It should be
|
|
||||||
** (LUA_IDSIZE + MAXNUMBER2STR) + a minimal space for basic messages,
|
|
||||||
** so that 'luaG_addinfo' can work directly on the buffer.
|
|
||||||
*/
|
|
||||||
#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95)
|
|
||||||
|
|
||||||
/* buffer used by 'luaO_pushvfstring' */
|
|
||||||
typedef struct BuffFS {
|
|
||||||
lua_State *L;
|
|
||||||
int pushed; /* true if there is a part of the result on the stack */
|
|
||||||
int blen; /* length of partial string in 'space' */
|
|
||||||
char space[BUFVFS]; /* holds last part of the result */
|
|
||||||
} BuffFS;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Push given string to the stack, as part of the result, and
|
|
||||||
** join it to previous partial result if there is one.
|
|
||||||
** It may call 'luaV_concat' while using one slot from EXTRA_STACK.
|
|
||||||
** This call cannot invoke metamethods, as both operands must be
|
|
||||||
** strings. It can, however, raise an error if the result is too
|
|
||||||
** long. In that case, 'luaV_concat' frees the extra slot before
|
|
||||||
** raising the error.
|
|
||||||
*/
|
|
||||||
static void pushstr (BuffFS *buff, const char *str, size_t lstr) {
|
|
||||||
lua_State *L = buff->L;
|
|
||||||
setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr));
|
|
||||||
L->top.p++; /* may use one slot from EXTRA_STACK */
|
|
||||||
if (!buff->pushed) /* no previous string on the stack? */
|
|
||||||
buff->pushed = 1; /* now there is one */
|
|
||||||
else /* join previous string with new one */
|
|
||||||
luaV_concat(L, 2);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** empty the buffer space into the stack
|
|
||||||
*/
|
|
||||||
static void clearbuff (BuffFS *buff) {
|
|
||||||
pushstr(buff, buff->space, buff->blen); /* push buffer contents */
|
|
||||||
buff->blen = 0; /* space now is empty */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Get a space of size 'sz' in the buffer. If buffer has not enough
|
|
||||||
** space, empty it. 'sz' must fit in an empty buffer.
|
|
||||||
*/
|
|
||||||
static char *getbuff (BuffFS *buff, int sz) {
|
|
||||||
lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS);
|
|
||||||
if (sz > BUFVFS - buff->blen) /* not enough space? */
|
|
||||||
clearbuff(buff);
|
|
||||||
return buff->space + buff->blen;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
#define addsize(b,sz) ((b)->blen += (sz))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Add 'str' to the buffer. If string is larger than the buffer space,
|
|
||||||
** push the string directly to the stack.
|
|
||||||
*/
|
|
||||||
static void addstr2buff (BuffFS *buff, const char *str, size_t slen) {
|
|
||||||
if (slen <= BUFVFS) { /* does string fit into buffer? */
|
|
||||||
char *bf = getbuff(buff, cast_int(slen));
|
|
||||||
memcpy(bf, str, slen); /* add string to buffer */
|
|
||||||
addsize(buff, cast_int(slen));
|
|
||||||
}
|
|
||||||
else { /* string larger than buffer */
|
|
||||||
clearbuff(buff); /* string comes after buffer's content */
|
|
||||||
pushstr(buff, str, slen); /* push string */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Add a numeral to the buffer.
|
|
||||||
*/
|
|
||||||
static void addnum2buff (BuffFS *buff, TValue *num) {
|
|
||||||
char *numbuff = getbuff(buff, MAXNUMBER2STR);
|
|
||||||
int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */
|
|
||||||
addsize(buff, len);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** this function handles only '%d', '%c', '%f', '%p', '%s', and '%%'
|
|
||||||
conventional formats, plus Lua-specific '%I' and '%U'
|
|
||||||
*/
|
|
||||||
const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
|
|
||||||
BuffFS buff; /* holds last part of the result */
|
|
||||||
const char *e; /* points to next '%' */
|
|
||||||
buff.pushed = buff.blen = 0;
|
|
||||||
buff.L = L;
|
|
||||||
while ((e = strchr(fmt, '%')) != NULL) {
|
|
||||||
addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */
|
|
||||||
switch (*(e + 1)) { /* conversion specifier */
|
|
||||||
case 's': { /* zero-terminated string */
|
|
||||||
const char *s = va_arg(argp, char *);
|
|
||||||
if (s == NULL) s = "(null)";
|
|
||||||
addstr2buff(&buff, s, strlen(s));
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'c': { /* an 'int' as a character */
|
|
||||||
char c = cast_uchar(va_arg(argp, int));
|
|
||||||
addstr2buff(&buff, &c, sizeof(char));
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'd': { /* an 'int' */
|
|
||||||
TValue num;
|
|
||||||
setivalue(&num, va_arg(argp, int));
|
|
||||||
addnum2buff(&buff, &num);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'I': { /* a 'lua_Integer' */
|
|
||||||
TValue num;
|
|
||||||
setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt)));
|
|
||||||
addnum2buff(&buff, &num);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'f': { /* a 'lua_Number' */
|
|
||||||
TValue num;
|
|
||||||
setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber)));
|
|
||||||
addnum2buff(&buff, &num);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'p': { /* a pointer */
|
|
||||||
const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */
|
|
||||||
char *bf = getbuff(&buff, sz);
|
|
||||||
void *p = va_arg(argp, void *);
|
|
||||||
int len = lua_pointer2str(bf, sz, p);
|
|
||||||
addsize(&buff, len);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case 'U': { /* a 'long' as a UTF-8 sequence */
|
|
||||||
char bf[UTF8BUFFSZ];
|
|
||||||
int len = luaO_utf8esc(bf, va_arg(argp, long));
|
|
||||||
addstr2buff(&buff, bf + UTF8BUFFSZ - len, len);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
case '%': {
|
|
||||||
addstr2buff(&buff, "%", 1);
|
|
||||||
break;
|
|
||||||
}
|
|
||||||
default: {
|
|
||||||
luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'",
|
|
||||||
*(e + 1));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
fmt = e + 2; /* skip '%' and the specifier */
|
|
||||||
}
|
|
||||||
addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */
|
|
||||||
clearbuff(&buff); /* empty buffer into the stack */
|
|
||||||
lua_assert(buff.pushed == 1);
|
|
||||||
return svalue(s2v(L->top.p - 1));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
|
|
||||||
const char *msg;
|
|
||||||
va_list argp;
|
|
||||||
va_start(argp, fmt);
|
|
||||||
msg = luaO_pushvfstring(L, fmt, argp);
|
|
||||||
va_end(argp);
|
|
||||||
return msg;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
#define RETS "..."
|
|
||||||
#define PRE "[string \""
|
|
||||||
#define POS "\"]"
|
|
||||||
|
|
||||||
#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) )
|
|
||||||
|
|
||||||
void luaO_chunkid (char *out, const char *source, size_t srclen) {
|
|
||||||
size_t bufflen = LUA_IDSIZE; /* free space in buffer */
|
|
||||||
if (*source == '=') { /* 'literal' source */
|
|
||||||
if (srclen <= bufflen) /* small enough? */
|
|
||||||
memcpy(out, source + 1, srclen * sizeof(char));
|
|
||||||
else { /* truncate it */
|
|
||||||
addstr(out, source + 1, bufflen - 1);
|
|
||||||
*out = '\0';
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else if (*source == '@') { /* file name */
|
|
||||||
if (srclen <= bufflen) /* small enough? */
|
|
||||||
memcpy(out, source + 1, srclen * sizeof(char));
|
|
||||||
else { /* add '...' before rest of name */
|
|
||||||
addstr(out, RETS, LL(RETS));
|
|
||||||
bufflen -= LL(RETS);
|
|
||||||
memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
else { /* string; format as [string "source"] */
|
|
||||||
const char *nl = strchr(source, '\n'); /* find first new line (if any) */
|
|
||||||
addstr(out, PRE, LL(PRE)); /* add prefix */
|
|
||||||
bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */
|
|
||||||
if (srclen < bufflen && nl == NULL) { /* small one-line source? */
|
|
||||||
addstr(out, source, srclen); /* keep it */
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (nl != NULL) srclen = nl - source; /* stop at first newline */
|
|
||||||
if (srclen > bufflen) srclen = bufflen;
|
|
||||||
addstr(out, source, srclen);
|
|
||||||
addstr(out, RETS, LL(RETS));
|
|
||||||
}
|
|
||||||
memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
@ -1,815 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lobject.h $
|
|
||||||
** Type definitions for Lua objects
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#ifndef lobject_h
|
|
||||||
#define lobject_h
|
|
||||||
|
|
||||||
|
|
||||||
#include <stdarg.h>
|
|
||||||
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Extra types for collectable non-values
|
|
||||||
*/
|
|
||||||
#define LUA_TUPVAL LUA_NUMTYPES /* upvalues */
|
|
||||||
#define LUA_TPROTO (LUA_NUMTYPES+1) /* function prototypes */
|
|
||||||
#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** number of all possible types (including LUA_TNONE but excluding DEADKEY)
|
|
||||||
*/
|
|
||||||
#define LUA_TOTALTYPES (LUA_TPROTO + 2)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** tags for Tagged Values have the following use of bits:
|
|
||||||
** bits 0-3: actual tag (a LUA_T* constant)
|
|
||||||
** bits 4-5: variant bits
|
|
||||||
** bit 6: whether value is collectable
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* add variant bits to a type */
|
|
||||||
#define makevariant(t,v) ((t) | ((v) << 4))
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Union of all Lua values
|
|
||||||
*/
|
|
||||||
typedef union Value {
|
|
||||||
struct GCObject *gc; /* collectable objects */
|
|
||||||
void *p; /* light userdata */
|
|
||||||
lua_CFunction f; /* light C functions */
|
|
||||||
lua_Integer i; /* integer numbers */
|
|
||||||
lua_Number n; /* float numbers */
|
|
||||||
/* not used, but may avoid warnings for uninitialized value */
|
|
||||||
lu_byte ub;
|
|
||||||
} Value;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Tagged Values. This is the basic representation of values in Lua:
|
|
||||||
** an actual value plus a tag with its type.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define TValuefields Value value_; lu_byte tt_
|
|
||||||
|
|
||||||
typedef struct TValue {
|
|
||||||
TValuefields;
|
|
||||||
} TValue;
|
|
||||||
|
|
||||||
|
|
||||||
#define val_(o) ((o)->value_)
|
|
||||||
#define valraw(o) (val_(o))
|
|
||||||
|
|
||||||
|
|
||||||
/* raw type tag of a TValue */
|
|
||||||
#define rawtt(o) ((o)->tt_)
|
|
||||||
|
|
||||||
/* tag with no variants (bits 0-3) */
|
|
||||||
#define novariant(t) ((t) & 0x0F)
|
|
||||||
|
|
||||||
/* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
|
|
||||||
#define withvariant(t) ((t) & 0x3F)
|
|
||||||
#define ttypetag(o) withvariant(rawtt(o))
|
|
||||||
|
|
||||||
/* type of a TValue */
|
|
||||||
#define ttype(o) (novariant(rawtt(o)))
|
|
||||||
|
|
||||||
|
|
||||||
/* Macros to test type */
|
|
||||||
#define checktag(o,t) (rawtt(o) == (t))
|
|
||||||
#define checktype(o,t) (ttype(o) == (t))
|
|
||||||
|
|
||||||
|
|
||||||
/* Macros for internal tests */
|
|
||||||
|
|
||||||
/* collectable object has the same tag as the original value */
|
|
||||||
#define righttt(obj) (ttypetag(obj) == gcvalue(obj)->tt)
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Any value being manipulated by the program either is non
|
|
||||||
** collectable, or the collectable object has the right tag
|
|
||||||
** and it is not dead. The option 'L == NULL' allows other
|
|
||||||
** macros using this one to be used where L is not available.
|
|
||||||
*/
|
|
||||||
#define checkliveness(L,obj) \
|
|
||||||
((void)L, lua_longassert(!iscollectable(obj) || \
|
|
||||||
(righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj))))))
|
|
||||||
|
|
||||||
|
|
||||||
/* Macros to set values */
|
|
||||||
|
|
||||||
/* set a value's tag */
|
|
||||||
#define settt_(o,t) ((o)->tt_=(t))
|
|
||||||
|
|
||||||
|
|
||||||
/* main macro to copy values (from 'obj2' to 'obj1') */
|
|
||||||
#define setobj(L,obj1,obj2) \
|
|
||||||
{ TValue *io1=(obj1); const TValue *io2=(obj2); \
|
|
||||||
io1->value_ = io2->value_; settt_(io1, io2->tt_); \
|
|
||||||
checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); }
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Different types of assignments, according to source and destination.
|
|
||||||
** (They are mostly equal now, but may be different in the future.)
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* from stack to stack */
|
|
||||||
#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2))
|
|
||||||
/* to stack (not from same stack) */
|
|
||||||
#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2)
|
|
||||||
/* from table to same table */
|
|
||||||
#define setobjt2t setobj
|
|
||||||
/* to new object */
|
|
||||||
#define setobj2n setobj
|
|
||||||
/* to table */
|
|
||||||
#define setobj2t setobj
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Entries in a Lua stack. Field 'tbclist' forms a list of all
|
|
||||||
** to-be-closed variables active in this stack. Dummy entries are
|
|
||||||
** used when the distance between two tbc variables does not fit
|
|
||||||
** in an unsigned short. They are represented by delta==0, and
|
|
||||||
** their real delta is always the maximum value that fits in
|
|
||||||
** that field.
|
|
||||||
*/
|
|
||||||
typedef union StackValue {
|
|
||||||
TValue val;
|
|
||||||
struct {
|
|
||||||
TValuefields;
|
|
||||||
unsigned short delta;
|
|
||||||
} tbclist;
|
|
||||||
} StackValue;
|
|
||||||
|
|
||||||
|
|
||||||
/* index to stack elements */
|
|
||||||
typedef StackValue *StkId;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** When reallocating the stack, change all pointers to the stack into
|
|
||||||
** proper offsets.
|
|
||||||
*/
|
|
||||||
typedef union {
|
|
||||||
StkId p; /* actual pointer */
|
|
||||||
ptrdiff_t offset; /* used while the stack is being reallocated */
|
|
||||||
} StkIdRel;
|
|
||||||
|
|
||||||
|
|
||||||
/* convert a 'StackValue' to a 'TValue' */
|
|
||||||
#define s2v(o) (&(o)->val)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Nil
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Standard nil */
|
|
||||||
#define LUA_VNIL makevariant(LUA_TNIL, 0)
|
|
||||||
|
|
||||||
/* Empty slot (which might be different from a slot containing nil) */
|
|
||||||
#define LUA_VEMPTY makevariant(LUA_TNIL, 1)
|
|
||||||
|
|
||||||
/* Value returned for a key not found in a table (absent key) */
|
|
||||||
#define LUA_VABSTKEY makevariant(LUA_TNIL, 2)
|
|
||||||
|
|
||||||
|
|
||||||
/* macro to test for (any kind of) nil */
|
|
||||||
#define ttisnil(v) checktype((v), LUA_TNIL)
|
|
||||||
|
|
||||||
|
|
||||||
/* macro to test for a standard nil */
|
|
||||||
#define ttisstrictnil(o) checktag((o), LUA_VNIL)
|
|
||||||
|
|
||||||
|
|
||||||
#define setnilvalue(obj) settt_(obj, LUA_VNIL)
|
|
||||||
|
|
||||||
|
|
||||||
#define isabstkey(v) checktag((v), LUA_VABSTKEY)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** macro to detect non-standard nils (used only in assertions)
|
|
||||||
*/
|
|
||||||
#define isnonstrictnil(v) (ttisnil(v) && !ttisstrictnil(v))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** By default, entries with any kind of nil are considered empty.
|
|
||||||
** (In any definition, values associated with absent keys must also
|
|
||||||
** be accepted as empty.)
|
|
||||||
*/
|
|
||||||
#define isempty(v) ttisnil(v)
|
|
||||||
|
|
||||||
|
|
||||||
/* macro defining a value corresponding to an absent key */
|
|
||||||
#define ABSTKEYCONSTANT {NULL}, LUA_VABSTKEY
|
|
||||||
|
|
||||||
|
|
||||||
/* mark an entry as empty */
|
|
||||||
#define setempty(v) settt_(v, LUA_VEMPTY)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Booleans
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0)
|
|
||||||
#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1)
|
|
||||||
|
|
||||||
#define ttisboolean(o) checktype((o), LUA_TBOOLEAN)
|
|
||||||
#define ttisfalse(o) checktag((o), LUA_VFALSE)
|
|
||||||
#define ttistrue(o) checktag((o), LUA_VTRUE)
|
|
||||||
|
|
||||||
|
|
||||||
#define l_isfalse(o) (ttisfalse(o) || ttisnil(o))
|
|
||||||
|
|
||||||
|
|
||||||
#define setbfvalue(obj) settt_(obj, LUA_VFALSE)
|
|
||||||
#define setbtvalue(obj) settt_(obj, LUA_VTRUE)
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Threads
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0)
|
|
||||||
|
|
||||||
#define ttisthread(o) checktag((o), ctb(LUA_VTHREAD))
|
|
||||||
|
|
||||||
#define thvalue(o) check_exp(ttisthread(o), gco2th(val_(o).gc))
|
|
||||||
|
|
||||||
#define setthvalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); lua_State *x_ = (x); \
|
|
||||||
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \
|
|
||||||
checkliveness(L,io); }
|
|
||||||
|
|
||||||
#define setthvalue2s(L,o,t) setthvalue(L,s2v(o),t)
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Collectable Objects
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Common Header for all collectable objects (in macro form, to be
|
|
||||||
** included in other objects)
|
|
||||||
*/
|
|
||||||
#define CommonHeader struct GCObject *next; lu_byte tt; lu_byte marked
|
|
||||||
|
|
||||||
|
|
||||||
/* Common type for all collectable objects */
|
|
||||||
typedef struct GCObject {
|
|
||||||
CommonHeader;
|
|
||||||
} GCObject;
|
|
||||||
|
|
||||||
|
|
||||||
/* Bit mark for collectable types */
|
|
||||||
#define BIT_ISCOLLECTABLE (1 << 6)
|
|
||||||
|
|
||||||
#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE)
|
|
||||||
|
|
||||||
/* mark a tag as collectable */
|
|
||||||
#define ctb(t) ((t) | BIT_ISCOLLECTABLE)
|
|
||||||
|
|
||||||
#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc)
|
|
||||||
|
|
||||||
#define gcvalueraw(v) ((v).gc)
|
|
||||||
|
|
||||||
#define setgcovalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); GCObject *i_g=(x); \
|
|
||||||
val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Numbers
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Variant tags for numbers */
|
|
||||||
#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */
|
|
||||||
#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */
|
|
||||||
|
|
||||||
#define ttisnumber(o) checktype((o), LUA_TNUMBER)
|
|
||||||
#define ttisfloat(o) checktag((o), LUA_VNUMFLT)
|
|
||||||
#define ttisinteger(o) checktag((o), LUA_VNUMINT)
|
|
||||||
|
|
||||||
#define nvalue(o) check_exp(ttisnumber(o), \
|
|
||||||
(ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
|
|
||||||
#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n)
|
|
||||||
#define ivalue(o) check_exp(ttisinteger(o), val_(o).i)
|
|
||||||
|
|
||||||
#define fltvalueraw(v) ((v).n)
|
|
||||||
#define ivalueraw(v) ((v).i)
|
|
||||||
|
|
||||||
#define setfltvalue(obj,x) \
|
|
||||||
{ TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); }
|
|
||||||
|
|
||||||
#define chgfltvalue(obj,x) \
|
|
||||||
{ TValue *io=(obj); lua_assert(ttisfloat(io)); val_(io).n=(x); }
|
|
||||||
|
|
||||||
#define setivalue(obj,x) \
|
|
||||||
{ TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); }
|
|
||||||
|
|
||||||
#define chgivalue(obj,x) \
|
|
||||||
{ TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Strings
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Variant tags for strings */
|
|
||||||
#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */
|
|
||||||
#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */
|
|
||||||
|
|
||||||
#define ttisstring(o) checktype((o), LUA_TSTRING)
|
|
||||||
#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR))
|
|
||||||
#define ttislngstring(o) checktag((o), ctb(LUA_VLNGSTR))
|
|
||||||
|
|
||||||
#define tsvalueraw(v) (gco2ts((v).gc))
|
|
||||||
|
|
||||||
#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc))
|
|
||||||
|
|
||||||
#define setsvalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); TString *x_ = (x); \
|
|
||||||
val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
|
|
||||||
checkliveness(L,io); }
|
|
||||||
|
|
||||||
/* set a string to the stack */
|
|
||||||
#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s)
|
|
||||||
|
|
||||||
/* set a string to a new object */
|
|
||||||
#define setsvalue2n setsvalue
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Header for a string value.
|
|
||||||
*/
|
|
||||||
typedef struct TString {
|
|
||||||
CommonHeader;
|
|
||||||
lu_byte extra; /* reserved words for short strings; "has hash" for longs */
|
|
||||||
lu_byte shrlen; /* length for short strings */
|
|
||||||
unsigned int hash;
|
|
||||||
union {
|
|
||||||
size_t lnglen; /* length for long strings */
|
|
||||||
struct TString *hnext; /* linked list for hash table */
|
|
||||||
} u;
|
|
||||||
char contents[1];
|
|
||||||
} TString;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Get the actual string (array of bytes) from a 'TString'.
|
|
||||||
*/
|
|
||||||
#define getstr(ts) ((ts)->contents)
|
|
||||||
|
|
||||||
|
|
||||||
/* get the actual string (array of bytes) from a Lua value */
|
|
||||||
#define svalue(o) getstr(tsvalue(o))
|
|
||||||
|
|
||||||
/* get string length from 'TString *s' */
|
|
||||||
#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen)
|
|
||||||
|
|
||||||
/* get string length from 'TValue *o' */
|
|
||||||
#define vslen(o) tsslen(tsvalue(o))
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Userdata
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Light userdata should be a variant of userdata, but for compatibility
|
|
||||||
** reasons they are also different types.
|
|
||||||
*/
|
|
||||||
#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0)
|
|
||||||
|
|
||||||
#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0)
|
|
||||||
|
|
||||||
#define ttislightuserdata(o) checktag((o), LUA_VLIGHTUSERDATA)
|
|
||||||
#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA))
|
|
||||||
|
|
||||||
#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p)
|
|
||||||
#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
|
|
||||||
|
|
||||||
#define pvalueraw(v) ((v).p)
|
|
||||||
|
|
||||||
#define setpvalue(obj,x) \
|
|
||||||
{ TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); }
|
|
||||||
|
|
||||||
#define setuvalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); Udata *x_ = (x); \
|
|
||||||
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \
|
|
||||||
checkliveness(L,io); }
|
|
||||||
|
|
||||||
|
|
||||||
/* Ensures that addresses after this type are always fully aligned. */
|
|
||||||
typedef union UValue {
|
|
||||||
TValue uv;
|
|
||||||
LUAI_MAXALIGN; /* ensures maximum alignment for udata bytes */
|
|
||||||
} UValue;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Header for userdata with user values;
|
|
||||||
** memory area follows the end of this structure.
|
|
||||||
*/
|
|
||||||
typedef struct Udata {
|
|
||||||
CommonHeader;
|
|
||||||
unsigned short nuvalue; /* number of user values */
|
|
||||||
size_t len; /* number of bytes */
|
|
||||||
struct Table *metatable;
|
|
||||||
GCObject *gclist;
|
|
||||||
UValue uv[1]; /* user values */
|
|
||||||
} Udata;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Header for userdata with no user values. These userdata do not need
|
|
||||||
** to be gray during GC, and therefore do not need a 'gclist' field.
|
|
||||||
** To simplify, the code always use 'Udata' for both kinds of userdata,
|
|
||||||
** making sure it never accesses 'gclist' on userdata with no user values.
|
|
||||||
** This structure here is used only to compute the correct size for
|
|
||||||
** this representation. (The 'bindata' field in its end ensures correct
|
|
||||||
** alignment for binary data following this header.)
|
|
||||||
*/
|
|
||||||
typedef struct Udata0 {
|
|
||||||
CommonHeader;
|
|
||||||
unsigned short nuvalue; /* number of user values */
|
|
||||||
size_t len; /* number of bytes */
|
|
||||||
struct Table *metatable;
|
|
||||||
union {LUAI_MAXALIGN;} bindata;
|
|
||||||
} Udata0;
|
|
||||||
|
|
||||||
|
|
||||||
/* compute the offset of the memory area of a userdata */
|
|
||||||
#define udatamemoffset(nuv) \
|
|
||||||
((nuv) == 0 ? offsetof(Udata0, bindata) \
|
|
||||||
: offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
|
|
||||||
|
|
||||||
/* get the address of the memory block inside 'Udata' */
|
|
||||||
#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue))
|
|
||||||
|
|
||||||
/* compute the size of a userdata */
|
|
||||||
#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb))
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Prototypes
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_VPROTO makevariant(LUA_TPROTO, 0)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Description of an upvalue for function prototypes
|
|
||||||
*/
|
|
||||||
typedef struct Upvaldesc {
|
|
||||||
TString *name; /* upvalue name (for debug information) */
|
|
||||||
lu_byte instack; /* whether it is in stack (register) */
|
|
||||||
lu_byte idx; /* index of upvalue (in stack or in outer function's list) */
|
|
||||||
lu_byte kind; /* kind of corresponding variable */
|
|
||||||
} Upvaldesc;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Description of a local variable for function prototypes
|
|
||||||
** (used for debug information)
|
|
||||||
*/
|
|
||||||
typedef struct LocVar {
|
|
||||||
TString *varname;
|
|
||||||
int startpc; /* first point where variable is active */
|
|
||||||
int endpc; /* first point where variable is dead */
|
|
||||||
} LocVar;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Associates the absolute line source for a given instruction ('pc').
|
|
||||||
** The array 'lineinfo' gives, for each instruction, the difference in
|
|
||||||
** lines from the previous instruction. When that difference does not
|
|
||||||
** fit into a byte, Lua saves the absolute line for that instruction.
|
|
||||||
** (Lua also saves the absolute line periodically, to speed up the
|
|
||||||
** computation of a line number: we can use binary search in the
|
|
||||||
** absolute-line array, but we must traverse the 'lineinfo' array
|
|
||||||
** linearly to compute a line.)
|
|
||||||
*/
|
|
||||||
typedef struct AbsLineInfo {
|
|
||||||
int pc;
|
|
||||||
int line;
|
|
||||||
} AbsLineInfo;
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Function Prototypes
|
|
||||||
*/
|
|
||||||
typedef struct Proto {
|
|
||||||
CommonHeader;
|
|
||||||
lu_byte numparams; /* number of fixed (named) parameters */
|
|
||||||
lu_byte is_vararg;
|
|
||||||
lu_byte maxstacksize; /* number of registers needed by this function */
|
|
||||||
int sizeupvalues; /* size of 'upvalues' */
|
|
||||||
int sizek; /* size of 'k' */
|
|
||||||
int sizecode;
|
|
||||||
int sizelineinfo;
|
|
||||||
int sizep; /* size of 'p' */
|
|
||||||
int sizelocvars;
|
|
||||||
int sizeabslineinfo; /* size of 'abslineinfo' */
|
|
||||||
int linedefined; /* debug information */
|
|
||||||
int lastlinedefined; /* debug information */
|
|
||||||
TValue *k; /* constants used by the function */
|
|
||||||
Instruction *code; /* opcodes */
|
|
||||||
struct Proto **p; /* functions defined inside the function */
|
|
||||||
Upvaldesc *upvalues; /* upvalue information */
|
|
||||||
ls_byte *lineinfo; /* information about source lines (debug information) */
|
|
||||||
AbsLineInfo *abslineinfo; /* idem */
|
|
||||||
LocVar *locvars; /* information about local variables (debug information) */
|
|
||||||
TString *source; /* used for debug information */
|
|
||||||
GCObject *gclist;
|
|
||||||
} Proto;
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Functions
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0)
|
|
||||||
|
|
||||||
|
|
||||||
/* Variant tags for functions */
|
|
||||||
#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */
|
|
||||||
#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */
|
|
||||||
#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */
|
|
||||||
|
|
||||||
#define ttisfunction(o) checktype(o, LUA_TFUNCTION)
|
|
||||||
#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL))
|
|
||||||
#define ttislcf(o) checktag((o), LUA_VLCF)
|
|
||||||
#define ttisCclosure(o) checktag((o), ctb(LUA_VCCL))
|
|
||||||
#define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o))
|
|
||||||
|
|
||||||
|
|
||||||
#define isLfunction(o) ttisLclosure(o)
|
|
||||||
|
|
||||||
#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc))
|
|
||||||
#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
|
|
||||||
#define fvalue(o) check_exp(ttislcf(o), val_(o).f)
|
|
||||||
#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
|
|
||||||
|
|
||||||
#define fvalueraw(v) ((v).f)
|
|
||||||
|
|
||||||
#define setclLvalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); LClosure *x_ = (x); \
|
|
||||||
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \
|
|
||||||
checkliveness(L,io); }
|
|
||||||
|
|
||||||
#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl)
|
|
||||||
|
|
||||||
#define setfvalue(obj,x) \
|
|
||||||
{ TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); }
|
|
||||||
|
|
||||||
#define setclCvalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); CClosure *x_ = (x); \
|
|
||||||
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \
|
|
||||||
checkliveness(L,io); }
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Upvalues for Lua closures
|
|
||||||
*/
|
|
||||||
typedef struct UpVal {
|
|
||||||
CommonHeader;
|
|
||||||
union {
|
|
||||||
TValue *p; /* points to stack or to its own value */
|
|
||||||
ptrdiff_t offset; /* used while the stack is being reallocated */
|
|
||||||
} v;
|
|
||||||
union {
|
|
||||||
struct { /* (when open) */
|
|
||||||
struct UpVal *next; /* linked list */
|
|
||||||
struct UpVal **previous;
|
|
||||||
} open;
|
|
||||||
TValue value; /* the value (when closed) */
|
|
||||||
} u;
|
|
||||||
} UpVal;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define ClosureHeader \
|
|
||||||
CommonHeader; lu_byte nupvalues; GCObject *gclist
|
|
||||||
|
|
||||||
typedef struct CClosure {
|
|
||||||
ClosureHeader;
|
|
||||||
lua_CFunction f;
|
|
||||||
TValue upvalue[1]; /* list of upvalues */
|
|
||||||
} CClosure;
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct LClosure {
|
|
||||||
ClosureHeader;
|
|
||||||
struct Proto *p;
|
|
||||||
UpVal *upvals[1]; /* list of upvalues */
|
|
||||||
} LClosure;
|
|
||||||
|
|
||||||
|
|
||||||
typedef union Closure {
|
|
||||||
CClosure c;
|
|
||||||
LClosure l;
|
|
||||||
} Closure;
|
|
||||||
|
|
||||||
|
|
||||||
#define getproto(o) (clLvalue(o)->p)
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Tables
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define LUA_VTABLE makevariant(LUA_TTABLE, 0)
|
|
||||||
|
|
||||||
#define ttistable(o) checktag((o), ctb(LUA_VTABLE))
|
|
||||||
|
|
||||||
#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc))
|
|
||||||
|
|
||||||
#define sethvalue(L,obj,x) \
|
|
||||||
{ TValue *io = (obj); Table *x_ = (x); \
|
|
||||||
val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \
|
|
||||||
checkliveness(L,io); }
|
|
||||||
|
|
||||||
#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Nodes for Hash tables: A pack of two TValue's (key-value pairs)
|
|
||||||
** plus a 'next' field to link colliding entries. The distribution
|
|
||||||
** of the key's fields ('key_tt' and 'key_val') not forming a proper
|
|
||||||
** 'TValue' allows for a smaller size for 'Node' both in 4-byte
|
|
||||||
** and 8-byte alignments.
|
|
||||||
*/
|
|
||||||
typedef union Node {
|
|
||||||
struct NodeKey {
|
|
||||||
TValuefields; /* fields for value */
|
|
||||||
lu_byte key_tt; /* key type */
|
|
||||||
int next; /* for chaining */
|
|
||||||
Value key_val; /* key value */
|
|
||||||
} u;
|
|
||||||
TValue i_val; /* direct access to node's value as a proper 'TValue' */
|
|
||||||
} Node;
|
|
||||||
|
|
||||||
|
|
||||||
/* copy a value into a key */
|
|
||||||
#define setnodekey(L,node,obj) \
|
|
||||||
{ Node *n_=(node); const TValue *io_=(obj); \
|
|
||||||
n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \
|
|
||||||
checkliveness(L,io_); }
|
|
||||||
|
|
||||||
|
|
||||||
/* copy a value from a key */
|
|
||||||
#define getnodekey(L,obj,node) \
|
|
||||||
{ TValue *io_=(obj); const Node *n_=(node); \
|
|
||||||
io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \
|
|
||||||
checkliveness(L,io_); }
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** About 'alimit': if 'isrealasize(t)' is true, then 'alimit' is the
|
|
||||||
** real size of 'array'. Otherwise, the real size of 'array' is the
|
|
||||||
** smallest power of two not smaller than 'alimit' (or zero iff 'alimit'
|
|
||||||
** is zero); 'alimit' is then used as a hint for #t.
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define BITRAS (1 << 7)
|
|
||||||
#define isrealasize(t) (!((t)->flags & BITRAS))
|
|
||||||
#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS))
|
|
||||||
#define setnorealasize(t) ((t)->flags |= BITRAS)
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct Table {
|
|
||||||
CommonHeader;
|
|
||||||
lu_byte flags; /* 1<<p means tagmethod(p) is not present */
|
|
||||||
lu_byte lsizenode; /* log2 of size of 'node' array */
|
|
||||||
unsigned int alimit; /* "limit" of 'array' array */
|
|
||||||
TValue *array; /* array part */
|
|
||||||
Node *node;
|
|
||||||
Node *lastfree; /* any free position is before this position */
|
|
||||||
struct Table *metatable;
|
|
||||||
GCObject *gclist;
|
|
||||||
} Table;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Macros to manipulate keys inserted in nodes
|
|
||||||
*/
|
|
||||||
#define keytt(node) ((node)->u.key_tt)
|
|
||||||
#define keyval(node) ((node)->u.key_val)
|
|
||||||
|
|
||||||
#define keyisnil(node) (keytt(node) == LUA_TNIL)
|
|
||||||
#define keyisinteger(node) (keytt(node) == LUA_VNUMINT)
|
|
||||||
#define keyival(node) (keyval(node).i)
|
|
||||||
#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR))
|
|
||||||
#define keystrval(node) (gco2ts(keyval(node).gc))
|
|
||||||
|
|
||||||
#define setnilkey(node) (keytt(node) = LUA_TNIL)
|
|
||||||
|
|
||||||
#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE)
|
|
||||||
|
|
||||||
#define gckey(n) (keyval(n).gc)
|
|
||||||
#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL)
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Dead keys in tables have the tag DEADKEY but keep their original
|
|
||||||
** gcvalue. This distinguishes them from regular keys but allows them to
|
|
||||||
** be found when searched in a special way. ('next' needs that to find
|
|
||||||
** keys removed from a table during a traversal.)
|
|
||||||
*/
|
|
||||||
#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY)
|
|
||||||
#define keyisdead(node) (keytt(node) == LUA_TDEADKEY)
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** 'module' operation for hashing (size is always a power of 2)
|
|
||||||
*/
|
|
||||||
#define lmod(s,size) \
|
|
||||||
(check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1)))))
|
|
||||||
|
|
||||||
|
|
||||||
#define twoto(x) (1<<(x))
|
|
||||||
#define sizenode(t) (twoto((t)->lsizenode))
|
|
||||||
|
|
||||||
|
|
||||||
/* size of buffer for 'luaO_utf8esc' function */
|
|
||||||
#define UTF8BUFFSZ 8
|
|
||||||
|
|
||||||
LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
|
|
||||||
LUAI_FUNC int luaO_ceillog2 (unsigned int x);
|
|
||||||
LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1,
|
|
||||||
const TValue *p2, TValue *res);
|
|
||||||
LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
|
|
||||||
const TValue *p2, StkId res);
|
|
||||||
LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
|
|
||||||
LUAI_FUNC int luaO_hexavalue (int c);
|
|
||||||
LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj);
|
|
||||||
LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
|
|
||||||
va_list argp);
|
|
||||||
LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
|
|
||||||
LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t srclen);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,104 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lopcodes.c $
|
|
||||||
** Opcodes for Lua virtual machine
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lopcodes_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include "lopcodes.h"
|
|
||||||
|
|
||||||
|
|
||||||
/* ORDER OP */
|
|
||||||
|
|
||||||
LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
|
|
||||||
/* MM OT IT T A mode opcode */
|
|
||||||
opmode(0, 0, 0, 0, 1, iABC) /* OP_MOVE */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iAsBx) /* OP_LOADI */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iAsBx) /* OP_LOADF */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABx) /* OP_LOADK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABx) /* OP_LOADKX */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_LOADFALSE */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_LFALSESKIP */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_LOADTRUE */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_LOADNIL */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETUPVAL */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETUPVAL */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETTABUP */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETTABLE */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETI */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_GETFIELD */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETTABUP */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETTABLE */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETI */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_SETFIELD */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_NEWTABLE */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SELF */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_ADDI */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_ADDK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SUBK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_MULK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_MODK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_POWK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_DIVK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_IDIVK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BANDK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BORK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BXORK */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHRI */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHLI */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_ADD */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SUB */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_MUL */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_MOD */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_POW */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_DIV */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_IDIV */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BAND */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BOR */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BXOR */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHL */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_SHR */
|
|
||||||
,opmode(1, 0, 0, 0, 0, iABC) /* OP_MMBIN */
|
|
||||||
,opmode(1, 0, 0, 0, 0, iABC) /* OP_MMBINI*/
|
|
||||||
,opmode(1, 0, 0, 0, 0, iABC) /* OP_MMBINK*/
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_UNM */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_BNOT */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_NOT */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_LEN */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABC) /* OP_CONCAT */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_CLOSE */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_TBC */
|
|
||||||
,opmode(0, 0, 0, 0, 0, isJ) /* OP_JMP */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_EQ */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_LT */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_LE */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_EQK */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_EQI */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_LTI */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_LEI */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_GTI */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_GEI */
|
|
||||||
,opmode(0, 0, 0, 1, 0, iABC) /* OP_TEST */
|
|
||||||
,opmode(0, 0, 0, 1, 1, iABC) /* OP_TESTSET */
|
|
||||||
,opmode(0, 1, 1, 0, 1, iABC) /* OP_CALL */
|
|
||||||
,opmode(0, 1, 1, 0, 1, iABC) /* OP_TAILCALL */
|
|
||||||
,opmode(0, 0, 1, 0, 0, iABC) /* OP_RETURN */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_RETURN0 */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_RETURN1 */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABx) /* OP_FORLOOP */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABx) /* OP_FORPREP */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABx) /* OP_TFORPREP */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iABC) /* OP_TFORCALL */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABx) /* OP_TFORLOOP */
|
|
||||||
,opmode(0, 0, 1, 0, 0, iABC) /* OP_SETLIST */
|
|
||||||
,opmode(0, 0, 0, 0, 1, iABx) /* OP_CLOSURE */
|
|
||||||
,opmode(0, 1, 0, 0, 1, iABC) /* OP_VARARG */
|
|
||||||
,opmode(0, 0, 1, 0, 1, iABC) /* OP_VARARGPREP */
|
|
||||||
,opmode(0, 0, 0, 0, 0, iAx) /* OP_EXTRAARG */
|
|
||||||
};
|
|
||||||
|
|
||||||
@ -1,405 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lopcodes.h $
|
|
||||||
** Opcodes for Lua virtual machine
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lopcodes_h
|
|
||||||
#define lopcodes_h
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*===========================================================================
|
|
||||||
We assume that instructions are unsigned 32-bit integers.
|
|
||||||
All instructions have an opcode in the first 7 bits.
|
|
||||||
Instructions can have the following formats:
|
|
||||||
|
|
||||||
3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
|
|
||||||
1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
|
|
||||||
iABC C(8) | B(8) |k| A(8) | Op(7) |
|
|
||||||
iABx Bx(17) | A(8) | Op(7) |
|
|
||||||
iAsBx sBx (signed)(17) | A(8) | Op(7) |
|
|
||||||
iAx Ax(25) | Op(7) |
|
|
||||||
isJ sJ (signed)(25) | Op(7) |
|
|
||||||
|
|
||||||
A signed argument is represented in excess K: the represented value is
|
|
||||||
the written unsigned value minus K, where K is half the maximum for the
|
|
||||||
corresponding unsigned argument.
|
|
||||||
===========================================================================*/
|
|
||||||
|
|
||||||
|
|
||||||
enum OpMode {iABC, iABx, iAsBx, iAx, isJ}; /* basic instruction formats */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** size and position of opcode arguments.
|
|
||||||
*/
|
|
||||||
#define SIZE_C 8
|
|
||||||
#define SIZE_B 8
|
|
||||||
#define SIZE_Bx (SIZE_C + SIZE_B + 1)
|
|
||||||
#define SIZE_A 8
|
|
||||||
#define SIZE_Ax (SIZE_Bx + SIZE_A)
|
|
||||||
#define SIZE_sJ (SIZE_Bx + SIZE_A)
|
|
||||||
|
|
||||||
#define SIZE_OP 7
|
|
||||||
|
|
||||||
#define POS_OP 0
|
|
||||||
|
|
||||||
#define POS_A (POS_OP + SIZE_OP)
|
|
||||||
#define POS_k (POS_A + SIZE_A)
|
|
||||||
#define POS_B (POS_k + 1)
|
|
||||||
#define POS_C (POS_B + SIZE_B)
|
|
||||||
|
|
||||||
#define POS_Bx POS_k
|
|
||||||
|
|
||||||
#define POS_Ax POS_A
|
|
||||||
|
|
||||||
#define POS_sJ POS_A
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** limits for opcode arguments.
|
|
||||||
** we use (signed) 'int' to manipulate most arguments,
|
|
||||||
** so they must fit in ints.
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* Check whether type 'int' has at least 'b' bits ('b' < 32) */
|
|
||||||
#define L_INTHASBITS(b) ((UINT_MAX >> ((b) - 1)) >= 1)
|
|
||||||
|
|
||||||
|
|
||||||
#if L_INTHASBITS(SIZE_Bx)
|
|
||||||
#define MAXARG_Bx ((1<<SIZE_Bx)-1)
|
|
||||||
#else
|
|
||||||
#define MAXARG_Bx MAX_INT
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define OFFSET_sBx (MAXARG_Bx>>1) /* 'sBx' is signed */
|
|
||||||
|
|
||||||
|
|
||||||
#if L_INTHASBITS(SIZE_Ax)
|
|
||||||
#define MAXARG_Ax ((1<<SIZE_Ax)-1)
|
|
||||||
#else
|
|
||||||
#define MAXARG_Ax MAX_INT
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#if L_INTHASBITS(SIZE_sJ)
|
|
||||||
#define MAXARG_sJ ((1 << SIZE_sJ) - 1)
|
|
||||||
#else
|
|
||||||
#define MAXARG_sJ MAX_INT
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define OFFSET_sJ (MAXARG_sJ >> 1)
|
|
||||||
|
|
||||||
|
|
||||||
#define MAXARG_A ((1<<SIZE_A)-1)
|
|
||||||
#define MAXARG_B ((1<<SIZE_B)-1)
|
|
||||||
#define MAXARG_C ((1<<SIZE_C)-1)
|
|
||||||
#define OFFSET_sC (MAXARG_C >> 1)
|
|
||||||
|
|
||||||
#define int2sC(i) ((i) + OFFSET_sC)
|
|
||||||
#define sC2int(i) ((i) - OFFSET_sC)
|
|
||||||
|
|
||||||
|
|
||||||
/* creates a mask with 'n' 1 bits at position 'p' */
|
|
||||||
#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p))
|
|
||||||
|
|
||||||
/* creates a mask with 'n' 0 bits at position 'p' */
|
|
||||||
#define MASK0(n,p) (~MASK1(n,p))
|
|
||||||
|
|
||||||
/*
|
|
||||||
** the following macros help to manipulate instructions
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
|
|
||||||
#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
|
|
||||||
((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
|
|
||||||
|
|
||||||
#define checkopm(i,m) (getOpMode(GET_OPCODE(i)) == m)
|
|
||||||
|
|
||||||
|
|
||||||
#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0)))
|
|
||||||
#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \
|
|
||||||
((cast(Instruction, v)<<pos)&MASK1(size,pos))))
|
|
||||||
|
|
||||||
#define GETARG_A(i) getarg(i, POS_A, SIZE_A)
|
|
||||||
#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A)
|
|
||||||
|
|
||||||
#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B))
|
|
||||||
#define GETARG_sB(i) sC2int(GETARG_B(i))
|
|
||||||
#define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B)
|
|
||||||
|
|
||||||
#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C))
|
|
||||||
#define GETARG_sC(i) sC2int(GETARG_C(i))
|
|
||||||
#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C)
|
|
||||||
|
|
||||||
#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k)))))
|
|
||||||
#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1))
|
|
||||||
#define SETARG_k(i,v) setarg(i, v, POS_k, 1)
|
|
||||||
|
|
||||||
#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx))
|
|
||||||
#define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx)
|
|
||||||
|
|
||||||
#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax))
|
|
||||||
#define SETARG_Ax(i,v) setarg(i, v, POS_Ax, SIZE_Ax)
|
|
||||||
|
|
||||||
#define GETARG_sBx(i) \
|
|
||||||
check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx)
|
|
||||||
#define SETARG_sBx(i,b) SETARG_Bx((i),cast_uint((b)+OFFSET_sBx))
|
|
||||||
|
|
||||||
#define GETARG_sJ(i) \
|
|
||||||
check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ)
|
|
||||||
#define SETARG_sJ(i,j) \
|
|
||||||
setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ)
|
|
||||||
|
|
||||||
|
|
||||||
#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<<POS_OP) \
|
|
||||||
| (cast(Instruction, a)<<POS_A) \
|
|
||||||
| (cast(Instruction, b)<<POS_B) \
|
|
||||||
| (cast(Instruction, c)<<POS_C) \
|
|
||||||
| (cast(Instruction, k)<<POS_k))
|
|
||||||
|
|
||||||
#define CREATE_ABx(o,a,bc) ((cast(Instruction, o)<<POS_OP) \
|
|
||||||
| (cast(Instruction, a)<<POS_A) \
|
|
||||||
| (cast(Instruction, bc)<<POS_Bx))
|
|
||||||
|
|
||||||
#define CREATE_Ax(o,a) ((cast(Instruction, o)<<POS_OP) \
|
|
||||||
| (cast(Instruction, a)<<POS_Ax))
|
|
||||||
|
|
||||||
#define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \
|
|
||||||
| (cast(Instruction, j) << POS_sJ) \
|
|
||||||
| (cast(Instruction, k) << POS_k))
|
|
||||||
|
|
||||||
|
|
||||||
#if !defined(MAXINDEXRK) /* (for debugging only) */
|
|
||||||
#define MAXINDEXRK MAXARG_B
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** invalid register that fits in 8 bits
|
|
||||||
*/
|
|
||||||
#define NO_REG MAXARG_A
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** R[x] - register
|
|
||||||
** K[x] - constant (in constant table)
|
|
||||||
** RK(x) == if k(i) then K[x] else R[x]
|
|
||||||
*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Grep "ORDER OP" if you change these enums. Opcodes marked with a (*)
|
|
||||||
** has extra descriptions in the notes after the enumeration.
|
|
||||||
*/
|
|
||||||
|
|
||||||
typedef enum {
|
|
||||||
/*----------------------------------------------------------------------
|
|
||||||
name args description
|
|
||||||
------------------------------------------------------------------------*/
|
|
||||||
OP_MOVE,/* A B R[A] := R[B] */
|
|
||||||
OP_LOADI,/* A sBx R[A] := sBx */
|
|
||||||
OP_LOADF,/* A sBx R[A] := (lua_Number)sBx */
|
|
||||||
OP_LOADK,/* A Bx R[A] := K[Bx] */
|
|
||||||
OP_LOADKX,/* A R[A] := K[extra arg] */
|
|
||||||
OP_LOADFALSE,/* A R[A] := false */
|
|
||||||
OP_LFALSESKIP,/*A R[A] := false; pc++ (*) */
|
|
||||||
OP_LOADTRUE,/* A R[A] := true */
|
|
||||||
OP_LOADNIL,/* A B R[A], R[A+1], ..., R[A+B] := nil */
|
|
||||||
OP_GETUPVAL,/* A B R[A] := UpValue[B] */
|
|
||||||
OP_SETUPVAL,/* A B UpValue[B] := R[A] */
|
|
||||||
|
|
||||||
OP_GETTABUP,/* A B C R[A] := UpValue[B][K[C]:string] */
|
|
||||||
OP_GETTABLE,/* A B C R[A] := R[B][R[C]] */
|
|
||||||
OP_GETI,/* A B C R[A] := R[B][C] */
|
|
||||||
OP_GETFIELD,/* A B C R[A] := R[B][K[C]:string] */
|
|
||||||
|
|
||||||
OP_SETTABUP,/* A B C UpValue[A][K[B]:string] := RK(C) */
|
|
||||||
OP_SETTABLE,/* A B C R[A][R[B]] := RK(C) */
|
|
||||||
OP_SETI,/* A B C R[A][B] := RK(C) */
|
|
||||||
OP_SETFIELD,/* A B C R[A][K[B]:string] := RK(C) */
|
|
||||||
|
|
||||||
OP_NEWTABLE,/* A B C k R[A] := {} */
|
|
||||||
|
|
||||||
OP_SELF,/* A B C R[A+1] := R[B]; R[A] := R[B][RK(C):string] */
|
|
||||||
|
|
||||||
OP_ADDI,/* A B sC R[A] := R[B] + sC */
|
|
||||||
|
|
||||||
OP_ADDK,/* A B C R[A] := R[B] + K[C]:number */
|
|
||||||
OP_SUBK,/* A B C R[A] := R[B] - K[C]:number */
|
|
||||||
OP_MULK,/* A B C R[A] := R[B] * K[C]:number */
|
|
||||||
OP_MODK,/* A B C R[A] := R[B] % K[C]:number */
|
|
||||||
OP_POWK,/* A B C R[A] := R[B] ^ K[C]:number */
|
|
||||||
OP_DIVK,/* A B C R[A] := R[B] / K[C]:number */
|
|
||||||
OP_IDIVK,/* A B C R[A] := R[B] // K[C]:number */
|
|
||||||
|
|
||||||
OP_BANDK,/* A B C R[A] := R[B] & K[C]:integer */
|
|
||||||
OP_BORK,/* A B C R[A] := R[B] | K[C]:integer */
|
|
||||||
OP_BXORK,/* A B C R[A] := R[B] ~ K[C]:integer */
|
|
||||||
|
|
||||||
OP_SHRI,/* A B sC R[A] := R[B] >> sC */
|
|
||||||
OP_SHLI,/* A B sC R[A] := sC << R[B] */
|
|
||||||
|
|
||||||
OP_ADD,/* A B C R[A] := R[B] + R[C] */
|
|
||||||
OP_SUB,/* A B C R[A] := R[B] - R[C] */
|
|
||||||
OP_MUL,/* A B C R[A] := R[B] * R[C] */
|
|
||||||
OP_MOD,/* A B C R[A] := R[B] % R[C] */
|
|
||||||
OP_POW,/* A B C R[A] := R[B] ^ R[C] */
|
|
||||||
OP_DIV,/* A B C R[A] := R[B] / R[C] */
|
|
||||||
OP_IDIV,/* A B C R[A] := R[B] // R[C] */
|
|
||||||
|
|
||||||
OP_BAND,/* A B C R[A] := R[B] & R[C] */
|
|
||||||
OP_BOR,/* A B C R[A] := R[B] | R[C] */
|
|
||||||
OP_BXOR,/* A B C R[A] := R[B] ~ R[C] */
|
|
||||||
OP_SHL,/* A B C R[A] := R[B] << R[C] */
|
|
||||||
OP_SHR,/* A B C R[A] := R[B] >> R[C] */
|
|
||||||
|
|
||||||
OP_MMBIN,/* A B C call C metamethod over R[A] and R[B] (*) */
|
|
||||||
OP_MMBINI,/* A sB C k call C metamethod over R[A] and sB */
|
|
||||||
OP_MMBINK,/* A B C k call C metamethod over R[A] and K[B] */
|
|
||||||
|
|
||||||
OP_UNM,/* A B R[A] := -R[B] */
|
|
||||||
OP_BNOT,/* A B R[A] := ~R[B] */
|
|
||||||
OP_NOT,/* A B R[A] := not R[B] */
|
|
||||||
OP_LEN,/* A B R[A] := #R[B] (length operator) */
|
|
||||||
|
|
||||||
OP_CONCAT,/* A B R[A] := R[A].. ... ..R[A + B - 1] */
|
|
||||||
|
|
||||||
OP_CLOSE,/* A close all upvalues >= R[A] */
|
|
||||||
OP_TBC,/* A mark variable A "to be closed" */
|
|
||||||
OP_JMP,/* sJ pc += sJ */
|
|
||||||
OP_EQ,/* A B k if ((R[A] == R[B]) ~= k) then pc++ */
|
|
||||||
OP_LT,/* A B k if ((R[A] < R[B]) ~= k) then pc++ */
|
|
||||||
OP_LE,/* A B k if ((R[A] <= R[B]) ~= k) then pc++ */
|
|
||||||
|
|
||||||
OP_EQK,/* A B k if ((R[A] == K[B]) ~= k) then pc++ */
|
|
||||||
OP_EQI,/* A sB k if ((R[A] == sB) ~= k) then pc++ */
|
|
||||||
OP_LTI,/* A sB k if ((R[A] < sB) ~= k) then pc++ */
|
|
||||||
OP_LEI,/* A sB k if ((R[A] <= sB) ~= k) then pc++ */
|
|
||||||
OP_GTI,/* A sB k if ((R[A] > sB) ~= k) then pc++ */
|
|
||||||
OP_GEI,/* A sB k if ((R[A] >= sB) ~= k) then pc++ */
|
|
||||||
|
|
||||||
OP_TEST,/* A k if (not R[A] == k) then pc++ */
|
|
||||||
OP_TESTSET,/* A B k if (not R[B] == k) then pc++ else R[A] := R[B] (*) */
|
|
||||||
|
|
||||||
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 k return R[A](R[A+1], ... ,R[A+B-1]) */
|
|
||||||
|
|
||||||
OP_RETURN,/* A B C k return R[A], ... ,R[A+B-2] (see note) */
|
|
||||||
OP_RETURN0,/* return */
|
|
||||||
OP_RETURN1,/* A return R[A] */
|
|
||||||
|
|
||||||
OP_FORLOOP,/* A Bx update counters; if loop continues then pc-=Bx; */
|
|
||||||
OP_FORPREP,/* A Bx <check values and prepare counters>;
|
|
||||||
if not to run then pc+=Bx+1; */
|
|
||||||
|
|
||||||
OP_TFORPREP,/* A Bx create upvalue for R[A + 3]; pc+=Bx */
|
|
||||||
OP_TFORCALL,/* A C R[A+4], ... ,R[A+3+C] := R[A](R[A+1], R[A+2]); */
|
|
||||||
OP_TFORLOOP,/* A Bx if R[A+2] ~= nil then { R[A]=R[A+2]; pc -= Bx } */
|
|
||||||
|
|
||||||
OP_SETLIST,/* A B C k R[A][C+i] := R[A+i], 1 <= i <= B */
|
|
||||||
|
|
||||||
OP_CLOSURE,/* A Bx R[A] := closure(KPROTO[Bx]) */
|
|
||||||
|
|
||||||
OP_VARARG,/* A C R[A], R[A+1], ..., R[A+C-2] = vararg */
|
|
||||||
|
|
||||||
OP_VARARGPREP,/*A (adjust vararg parameters) */
|
|
||||||
|
|
||||||
OP_EXTRAARG/* Ax extra (larger) argument for previous opcode */
|
|
||||||
} OpCode;
|
|
||||||
|
|
||||||
|
|
||||||
#define NUM_OPCODES ((int)(OP_EXTRAARG) + 1)
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*===========================================================================
|
|
||||||
Notes:
|
|
||||||
|
|
||||||
(*) Opcode OP_LFALSESKIP is used to convert a condition to a boolean
|
|
||||||
value, in a code equivalent to (not cond ? false : true). (It
|
|
||||||
produces false and skips the next instruction producing true.)
|
|
||||||
|
|
||||||
(*) Opcodes OP_MMBIN and variants follow each arithmetic and
|
|
||||||
bitwise opcode. If the operation succeeds, it skips this next
|
|
||||||
opcode. Otherwise, this opcode calls the corresponding metamethod.
|
|
||||||
|
|
||||||
(*) Opcode OP_TESTSET is used in short-circuit expressions that need
|
|
||||||
both to jump and to produce a value, such as (a = b or c).
|
|
||||||
|
|
||||||
(*) In OP_CALL, if (B == 0) then B = top - A. If (C == 0), then
|
|
||||||
'top' is set to last_result+1, so next open instruction (OP_CALL,
|
|
||||||
OP_RETURN*, OP_SETLIST) may use 'top'.
|
|
||||||
|
|
||||||
(*) In OP_VARARG, if (C == 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_LOADKX and OP_NEWTABLE, the next instruction is always
|
|
||||||
OP_EXTRAARG.
|
|
||||||
|
|
||||||
(*) In OP_SETLIST, if (B == 0) then real B = 'top'; if k, then
|
|
||||||
real C = EXTRAARG _ C (the bits of EXTRAARG concatenated with the
|
|
||||||
bits of C).
|
|
||||||
|
|
||||||
(*) In OP_NEWTABLE, B is log2 of the hash size (which is always a
|
|
||||||
power of 2) plus 1, or zero for size zero. If not k, the array size
|
|
||||||
is C. Otherwise, the array size is EXTRAARG _ C.
|
|
||||||
|
|
||||||
(*) For comparisons, k specifies what condition the test should accept
|
|
||||||
(true or false).
|
|
||||||
|
|
||||||
(*) In OP_MMBINI/OP_MMBINK, k means the arguments were flipped
|
|
||||||
(the constant is the first operand).
|
|
||||||
|
|
||||||
(*) All 'skips' (pc++) assume that next instruction is a jump.
|
|
||||||
|
|
||||||
(*) In instructions OP_RETURN/OP_TAILCALL, 'k' specifies that the
|
|
||||||
function builds upvalues, which may need to be closed. C > 0 means
|
|
||||||
the function is vararg, so that its 'func' must be corrected before
|
|
||||||
returning; in this case, (C - 1) is its number of fixed parameters.
|
|
||||||
|
|
||||||
(*) In comparisons with an immediate operand, C signals whether the
|
|
||||||
original operand was a float. (It must be corrected in case of
|
|
||||||
metamethods.)
|
|
||||||
|
|
||||||
===========================================================================*/
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** masks for instruction properties. The format is:
|
|
||||||
** bits 0-2: op mode
|
|
||||||
** bit 3: instruction set register A
|
|
||||||
** bit 4: operator is a test (next instruction must be a jump)
|
|
||||||
** bit 5: instruction uses 'L->top' set by previous instruction (when B == 0)
|
|
||||||
** bit 6: instruction sets 'L->top' for next instruction (when C == 0)
|
|
||||||
** bit 7: instruction is an MM instruction (call a metamethod)
|
|
||||||
*/
|
|
||||||
|
|
||||||
LUAI_DDEC(const lu_byte luaP_opmodes[NUM_OPCODES];)
|
|
||||||
|
|
||||||
#define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 7))
|
|
||||||
#define testAMode(m) (luaP_opmodes[m] & (1 << 3))
|
|
||||||
#define testTMode(m) (luaP_opmodes[m] & (1 << 4))
|
|
||||||
#define testITMode(m) (luaP_opmodes[m] & (1 << 5))
|
|
||||||
#define testOTMode(m) (luaP_opmodes[m] & (1 << 6))
|
|
||||||
#define testMMMode(m) (luaP_opmodes[m] & (1 << 7))
|
|
||||||
|
|
||||||
/* "out top" (set top for next instruction) */
|
|
||||||
#define isOT(i) \
|
|
||||||
((testOTMode(GET_OPCODE(i)) && GETARG_C(i) == 0) || \
|
|
||||||
GET_OPCODE(i) == OP_TAILCALL)
|
|
||||||
|
|
||||||
/* "in top" (uses top from previous instruction) */
|
|
||||||
#define isIT(i) (testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0)
|
|
||||||
|
|
||||||
#define opmode(mm,ot,it,t,a,m) \
|
|
||||||
(((mm) << 7) | ((ot) << 6) | ((it) << 5) | ((t) << 4) | ((a) << 3) | (m))
|
|
||||||
|
|
||||||
|
|
||||||
/* number of list items to accumulate before a SETLIST instruction */
|
|
||||||
#define LFIELDS_PER_FLUSH 50
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,103 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lopnames.h $
|
|
||||||
** Opcode names
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if !defined(lopnames_h)
|
|
||||||
#define lopnames_h
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
|
|
||||||
|
|
||||||
/* ORDER OP */
|
|
||||||
|
|
||||||
static const char *const opnames[] = {
|
|
||||||
"MOVE",
|
|
||||||
"LOADI",
|
|
||||||
"LOADF",
|
|
||||||
"LOADK",
|
|
||||||
"LOADKX",
|
|
||||||
"LOADFALSE",
|
|
||||||
"LFALSESKIP",
|
|
||||||
"LOADTRUE",
|
|
||||||
"LOADNIL",
|
|
||||||
"GETUPVAL",
|
|
||||||
"SETUPVAL",
|
|
||||||
"GETTABUP",
|
|
||||||
"GETTABLE",
|
|
||||||
"GETI",
|
|
||||||
"GETFIELD",
|
|
||||||
"SETTABUP",
|
|
||||||
"SETTABLE",
|
|
||||||
"SETI",
|
|
||||||
"SETFIELD",
|
|
||||||
"NEWTABLE",
|
|
||||||
"SELF",
|
|
||||||
"ADDI",
|
|
||||||
"ADDK",
|
|
||||||
"SUBK",
|
|
||||||
"MULK",
|
|
||||||
"MODK",
|
|
||||||
"POWK",
|
|
||||||
"DIVK",
|
|
||||||
"IDIVK",
|
|
||||||
"BANDK",
|
|
||||||
"BORK",
|
|
||||||
"BXORK",
|
|
||||||
"SHRI",
|
|
||||||
"SHLI",
|
|
||||||
"ADD",
|
|
||||||
"SUB",
|
|
||||||
"MUL",
|
|
||||||
"MOD",
|
|
||||||
"POW",
|
|
||||||
"DIV",
|
|
||||||
"IDIV",
|
|
||||||
"BAND",
|
|
||||||
"BOR",
|
|
||||||
"BXOR",
|
|
||||||
"SHL",
|
|
||||||
"SHR",
|
|
||||||
"MMBIN",
|
|
||||||
"MMBINI",
|
|
||||||
"MMBINK",
|
|
||||||
"UNM",
|
|
||||||
"BNOT",
|
|
||||||
"NOT",
|
|
||||||
"LEN",
|
|
||||||
"CONCAT",
|
|
||||||
"CLOSE",
|
|
||||||
"TBC",
|
|
||||||
"JMP",
|
|
||||||
"EQ",
|
|
||||||
"LT",
|
|
||||||
"LE",
|
|
||||||
"EQK",
|
|
||||||
"EQI",
|
|
||||||
"LTI",
|
|
||||||
"LEI",
|
|
||||||
"GTI",
|
|
||||||
"GEI",
|
|
||||||
"TEST",
|
|
||||||
"TESTSET",
|
|
||||||
"CALL",
|
|
||||||
"TAILCALL",
|
|
||||||
"RETURN",
|
|
||||||
"RETURN0",
|
|
||||||
"RETURN1",
|
|
||||||
"FORLOOP",
|
|
||||||
"FORPREP",
|
|
||||||
"TFORPREP",
|
|
||||||
"TFORCALL",
|
|
||||||
"TFORLOOP",
|
|
||||||
"SETLIST",
|
|
||||||
"CLOSURE",
|
|
||||||
"VARARG",
|
|
||||||
"VARARGPREP",
|
|
||||||
"EXTRAARG",
|
|
||||||
NULL
|
|
||||||
};
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,428 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: loslib.c $
|
|
||||||
** Standard Operating System library
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define loslib_c
|
|
||||||
#define LUA_LIB
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <errno.h>
|
|
||||||
#include <locale.h>
|
|
||||||
#include <stdlib.h>
|
|
||||||
#include <string.h>
|
|
||||||
#include <time.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lauxlib.h"
|
|
||||||
#include "lualib.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** List of valid conversion specifiers for the 'strftime' function;
|
|
||||||
** options are grouped by length; group of length 2 start with '||'.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_STRFTIMEOPTIONS) /* { */
|
|
||||||
|
|
||||||
#if defined(LUA_USE_WINDOWS)
|
|
||||||
#define LUA_STRFTIMEOPTIONS "aAbBcdHIjmMpSUwWxXyYzZ%" \
|
|
||||||
"||" "#c#x#d#H#I#j#m#M#S#U#w#W#y#Y" /* two-char options */
|
|
||||||
#elif defined(LUA_USE_C89) /* ANSI C 89 (only 1-char options) */
|
|
||||||
#define LUA_STRFTIMEOPTIONS "aAbBcdHIjmMpSUwWxXyYZ%"
|
|
||||||
#else /* C99 specification */
|
|
||||||
#define LUA_STRFTIMEOPTIONS "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%" \
|
|
||||||
"||" "EcECExEXEyEY" "OdOeOHOIOmOMOSOuOUOVOwOWOy" /* two-char options */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Configuration for time-related stuff
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** type to represent time_t in Lua
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_NUMTIME) /* { */
|
|
||||||
|
|
||||||
#define l_timet lua_Integer
|
|
||||||
#define l_pushtime(L,t) lua_pushinteger(L,(lua_Integer)(t))
|
|
||||||
#define l_gettime(L,arg) luaL_checkinteger(L, arg)
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
#define l_timet lua_Number
|
|
||||||
#define l_pushtime(L,t) lua_pushnumber(L,(lua_Number)(t))
|
|
||||||
#define l_gettime(L,arg) luaL_checknumber(L, arg)
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
#if !defined(l_gmtime) /* { */
|
|
||||||
/*
|
|
||||||
** By default, Lua uses gmtime/localtime, except when POSIX is available,
|
|
||||||
** where it uses gmtime_r/localtime_r
|
|
||||||
*/
|
|
||||||
|
|
||||||
#if defined(LUA_USE_POSIX) /* { */
|
|
||||||
|
|
||||||
#define l_gmtime(t,r) gmtime_r(t,r)
|
|
||||||
#define l_localtime(t,r) localtime_r(t,r)
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
/* ISO C definitions */
|
|
||||||
#define l_gmtime(t,r) ((void)(r)->tm_sec, gmtime(t))
|
|
||||||
#define l_localtime(t,r) ((void)(r)->tm_sec, localtime(t))
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {==================================================================
|
|
||||||
** Configuration for 'tmpnam':
|
|
||||||
** By default, Lua uses tmpnam except when POSIX is available, where
|
|
||||||
** it uses mkstemp.
|
|
||||||
** ===================================================================
|
|
||||||
*/
|
|
||||||
#if !defined(lua_tmpnam) /* { */
|
|
||||||
|
|
||||||
#if defined(LUA_USE_POSIX) /* { */
|
|
||||||
|
|
||||||
#include <unistd.h>
|
|
||||||
|
|
||||||
#define LUA_TMPNAMBUFSIZE 32
|
|
||||||
|
|
||||||
#if !defined(LUA_TMPNAMTEMPLATE)
|
|
||||||
#define LUA_TMPNAMTEMPLATE "/tmp/lua_XXXXXX"
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#define lua_tmpnam(b,e) { \
|
|
||||||
strcpy(b, LUA_TMPNAMTEMPLATE); \
|
|
||||||
e = mkstemp(b); \
|
|
||||||
if (e != -1) close(e); \
|
|
||||||
e = (e == -1); }
|
|
||||||
|
|
||||||
#else /* }{ */
|
|
||||||
|
|
||||||
/* ISO C definitions */
|
|
||||||
#define LUA_TMPNAMBUFSIZE L_tmpnam
|
|
||||||
#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); }
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
/* }================================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
#if !defined(l_system)
|
|
||||||
#if defined(LUA_USE_IOS)
|
|
||||||
/* Despite claiming to be ISO C, iOS does not implement 'system'. */
|
|
||||||
#define l_system(cmd) ((cmd) == NULL ? 0 : -1)
|
|
||||||
#else
|
|
||||||
#define l_system(cmd) system(cmd) /* default definition */
|
|
||||||
#endif
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
static int os_execute (lua_State *L) {
|
|
||||||
const char *cmd = luaL_optstring(L, 1, NULL);
|
|
||||||
int stat;
|
|
||||||
errno = 0;
|
|
||||||
stat = l_system(cmd);
|
|
||||||
if (cmd != NULL)
|
|
||||||
return luaL_execresult(L, stat);
|
|
||||||
else {
|
|
||||||
lua_pushboolean(L, stat); /* true if there is a shell */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_remove (lua_State *L) {
|
|
||||||
const char *filename = luaL_checkstring(L, 1);
|
|
||||||
return luaL_fileresult(L, remove(filename) == 0, filename);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_rename (lua_State *L) {
|
|
||||||
const char *fromname = luaL_checkstring(L, 1);
|
|
||||||
const char *toname = luaL_checkstring(L, 2);
|
|
||||||
return luaL_fileresult(L, rename(fromname, toname) == 0, NULL);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_tmpname (lua_State *L) {
|
|
||||||
char buff[LUA_TMPNAMBUFSIZE];
|
|
||||||
int err;
|
|
||||||
lua_tmpnam(buff, err);
|
|
||||||
if (l_unlikely(err))
|
|
||||||
return luaL_error(L, "unable to generate a unique filename");
|
|
||||||
lua_pushstring(L, buff);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_getenv (lua_State *L) {
|
|
||||||
lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_clock (lua_State *L) {
|
|
||||||
lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** {======================================================
|
|
||||||
** Time/Date operations
|
|
||||||
** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
|
|
||||||
** wday=%w+1, yday=%j, isdst=? }
|
|
||||||
** =======================================================
|
|
||||||
*/
|
|
||||||
|
|
||||||
/*
|
|
||||||
** About the overflow check: an overflow cannot occur when time
|
|
||||||
** is represented by a lua_Integer, because either lua_Integer is
|
|
||||||
** large enough to represent all int fields or it is not large enough
|
|
||||||
** to represent a time that cause a field to overflow. However, if
|
|
||||||
** times are represented as doubles and lua_Integer is int, then the
|
|
||||||
** time 0x1.e1853b0d184f6p+55 would cause an overflow when adding 1900
|
|
||||||
** to compute the year.
|
|
||||||
*/
|
|
||||||
static void setfield (lua_State *L, const char *key, int value, int delta) {
|
|
||||||
#if (defined(LUA_NUMTIME) && LUA_MAXINTEGER <= INT_MAX)
|
|
||||||
if (l_unlikely(value > LUA_MAXINTEGER - delta))
|
|
||||||
luaL_error(L, "field '%s' is out-of-bound", key);
|
|
||||||
#endif
|
|
||||||
lua_pushinteger(L, (lua_Integer)value + delta);
|
|
||||||
lua_setfield(L, -2, key);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void setboolfield (lua_State *L, const char *key, int value) {
|
|
||||||
if (value < 0) /* undefined? */
|
|
||||||
return; /* does not set field */
|
|
||||||
lua_pushboolean(L, value);
|
|
||||||
lua_setfield(L, -2, key);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Set all fields from structure 'tm' in the table on top of the stack
|
|
||||||
*/
|
|
||||||
static void setallfields (lua_State *L, struct tm *stm) {
|
|
||||||
setfield(L, "year", stm->tm_year, 1900);
|
|
||||||
setfield(L, "month", stm->tm_mon, 1);
|
|
||||||
setfield(L, "day", stm->tm_mday, 0);
|
|
||||||
setfield(L, "hour", stm->tm_hour, 0);
|
|
||||||
setfield(L, "min", stm->tm_min, 0);
|
|
||||||
setfield(L, "sec", stm->tm_sec, 0);
|
|
||||||
setfield(L, "yday", stm->tm_yday, 1);
|
|
||||||
setfield(L, "wday", stm->tm_wday, 1);
|
|
||||||
setboolfield(L, "isdst", stm->tm_isdst);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int getboolfield (lua_State *L, const char *key) {
|
|
||||||
int res;
|
|
||||||
res = (lua_getfield(L, -1, key) == LUA_TNIL) ? -1 : lua_toboolean(L, -1);
|
|
||||||
lua_pop(L, 1);
|
|
||||||
return res;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int getfield (lua_State *L, const char *key, int d, int delta) {
|
|
||||||
int isnum;
|
|
||||||
int t = lua_getfield(L, -1, key); /* get field and its type */
|
|
||||||
lua_Integer res = lua_tointegerx(L, -1, &isnum);
|
|
||||||
if (!isnum) { /* field is not an integer? */
|
|
||||||
if (l_unlikely(t != LUA_TNIL)) /* some other value? */
|
|
||||||
return luaL_error(L, "field '%s' is not an integer", key);
|
|
||||||
else if (l_unlikely(d < 0)) /* absent field; no default? */
|
|
||||||
return luaL_error(L, "field '%s' missing in date table", key);
|
|
||||||
res = d;
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
if (!(res >= 0 ? res - delta <= INT_MAX : INT_MIN + delta <= res))
|
|
||||||
return luaL_error(L, "field '%s' is out-of-bound", key);
|
|
||||||
res -= delta;
|
|
||||||
}
|
|
||||||
lua_pop(L, 1);
|
|
||||||
return (int)res;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const char *checkoption (lua_State *L, const char *conv,
|
|
||||||
ptrdiff_t convlen, char *buff) {
|
|
||||||
const char *option = LUA_STRFTIMEOPTIONS;
|
|
||||||
int oplen = 1; /* length of options being checked */
|
|
||||||
for (; *option != '\0' && oplen <= convlen; option += oplen) {
|
|
||||||
if (*option == '|') /* next block? */
|
|
||||||
oplen++; /* will check options with next length (+1) */
|
|
||||||
else if (memcmp(conv, option, oplen) == 0) { /* match? */
|
|
||||||
memcpy(buff, conv, oplen); /* copy valid option to buffer */
|
|
||||||
buff[oplen] = '\0';
|
|
||||||
return conv + oplen; /* return next item */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
luaL_argerror(L, 1,
|
|
||||||
lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
|
|
||||||
return conv; /* to avoid warnings */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static time_t l_checktime (lua_State *L, int arg) {
|
|
||||||
l_timet t = l_gettime(L, arg);
|
|
||||||
luaL_argcheck(L, (time_t)t == t, arg, "time out-of-bounds");
|
|
||||||
return (time_t)t;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/* maximum size for an individual 'strftime' item */
|
|
||||||
#define SIZETIMEFMT 250
|
|
||||||
|
|
||||||
|
|
||||||
static int os_date (lua_State *L) {
|
|
||||||
size_t slen;
|
|
||||||
const char *s = luaL_optlstring(L, 1, "%c", &slen);
|
|
||||||
time_t t = luaL_opt(L, l_checktime, 2, time(NULL));
|
|
||||||
const char *se = s + slen; /* 's' end */
|
|
||||||
struct tm tmr, *stm;
|
|
||||||
if (*s == '!') { /* UTC? */
|
|
||||||
stm = l_gmtime(&t, &tmr);
|
|
||||||
s++; /* skip '!' */
|
|
||||||
}
|
|
||||||
else
|
|
||||||
stm = l_localtime(&t, &tmr);
|
|
||||||
if (stm == NULL) /* invalid date? */
|
|
||||||
return luaL_error(L,
|
|
||||||
"date result cannot be represented in this installation");
|
|
||||||
if (strcmp(s, "*t") == 0) {
|
|
||||||
lua_createtable(L, 0, 9); /* 9 = number of fields */
|
|
||||||
setallfields(L, stm);
|
|
||||||
}
|
|
||||||
else {
|
|
||||||
char cc[4]; /* buffer for individual conversion specifiers */
|
|
||||||
luaL_Buffer b;
|
|
||||||
cc[0] = '%';
|
|
||||||
luaL_buffinit(L, &b);
|
|
||||||
while (s < se) {
|
|
||||||
if (*s != '%') /* not a conversion specifier? */
|
|
||||||
luaL_addchar(&b, *s++);
|
|
||||||
else {
|
|
||||||
size_t reslen;
|
|
||||||
char *buff = luaL_prepbuffsize(&b, SIZETIMEFMT);
|
|
||||||
s++; /* skip '%' */
|
|
||||||
s = checkoption(L, s, se - s, cc + 1); /* copy specifier to 'cc' */
|
|
||||||
reslen = strftime(buff, SIZETIMEFMT, cc, stm);
|
|
||||||
luaL_addsize(&b, reslen);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
luaL_pushresult(&b);
|
|
||||||
}
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_time (lua_State *L) {
|
|
||||||
time_t t;
|
|
||||||
if (lua_isnoneornil(L, 1)) /* called without args? */
|
|
||||||
t = time(NULL); /* get current time */
|
|
||||||
else {
|
|
||||||
struct tm ts;
|
|
||||||
luaL_checktype(L, 1, LUA_TTABLE);
|
|
||||||
lua_settop(L, 1); /* make sure table is at the top */
|
|
||||||
ts.tm_year = getfield(L, "year", -1, 1900);
|
|
||||||
ts.tm_mon = getfield(L, "month", -1, 1);
|
|
||||||
ts.tm_mday = getfield(L, "day", -1, 0);
|
|
||||||
ts.tm_hour = getfield(L, "hour", 12, 0);
|
|
||||||
ts.tm_min = getfield(L, "min", 0, 0);
|
|
||||||
ts.tm_sec = getfield(L, "sec", 0, 0);
|
|
||||||
ts.tm_isdst = getboolfield(L, "isdst");
|
|
||||||
t = mktime(&ts);
|
|
||||||
setallfields(L, &ts); /* update fields with normalized values */
|
|
||||||
}
|
|
||||||
if (t != (time_t)(l_timet)t || t == (time_t)(-1))
|
|
||||||
return luaL_error(L,
|
|
||||||
"time result cannot be represented in this installation");
|
|
||||||
l_pushtime(L, t);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_difftime (lua_State *L) {
|
|
||||||
time_t t1 = l_checktime(L, 1);
|
|
||||||
time_t t2 = l_checktime(L, 2);
|
|
||||||
lua_pushnumber(L, (lua_Number)difftime(t1, t2));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
static int os_setlocale (lua_State *L) {
|
|
||||||
static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
|
|
||||||
LC_NUMERIC, LC_TIME};
|
|
||||||
static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
|
|
||||||
"numeric", "time", NULL};
|
|
||||||
const char *l = luaL_optstring(L, 1, NULL);
|
|
||||||
int op = luaL_checkoption(L, 2, "all", catnames);
|
|
||||||
lua_pushstring(L, setlocale(cat[op], l));
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static int os_exit (lua_State *L) {
|
|
||||||
int status;
|
|
||||||
if (lua_isboolean(L, 1))
|
|
||||||
status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
|
|
||||||
else
|
|
||||||
status = (int)luaL_optinteger(L, 1, EXIT_SUCCESS);
|
|
||||||
if (lua_toboolean(L, 2))
|
|
||||||
lua_close(L);
|
|
||||||
if (L) exit(status); /* 'if' to avoid warnings for unreachable 'return' */
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static const luaL_Reg syslib[] = {
|
|
||||||
{"clock", os_clock},
|
|
||||||
{"date", os_date},
|
|
||||||
{"difftime", os_difftime},
|
|
||||||
{"execute", os_execute},
|
|
||||||
{"exit", os_exit},
|
|
||||||
{"getenv", os_getenv},
|
|
||||||
{"remove", os_remove},
|
|
||||||
{"rename", os_rename},
|
|
||||||
{"setlocale", os_setlocale},
|
|
||||||
{"time", os_time},
|
|
||||||
{"tmpname", os_tmpname},
|
|
||||||
{NULL, NULL}
|
|
||||||
};
|
|
||||||
|
|
||||||
/* }====================================================== */
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
LUAMOD_API int luaopen_os (lua_State *L) {
|
|
||||||
luaL_newlib(L, syslib);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
File diff suppressed because it is too large
Load Diff
@ -1,171 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lparser.h $
|
|
||||||
** Lua Parser
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lparser_h
|
|
||||||
#define lparser_h
|
|
||||||
|
|
||||||
#include "llimits.h"
|
|
||||||
#include "lobject.h"
|
|
||||||
#include "lzio.h"
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Expression and variable descriptor.
|
|
||||||
** Code generation for variables and expressions can be delayed to allow
|
|
||||||
** optimizations; An 'expdesc' structure describes a potentially-delayed
|
|
||||||
** variable/expression. It has a description of its "main" value plus a
|
|
||||||
** list of conditional jumps that can also produce its value (generated
|
|
||||||
** by short-circuit operators 'and'/'or').
|
|
||||||
*/
|
|
||||||
|
|
||||||
/* kinds of variables/expressions */
|
|
||||||
typedef enum {
|
|
||||||
VVOID, /* when 'expdesc' describes the last expression of a list,
|
|
||||||
this kind means an empty list (so, no expression) */
|
|
||||||
VNIL, /* constant nil */
|
|
||||||
VTRUE, /* constant true */
|
|
||||||
VFALSE, /* constant false */
|
|
||||||
VK, /* constant in 'k'; info = index of constant in 'k' */
|
|
||||||
VKFLT, /* floating constant; nval = numerical float value */
|
|
||||||
VKINT, /* integer constant; ival = numerical integer value */
|
|
||||||
VKSTR, /* string constant; strval = TString address;
|
|
||||||
(string is fixed by the lexer) */
|
|
||||||
VNONRELOC, /* expression has its value in a fixed register;
|
|
||||||
info = result register */
|
|
||||||
VLOCAL, /* local variable; var.ridx = register index;
|
|
||||||
var.vidx = relative index in 'actvar.arr' */
|
|
||||||
VUPVAL, /* upvalue variable; info = index of upvalue in 'upvalues' */
|
|
||||||
VCONST, /* compile-time <const> variable;
|
|
||||||
info = absolute index in 'actvar.arr' */
|
|
||||||
VINDEXED, /* indexed variable;
|
|
||||||
ind.t = table register;
|
|
||||||
ind.idx = key's R index */
|
|
||||||
VINDEXUP, /* indexed upvalue;
|
|
||||||
ind.t = table upvalue;
|
|
||||||
ind.idx = key's K index */
|
|
||||||
VINDEXI, /* indexed variable with constant integer;
|
|
||||||
ind.t = table register;
|
|
||||||
ind.idx = key's value */
|
|
||||||
VINDEXSTR, /* indexed variable with literal string;
|
|
||||||
ind.t = table register;
|
|
||||||
ind.idx = key's K index */
|
|
||||||
VJMP, /* expression is a test/comparison;
|
|
||||||
info = pc of corresponding jump instruction */
|
|
||||||
VRELOC, /* expression can put result in any register;
|
|
||||||
info = instruction pc */
|
|
||||||
VCALL, /* expression is a function call; info = instruction pc */
|
|
||||||
VVARARG /* vararg expression; info = instruction pc */
|
|
||||||
} expkind;
|
|
||||||
|
|
||||||
|
|
||||||
#define vkisvar(k) (VLOCAL <= (k) && (k) <= VINDEXSTR)
|
|
||||||
#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR)
|
|
||||||
|
|
||||||
|
|
||||||
typedef struct expdesc {
|
|
||||||
expkind k;
|
|
||||||
union {
|
|
||||||
lua_Integer ival; /* for VKINT */
|
|
||||||
lua_Number nval; /* for VKFLT */
|
|
||||||
TString *strval; /* for VKSTR */
|
|
||||||
int info; /* for generic use */
|
|
||||||
struct { /* for indexed variables */
|
|
||||||
short idx; /* index (R or "long" K) */
|
|
||||||
lu_byte t; /* table (register or upvalue) */
|
|
||||||
} ind;
|
|
||||||
struct { /* for local variables */
|
|
||||||
lu_byte ridx; /* register holding the variable */
|
|
||||||
unsigned short vidx; /* compiler index (in 'actvar.arr') */
|
|
||||||
} var;
|
|
||||||
} u;
|
|
||||||
int t; /* patch list of 'exit when true' */
|
|
||||||
int f; /* patch list of 'exit when false' */
|
|
||||||
} expdesc;
|
|
||||||
|
|
||||||
|
|
||||||
/* kinds of variables */
|
|
||||||
#define VDKREG 0 /* regular */
|
|
||||||
#define RDKCONST 1 /* constant */
|
|
||||||
#define RDKTOCLOSE 2 /* to-be-closed */
|
|
||||||
#define RDKCTC 3 /* compile-time constant */
|
|
||||||
|
|
||||||
/* description of an active local variable */
|
|
||||||
typedef union Vardesc {
|
|
||||||
struct {
|
|
||||||
TValuefields; /* constant value (if it is a compile-time constant) */
|
|
||||||
lu_byte kind;
|
|
||||||
lu_byte ridx; /* register holding the variable */
|
|
||||||
short pidx; /* index of the variable in the Proto's 'locvars' array */
|
|
||||||
TString *name; /* variable name */
|
|
||||||
} vd;
|
|
||||||
TValue k; /* constant value (if any) */
|
|
||||||
} Vardesc;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/* description of pending goto statements and label statements */
|
|
||||||
typedef struct Labeldesc {
|
|
||||||
TString *name; /* label identifier */
|
|
||||||
int pc; /* position in code */
|
|
||||||
int line; /* line where it appeared */
|
|
||||||
lu_byte nactvar; /* number of active variables in that position */
|
|
||||||
lu_byte close; /* goto that escapes upvalues */
|
|
||||||
} Labeldesc;
|
|
||||||
|
|
||||||
|
|
||||||
/* list of labels or gotos */
|
|
||||||
typedef struct Labellist {
|
|
||||||
Labeldesc *arr; /* array */
|
|
||||||
int n; /* number of entries in use */
|
|
||||||
int size; /* array size */
|
|
||||||
} Labellist;
|
|
||||||
|
|
||||||
|
|
||||||
/* dynamic structures used by the parser */
|
|
||||||
typedef struct Dyndata {
|
|
||||||
struct { /* list of all active local variables */
|
|
||||||
Vardesc *arr;
|
|
||||||
int n;
|
|
||||||
int size;
|
|
||||||
} actvar;
|
|
||||||
Labellist gt; /* list of pending gotos */
|
|
||||||
Labellist label; /* list of active labels */
|
|
||||||
} Dyndata;
|
|
||||||
|
|
||||||
|
|
||||||
/* control of blocks */
|
|
||||||
struct BlockCnt; /* defined in lparser.c */
|
|
||||||
|
|
||||||
|
|
||||||
/* state needed to generate code for a given function */
|
|
||||||
typedef struct FuncState {
|
|
||||||
Proto *f; /* current function header */
|
|
||||||
struct FuncState *prev; /* enclosing function */
|
|
||||||
struct LexState *ls; /* lexical state */
|
|
||||||
struct BlockCnt *bl; /* chain of current blocks */
|
|
||||||
int pc; /* next position to code (equivalent to 'ncode') */
|
|
||||||
int lasttarget; /* 'label' of last 'jump label' */
|
|
||||||
int previousline; /* last line that was saved in 'lineinfo' */
|
|
||||||
int nk; /* number of elements in 'k' */
|
|
||||||
int np; /* number of elements in 'p' */
|
|
||||||
int nabslineinfo; /* number of elements in 'abslineinfo' */
|
|
||||||
int firstlocal; /* index of first local var (in Dyndata array) */
|
|
||||||
int firstlabel; /* index of first label (in 'dyd->label->arr') */
|
|
||||||
short ndebugvars; /* number of elements in 'f->locvars' */
|
|
||||||
lu_byte nactvar; /* number of active local variables */
|
|
||||||
lu_byte nups; /* number of upvalues */
|
|
||||||
lu_byte freereg; /* first free register */
|
|
||||||
lu_byte iwthabs; /* instructions issued since last absolute line info */
|
|
||||||
lu_byte needclose; /* function needs to close upvalues when returning */
|
|
||||||
} FuncState;
|
|
||||||
|
|
||||||
|
|
||||||
LUAI_FUNC int luaY_nvarstack (FuncState *fs);
|
|
||||||
LUAI_FUNC LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
|
|
||||||
Dyndata *dyd, const char *name, int firstchar);
|
|
||||||
|
|
||||||
|
|
||||||
#endif
|
|
||||||
@ -1,45 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lprefix.h $
|
|
||||||
** Definitions for Lua code that must come before any other header file
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#ifndef lprefix_h
|
|
||||||
#define lprefix_h
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Allows POSIX/XSI stuff
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_USE_C89) /* { */
|
|
||||||
|
|
||||||
#if !defined(_XOPEN_SOURCE)
|
|
||||||
#define _XOPEN_SOURCE 600
|
|
||||||
#elif _XOPEN_SOURCE == 0
|
|
||||||
#undef _XOPEN_SOURCE /* use -D_XOPEN_SOURCE=0 to undefine it */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Allows manipulation of large files in gcc and some other compilers
|
|
||||||
*/
|
|
||||||
#if !defined(LUA_32BITS) && !defined(_FILE_OFFSET_BITS)
|
|
||||||
#define _LARGEFILE_SOURCE 1
|
|
||||||
#define _FILE_OFFSET_BITS 64
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Windows stuff
|
|
||||||
*/
|
|
||||||
#if defined(_WIN32) /* { */
|
|
||||||
|
|
||||||
#if !defined(_CRT_SECURE_NO_WARNINGS)
|
|
||||||
#define _CRT_SECURE_NO_WARNINGS /* avoid warnings about ISO C functions */
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif /* } */
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
@ -1,437 +0,0 @@
|
|||||||
/*
|
|
||||||
** $Id: lstate.c $
|
|
||||||
** Global State
|
|
||||||
** See Copyright Notice in lua.h
|
|
||||||
*/
|
|
||||||
|
|
||||||
#define lstate_c
|
|
||||||
#define LUA_CORE
|
|
||||||
|
|
||||||
#include "lprefix.h"
|
|
||||||
|
|
||||||
|
|
||||||
#include <stddef.h>
|
|
||||||
#include <string.h>
|
|
||||||
|
|
||||||
#include "lua.h"
|
|
||||||
|
|
||||||
#include "lapi.h"
|
|
||||||
#include "ldebug.h"
|
|
||||||
#include "ldo.h"
|
|
||||||
#include "lfunc.h"
|
|
||||||
#include "lgc.h"
|
|
||||||
#include "llex.h"
|
|
||||||
#include "lmem.h"
|
|
||||||
#include "lstate.h"
|
|
||||||
#include "lstring.h"
|
|
||||||
#include "ltable.h"
|
|
||||||
#include "ltm.h"
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** thread state + extra space
|
|
||||||
*/
|
|
||||||
typedef struct LX {
|
|
||||||
lu_byte extra_[LUA_EXTRASPACE];
|
|
||||||
lua_State l;
|
|
||||||
} LX;
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Main thread combines a thread state and the global state
|
|
||||||
*/
|
|
||||||
typedef struct LG {
|
|
||||||
LX l;
|
|
||||||
global_State g;
|
|
||||||
} LG;
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** A macro to create a "random" seed when a state is created;
|
|
||||||
** the seed is used to randomize string hashes.
|
|
||||||
*/
|
|
||||||
#if !defined(luai_makeseed)
|
|
||||||
|
|
||||||
#include <time.h>
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Compute an initial seed with some level of randomness.
|
|
||||||
** Rely on Address Space Layout Randomization (if present) and
|
|
||||||
** current time.
|
|
||||||
*/
|
|
||||||
#define addbuff(b,p,e) \
|
|
||||||
{ size_t t = cast_sizet(e); \
|
|
||||||
memcpy(b + p, &t, sizeof(t)); p += sizeof(t); }
|
|
||||||
|
|
||||||
static unsigned int luai_makeseed (lua_State *L) {
|
|
||||||
char buff[3 * sizeof(size_t)];
|
|
||||||
unsigned int h = cast_uint(time(NULL));
|
|
||||||
int p = 0;
|
|
||||||
addbuff(buff, p, L); /* heap variable */
|
|
||||||
addbuff(buff, p, &h); /* local variable */
|
|
||||||
addbuff(buff, p, &lua_newstate); /* public function */
|
|
||||||
lua_assert(p == sizeof(buff));
|
|
||||||
return luaS_hash(buff, p, h);
|
|
||||||
}
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
|
|
||||||
** invariant (and avoiding underflows in 'totalbytes')
|
|
||||||
*/
|
|
||||||
void luaE_setdebt (global_State *g, l_mem debt) {
|
|
||||||
l_mem tb = gettotalbytes(g);
|
|
||||||
lua_assert(tb > 0);
|
|
||||||
if (debt < tb - MAX_LMEM)
|
|
||||||
debt = tb - MAX_LMEM; /* will make 'totalbytes == MAX_LMEM' */
|
|
||||||
g->totalbytes = tb - debt;
|
|
||||||
g->GCdebt = debt;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int lua_setcstacklimit (lua_State *L, unsigned int limit) {
|
|
||||||
UNUSED(L); UNUSED(limit);
|
|
||||||
return LUAI_MAXCCALLS; /* warning?? */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
CallInfo *luaE_extendCI (lua_State *L) {
|
|
||||||
CallInfo *ci;
|
|
||||||
lua_assert(L->ci->next == NULL);
|
|
||||||
ci = luaM_new(L, CallInfo);
|
|
||||||
lua_assert(L->ci->next == NULL);
|
|
||||||
L->ci->next = ci;
|
|
||||||
ci->previous = L->ci;
|
|
||||||
ci->next = NULL;
|
|
||||||
ci->u.l.trap = 0;
|
|
||||||
L->nci++;
|
|
||||||
return ci;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** free all CallInfo structures not in use by a thread
|
|
||||||
*/
|
|
||||||
void luaE_freeCI (lua_State *L) {
|
|
||||||
CallInfo *ci = L->ci;
|
|
||||||
CallInfo *next = ci->next;
|
|
||||||
ci->next = NULL;
|
|
||||||
while ((ci = next) != NULL) {
|
|
||||||
next = ci->next;
|
|
||||||
luaM_free(L, ci);
|
|
||||||
L->nci--;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** free half of the CallInfo structures not in use by a thread,
|
|
||||||
** keeping the first one.
|
|
||||||
*/
|
|
||||||
void luaE_shrinkCI (lua_State *L) {
|
|
||||||
CallInfo *ci = L->ci->next; /* first free CallInfo */
|
|
||||||
CallInfo *next;
|
|
||||||
if (ci == NULL)
|
|
||||||
return; /* no extra elements */
|
|
||||||
while ((next = ci->next) != NULL) { /* two extra elements? */
|
|
||||||
CallInfo *next2 = next->next; /* next's next */
|
|
||||||
ci->next = next2; /* remove next from the list */
|
|
||||||
L->nci--;
|
|
||||||
luaM_free(L, next); /* free next */
|
|
||||||
if (next2 == NULL)
|
|
||||||
break; /* no more elements */
|
|
||||||
else {
|
|
||||||
next2->previous = ci;
|
|
||||||
ci = next2; /* continue */
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Called when 'getCcalls(L)' larger or equal to LUAI_MAXCCALLS.
|
|
||||||
** If equal, raises an overflow error. If value is larger than
|
|
||||||
** LUAI_MAXCCALLS (which means it is handling an overflow) but
|
|
||||||
** not much larger, does not report an error (to allow overflow
|
|
||||||
** handling to work).
|
|
||||||
*/
|
|
||||||
void luaE_checkcstack (lua_State *L) {
|
|
||||||
if (getCcalls(L) == LUAI_MAXCCALLS)
|
|
||||||
luaG_runerror(L, "C stack overflow");
|
|
||||||
else if (getCcalls(L) >= (LUAI_MAXCCALLS / 10 * 11))
|
|
||||||
luaD_throw(L, LUA_ERRERR); /* error while handling stack error */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUAI_FUNC void luaE_incCstack (lua_State *L) {
|
|
||||||
L->nCcalls++;
|
|
||||||
if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS))
|
|
||||||
luaE_checkcstack(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void stack_init (lua_State *L1, lua_State *L) {
|
|
||||||
int i; CallInfo *ci;
|
|
||||||
/* initialize stack array */
|
|
||||||
L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue);
|
|
||||||
L1->tbclist.p = L1->stack.p;
|
|
||||||
for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++)
|
|
||||||
setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */
|
|
||||||
L1->top.p = L1->stack.p;
|
|
||||||
L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE;
|
|
||||||
/* initialize first ci */
|
|
||||||
ci = &L1->base_ci;
|
|
||||||
ci->next = ci->previous = NULL;
|
|
||||||
ci->callstatus = CIST_C;
|
|
||||||
ci->func.p = L1->top.p;
|
|
||||||
ci->u.c.k = NULL;
|
|
||||||
ci->nresults = 0;
|
|
||||||
setnilvalue(s2v(L1->top.p)); /* 'function' entry for this 'ci' */
|
|
||||||
L1->top.p++;
|
|
||||||
ci->top.p = L1->top.p + LUA_MINSTACK;
|
|
||||||
L1->ci = ci;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void freestack (lua_State *L) {
|
|
||||||
if (L->stack.p == NULL)
|
|
||||||
return; /* stack not completely built yet */
|
|
||||||
L->ci = &L->base_ci; /* free the entire 'ci' list */
|
|
||||||
luaE_freeCI(L);
|
|
||||||
lua_assert(L->nci == 0);
|
|
||||||
luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK); /* free stack */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Create registry table and its predefined values
|
|
||||||
*/
|
|
||||||
static void init_registry (lua_State *L, global_State *g) {
|
|
||||||
/* create registry */
|
|
||||||
Table *registry = luaH_new(L);
|
|
||||||
sethvalue(L, &g->l_registry, registry);
|
|
||||||
luaH_resize(L, registry, LUA_RIDX_LAST, 0);
|
|
||||||
/* registry[LUA_RIDX_MAINTHREAD] = L */
|
|
||||||
setthvalue(L, ®istry->array[LUA_RIDX_MAINTHREAD - 1], L);
|
|
||||||
/* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */
|
|
||||||
sethvalue(L, ®istry->array[LUA_RIDX_GLOBALS - 1], luaH_new(L));
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** open parts of the state that may cause memory-allocation errors.
|
|
||||||
*/
|
|
||||||
static void f_luaopen (lua_State *L, void *ud) {
|
|
||||||
global_State *g = G(L);
|
|
||||||
UNUSED(ud);
|
|
||||||
stack_init(L, L); /* init stack */
|
|
||||||
init_registry(L, g);
|
|
||||||
luaS_init(L);
|
|
||||||
luaT_init(L);
|
|
||||||
luaX_init(L);
|
|
||||||
g->gcstp = 0; /* allow gc */
|
|
||||||
setnilvalue(&g->nilvalue); /* now state is complete */
|
|
||||||
luai_userstateopen(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** preinitialize a thread with consistent values without allocating
|
|
||||||
** any memory (to avoid errors)
|
|
||||||
*/
|
|
||||||
static void preinit_thread (lua_State *L, global_State *g) {
|
|
||||||
G(L) = g;
|
|
||||||
L->stack.p = NULL;
|
|
||||||
L->ci = NULL;
|
|
||||||
L->nci = 0;
|
|
||||||
L->twups = L; /* thread has no upvalues */
|
|
||||||
L->nCcalls = 0;
|
|
||||||
L->errorJmp = NULL;
|
|
||||||
L->hook = NULL;
|
|
||||||
L->hookmask = 0;
|
|
||||||
L->basehookcount = 0;
|
|
||||||
L->allowhook = 1;
|
|
||||||
resethookcount(L);
|
|
||||||
L->openupval = NULL;
|
|
||||||
L->status = LUA_OK;
|
|
||||||
L->errfunc = 0;
|
|
||||||
L->oldpc = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
static void close_state (lua_State *L) {
|
|
||||||
global_State *g = G(L);
|
|
||||||
if (!completestate(g)) /* closing a partially built state? */
|
|
||||||
luaC_freeallobjects(L); /* just collect its objects */
|
|
||||||
else { /* closing a fully built state */
|
|
||||||
L->ci = &L->base_ci; /* unwind CallInfo list */
|
|
||||||
luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */
|
|
||||||
luaC_freeallobjects(L); /* collect all objects */
|
|
||||||
luai_userstateclose(L);
|
|
||||||
}
|
|
||||||
luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
|
|
||||||
freestack(L);
|
|
||||||
lua_assert(gettotalbytes(g) == sizeof(LG));
|
|
||||||
(*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API lua_State *lua_newthread (lua_State *L) {
|
|
||||||
global_State *g = G(L);
|
|
||||||
GCObject *o;
|
|
||||||
lua_State *L1;
|
|
||||||
lua_lock(L);
|
|
||||||
luaC_checkGC(L);
|
|
||||||
/* create new thread */
|
|
||||||
o = luaC_newobjdt(L, LUA_TTHREAD, sizeof(LX), offsetof(LX, l));
|
|
||||||
L1 = gco2th(o);
|
|
||||||
/* anchor it on L stack */
|
|
||||||
setthvalue2s(L, L->top.p, L1);
|
|
||||||
api_incr_top(L);
|
|
||||||
preinit_thread(L1, g);
|
|
||||||
L1->hookmask = L->hookmask;
|
|
||||||
L1->basehookcount = L->basehookcount;
|
|
||||||
L1->hook = L->hook;
|
|
||||||
resethookcount(L1);
|
|
||||||
/* initialize L1 extra space */
|
|
||||||
memcpy(lua_getextraspace(L1), lua_getextraspace(g->mainthread),
|
|
||||||
LUA_EXTRASPACE);
|
|
||||||
luai_userstatethread(L, L1);
|
|
||||||
stack_init(L1, L); /* init stack */
|
|
||||||
lua_unlock(L);
|
|
||||||
return L1;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaE_freethread (lua_State *L, lua_State *L1) {
|
|
||||||
LX *l = fromstate(L1);
|
|
||||||
luaF_closeupval(L1, L1->stack.p); /* close all upvalues */
|
|
||||||
lua_assert(L1->openupval == NULL);
|
|
||||||
luai_userstatefree(L, L1);
|
|
||||||
freestack(L1);
|
|
||||||
luaM_free(L, l);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
int luaE_resetthread (lua_State *L, int status) {
|
|
||||||
CallInfo *ci = L->ci = &L->base_ci; /* unwind CallInfo list */
|
|
||||||
setnilvalue(s2v(L->stack.p)); /* 'function' entry for basic 'ci' */
|
|
||||||
ci->func.p = L->stack.p;
|
|
||||||
ci->callstatus = CIST_C;
|
|
||||||
if (status == LUA_YIELD)
|
|
||||||
status = LUA_OK;
|
|
||||||
L->status = LUA_OK; /* so it can run __close metamethods */
|
|
||||||
status = luaD_closeprotected(L, 1, status);
|
|
||||||
if (status != LUA_OK) /* errors? */
|
|
||||||
luaD_seterrorobj(L, status, L->stack.p + 1);
|
|
||||||
else
|
|
||||||
L->top.p = L->stack.p + 1;
|
|
||||||
ci->top.p = L->top.p + LUA_MINSTACK;
|
|
||||||
luaD_reallocstack(L, cast_int(ci->top.p - L->stack.p), 0);
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API int lua_resetthread (lua_State *L, lua_State *from) {
|
|
||||||
int status;
|
|
||||||
lua_lock(L);
|
|
||||||
L->nCcalls = (from) ? getCcalls(from) : 0;
|
|
||||||
status = luaE_resetthread(L, L->status);
|
|
||||||
lua_unlock(L);
|
|
||||||
return status;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
|
|
||||||
int i;
|
|
||||||
lua_State *L;
|
|
||||||
global_State *g;
|
|
||||||
LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
|
|
||||||
if (l == NULL) return NULL;
|
|
||||||
L = &l->l.l;
|
|
||||||
g = &l->g;
|
|
||||||
L->tt = LUA_VTHREAD;
|
|
||||||
g->currentwhite = bitmask(WHITE0BIT);
|
|
||||||
L->marked = luaC_white(g);
|
|
||||||
preinit_thread(L, g);
|
|
||||||
g->allgc = obj2gco(L); /* by now, only object is the main thread */
|
|
||||||
L->next = NULL;
|
|
||||||
incnny(L); /* main thread is always non yieldable */
|
|
||||||
g->frealloc = f;
|
|
||||||
g->ud = ud;
|
|
||||||
g->warnf = NULL;
|
|
||||||
g->ud_warn = NULL;
|
|
||||||
g->mainthread = L;
|
|
||||||
g->seed = luai_makeseed(L);
|
|
||||||
g->gcstp = GCSTPGC; /* no GC while building state */
|
|
||||||
g->strt.size = g->strt.nuse = 0;
|
|
||||||
g->strt.hash = NULL;
|
|
||||||
setnilvalue(&g->l_registry);
|
|
||||||
g->panic = NULL;
|
|
||||||
g->gcstate = GCSpause;
|
|
||||||
g->gckind = KGC_INC;
|
|
||||||
g->gcstopem = 0;
|
|
||||||
g->gcemergency = 0;
|
|
||||||
g->finobj = g->tobefnz = g->fixedgc = NULL;
|
|
||||||
g->firstold1 = g->survival = g->old1 = g->reallyold = NULL;
|
|
||||||
g->finobjsur = g->finobjold1 = g->finobjrold = NULL;
|
|
||||||
g->sweepgc = NULL;
|
|
||||||
g->gray = g->grayagain = NULL;
|
|
||||||
g->weak = g->ephemeron = g->allweak = NULL;
|
|
||||||
g->twups = NULL;
|
|
||||||
g->totalbytes = sizeof(LG);
|
|
||||||
g->GCdebt = 0;
|
|
||||||
g->lastatomic = 0;
|
|
||||||
setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */
|
|
||||||
setgcparam(g->gcpause, LUAI_GCPAUSE);
|
|
||||||
setgcparam(g->gcstepmul, LUAI_GCMUL);
|
|
||||||
g->gcstepsize = LUAI_GCSTEPSIZE;
|
|
||||||
setgcparam(g->genmajormul, LUAI_GENMAJORMUL);
|
|
||||||
g->genminormul = LUAI_GENMINORMUL;
|
|
||||||
for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
|
|
||||||
if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
|
|
||||||
/* memory allocation error: free partial state */
|
|
||||||
close_state(L);
|
|
||||||
L = NULL;
|
|
||||||
}
|
|
||||||
return L;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
LUA_API void lua_close (lua_State *L) {
|
|
||||||
lua_lock(L);
|
|
||||||
L = G(L)->mainthread; /* only the main thread can be closed */
|
|
||||||
close_state(L);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
void luaE_warning (lua_State *L, const char *msg, int tocont) {
|
|
||||||
lua_WarnFunction wf = G(L)->warnf;
|
|
||||||
if (wf != NULL)
|
|
||||||
wf(G(L)->ud_warn, msg, tocont);
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
/*
|
|
||||||
** Generate a warning from an error message
|
|
||||||
*/
|
|
||||||
void luaE_warnerror (lua_State *L, const char *where) {
|
|
||||||
TValue *errobj = s2v(L->top.p - 1); /* error object */
|
|
||||||
const char *msg = (ttisstring(errobj))
|
|
||||||
? svalue(errobj)
|
|
||||||
: "error object is not a string";
|
|
||||||
/* produce warning "error in %s (%s)" (where, msg) */
|
|
||||||
luaE_warning(L, "error in ", 1);
|
|
||||||
luaE_warning(L, where, 1);
|
|
||||||
luaE_warning(L, " (", 1);
|
|
||||||
luaE_warning(L, msg, 1);
|
|
||||||
luaE_warning(L, ")", 0);
|
|
||||||
}
|
|
||||||
|
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user