From 3253191437721e3c35a46f6104f5c9526302901d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=99=BD=E8=8C=B6=E6=B8=85=E6=AC=A2?= Date: Mon, 12 May 2025 16:40:33 +0800 Subject: [PATCH] =?UTF-8?q?=E9=9B=86=E6=88=90=20github.com/vadv/gopher-lua?= =?UTF-8?q?-libs,=20=E5=B9=B6=E6=94=AF=E6=8C=81=20dkjson?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lib/builtin.lua | 105 +++++++ lib/coroutine.lua | 80 ++++++ lib/debug.lua | 239 ++++++++++++++++ lib/dkjson.lua | 713 ++++++++++++++++++++++++++++++++++++++++++++++ lib/global.lua | 317 +++++++++++++++++++++ lib/io.lua | 234 +++++++++++++++ lib/math.lua | 200 +++++++++++++ lib/os.lua | 192 +++++++++++++ lib/package.lua | 197 +++++++++++++ lib/string.lua | 300 +++++++++++++++++++ lib/table.lua | 116 ++++++++ lib/utf8.lua | 82 ++++++ vm.go | 20 +- vm_test.go | 20 +- 14 files changed, 2811 insertions(+), 4 deletions(-) create mode 100644 lib/builtin.lua create mode 100644 lib/coroutine.lua create mode 100644 lib/debug.lua create mode 100644 lib/dkjson.lua create mode 100644 lib/global.lua create mode 100644 lib/io.lua create mode 100644 lib/math.lua create mode 100644 lib/os.lua create mode 100644 lib/package.lua create mode 100644 lib/string.lua create mode 100644 lib/table.lua create mode 100644 lib/utf8.lua diff --git a/lib/builtin.lua b/lib/builtin.lua new file mode 100644 index 0000000..18e55f3 --- /dev/null +++ b/lib/builtin.lua @@ -0,0 +1,105 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +-- Built-in Types + +--- +--- The type *nil* has one single value, **nil**, whose main property is to be +--- different from any other value; it usually represents the absence of a +--- useful value. +---@class nil + +--- +--- The type *boolean* has two values, **false** and **true**. Both **nil** and +--- **false** make a condition false; any other value makes it true. +---@class boolean + +--- +--- The type *number* uses two internal representations, or two subtypes, one +--- called *integer* and the other called *float*. Lua has explicit rules about +--- when each representation is used, but it also converts between them +--- automatically as needed. Therefore, the programmer may choose to mostly +--- ignore the difference between integers and floats or to assume complete +--- control over the representation of each number. Standard Lua uses 64-bit +--- integers and double-precision (64-bit) floats, but you can also compile +--- Lua so that it uses 32-bit integers and/or single-precision (32-bit) +--- floats. The option with 32 bits for both integers and floats is +--- particularly attractive for small machines and embedded systems. (See +--- macro LUA_32BITS in file luaconf.h.) +---@class number + +--- +--- Lua can call (and manipulate) functions written in Lua and functions +--- written in C. Both are represented by the type *function*. +---@class function + +--- +--- The type *userdata* is provided to allow arbitrary C data to be stored in +--- Lua variables. A userdata value represents a block of raw memory. There +--- are two kinds of userdata: *full userdata*, which is an object with a block +--- of memory managed by Lua, and *light userdata*, which is simply a C pointer +--- value. Userdata has no predefined operations in Lua, except assignment +--- and identity test. By using *metatables*, the programmer can define +--- operations for full userdata values. Userdata values cannot be +--- created or modified in Lua, only through the C API. This guarantees the +--- integrity of data owned by the host program. +---@class userdata + +--- +--- The type *thread* represents independent threads of execution and it is +--- used to implement coroutines. Lua threads are not related to +--- operating-system threads. Lua supports coroutines on all systems, even those +--- that do not support threads natively. +---@class thread + +--- +--- The type *table* implements associative arrays, that is, arrays that can +--- have as indices not only numbers, but any Lua value except **nil** and NaN. +--- (*Not a Number* is a special floating-point value used by the IEEE 754 +--- standard to represent undefined or unrepresentable numerical results, such +--- as `0/0`.) Tables can be heterogeneous; that is, they can contain values of +--- all types (except **nil**). Any key with value **nil** is not considered +--- part oft he table. Conversely, any key that is not part of a table has an +--- a ssociated value **nil**. +--- +--- Tables are the sole data-structuring mechanism in Lua; they can be used to +--- represent ordinary arrays, lists, symbol tables, sets, records, graphs, +--- trees, etc. To represent records, Lua uses the field name as an index. The +--- language supports this representation by providing `a.name` as syntactic +--- sugar for `a["name"]`. There are several convenient ways to create tables +--- in Lua. +--- +--- Like indices, the values of table fields can be of any type. In particular, +--- because functions are first-class values, table fields can contain functions. +--- Thus tables can also carry *methods*. +--- +--- The indexing of tables follows the definition of raw equality in the +--- language. The expressions `a[i]` and `a[j]` denote the same table element +--- if and only if `i` and `j` are raw equal (that is, equal without +--- metamethods). In particular, floats with integral values are equal to +--- their respective integers. To avoid ambiguities, any float with integral +--- value used as a key is converted to its respective integer. For instance, +--- if you write `a[2.0] = true`, the actual key inserted into the table will +--- be the integer `2`. (On the other hand, 2 and "`2`" are different Lua +--- values and therefore denote different table entries.) +---@class table + +--- +--- Any of the above Built-in Types. +---@class any + +--- +---@class void + +---@class self \ No newline at end of file diff --git a/lib/coroutine.lua b/lib/coroutine.lua new file mode 100644 index 0000000..ba2f7ee --- /dev/null +++ b/lib/coroutine.lua @@ -0,0 +1,80 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +coroutine = {} + +--- +--- Creates a new coroutine, with body `f`. `f` must be a Lua function. Returns +--- this new coroutine, an object with type `"thread"`. +---@param f fun():thread +---@return thread +function coroutine.create(f) end + +--- +--- Returns true when the running coroutine can yield. +--- +--- A running coroutine is yieldable if it is not the main thread and it is not +--- inside a non-yieldable C function. +---@return boolean +function coroutine.isyieldable() end + +--- +--- Starts or continues the execution of coroutine `co`. The first time you +--- resume a coroutine, it starts running its body. The values `val1`, ... +--- are passed as the arguments to the body function. If the coroutine has +--- yielded, `resume` restarts it; the values `val1`, ... are passed as the +--- results from the yield. +--- +--- If the coroutine runs without any errors, `resume` returns **true** plus any +--- values passed to `yield` (when the coroutine yields) or any values returned +--- by the body function (when the coroutine terminates). If there is any error, +--- `resume` returns **false** plus the error message. +---@overload fun(co:thread):boolean|any +---@param co thread +---@param val1 string +---@return thread|any +function coroutine.resume(co, val1, ...) end + +--- +--- Returns the running coroutine plus a boolean, true when the running +--- coroutine is the main one. +---@return thread|boolean +function coroutine.running() end + +--- +--- Returns the status of coroutine `co`, as a string: "`running`", if the +--- coroutine is running (that is, it called `status`); "`suspended`", if the +--- coroutine is suspended in a call to `yield`, or if it has not started +--- running yet; "`normal`" if the coroutine is active but not running (that +--- is, it has resumed another coroutine); and "`dead`" if the coroutine has +--- finished its body function, or if it has stopped with an error. +---@param co thread +---@return string +function coroutine.status(co) end + +--- +--- Creates a new coroutine, with body `f`. `f` must be a Lua function. Returns +--- a function that resumes the coroutine each time it is called. Any arguments +--- passed to the function behave as the extra arguments to `resume`. Returns +--- the same values returned by `resume`, except the first +--- boolean. In case of error, propagates the error. +---@param f fun():thread +---@return fun():any +function coroutine.wrap(f) end + +--- +--- Suspends the execution of the calling coroutine. Any arguments to `yield` +--- are passed as extra results to `resume`. +---@return any +function coroutine.yield(...) end diff --git a/lib/debug.lua b/lib/debug.lua new file mode 100644 index 0000000..42ab0f3 --- /dev/null +++ b/lib/debug.lua @@ -0,0 +1,239 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +debug = {} + +--- +--- Enters an interactive mode with the user, running each string that the user +--- enters. Using simple commands and other debug facilities, the user can +--- inspect global and local variables, change their values, evaluate +--- expressions, and so on. A line containing only the word `cont` finishes this +--- function, so that the caller continues its execution. +--- +--- Note that commands for `debug.debug` are not lexically nested within any +--- function, and so have no direct access to local variables. +function debug.debug() end + +--- +--- Returns the current hook settings of the thread, as three values: the +--- current hook function, the current hook mask, and the current hook count +--- (as set by the `debug.sethook` function). +---@overload fun():thread +---@param thread thread +---@return thread +function debug.gethook(thread) end + +---@class DebugInfo +---@field linedefined number +---@field lastlinedefined number +---@field currentline number +---@field func function +---@field isvararg boolean +---@field namewhat string +---@field source string +---@field nups number +---@field what string +---@field nparams number +---@field short_src string + +--- +--- Returns a table with information about a function. You can give the +--- function directly, or you can give a number as the value of `f`, +--- which means the function running at level `f` of the call stack +--- of the given thread: level 0 is the current function (`getinfo` itself); +--- level 1 is the function that called `getinfo` (except for tail calls, which +--- do not count on the stack); and so on. If `f` is a number larger than +--- the number of active functions, then `getinfo` returns **nil**. +--- +--- The returned table can contain all the fields returned by `lua_getinfo`, +--- with the string `what` describing which fields to fill in. The default for +--- `what` is to get all information available, except the table of valid +--- lines. If present, the option '`f`' adds a field named `func` with the +--- function itself. If present, the option '`L`' adds a field named +--- `activelines` with the table of valid lines. +--- +--- For instance, the expression `debug.getinfo(1,"n").name` returns a table +--- with a name for the current function, if a reasonable name can be found, +--- and the expression `debug.getinfo(print)` returns a table with all available +--- information about the `print` function. +---@overload fun(f:function):DebugInfo +---@param thread thread +---@param f function +---@param what string +---@return DebugInfo +function debug.getinfo(thread, f, what) end + +--- +--- This function returns the name and the value of the local variable with +--- index `local` of the function at level `level f` of the stack. This function +--- accesses not only explicit local variables, but also parameters, +--- temporaries, etc. +--- +--- The first parameter or local variable has index 1, and so on, following the +--- order that they are declared in the code, counting only the variables that +--- are active in the current scope of the function. Negative indices refer to +--- vararg parameters; -1 is the first vararg parameter. The function returns +--- **nil** if there is no variable with the given index, and raises an error +--- when called with a level out of range. (You can call `debug.getinfo` to +--- check whether the level is valid.) +--- +--- Variable names starting with '(' (open parenthesis) represent variables with +--- no known names (internal variables such as loop control variables, and +--- variables from chunks saved without debug information). +--- +--- The parameter `f` may also be a function. In that case, `getlocal` returns +--- only the name of function parameters. +---@overload fun(f:table, var:string):table +---@param thread thread +---@param f table +---@param var string +---@return table +function debug.getlocal(thread, f, var) end + +--- +--- Returns the metatable of the given `value` or **nil** if it does not have +--- a metatable. +---@param value table +---@return table +function debug.getmetatable(value) end + +--- +--- Returns the registry table. +---@return table +function debug.getregistry() end + +--- +--- This function returns the name and the value of the upvalue with index +--- `up` of the function `f`. The function returns **nil** if there is no +--- upvalue with the given index. +--- +--- Variable names starting with '(' (open parenthesis) represent variables with +--- no known names (variables from chunks saved without debug information). +---@param f number +---@param up number +---@return table +function debug.getupvalue(f, up) end + +--- +--- Returns the `n`-th user value associated to the userdata `u` plus a boolean, +--- **false** if the userdata does not have that value. +---@param u userdata +---@param n number +---@return boolean +function debug.getuservalue(u, n) end + +--- +--- Sets the given function as a hook. The string `mask` and the number `count` +--- describe when the hook will be called. The string mask may have any +--- combination of the following characters, with the given meaning: +--- +--- * `"c"`: the hook is called every time Lua calls a function; +--- * `"r"`: the hook is called every time Lua returns from a function; +--- * `"l"`: the hook is called every time Lua enters a new line of code. +--- +--- Moreover, with a `count` different from zero, the hook is called after every +--- `count` instructions. +--- +--- When called without arguments, `debug.sethook` turns off the hook. +--- +--- When the hook is called, its first parameter is a string describing +--- the event that has triggered its call: `"call"`, (or `"tail +--- call"`), `"return"`, `"line"`, and `"count"`. For line events, the hook also +--- gets the new line number as its second parameter. Inside a hook, you can +--- call `getinfo` with level 2 to get more information about the running +--- function (level 0 is the `getinfo` function, and level 1 is the hook +--- function) +---@overload fun(hook:(fun():any), mask:any) +---@param thread thread +---@param hook fun():any +---@param mask string +---@param count number +function debug.sethook(thread, hook, mask, count) end + +--- +--- This function assigns the value `value` to the local variable with +--- index `local` of the function at level `level` of the stack. The function +--- returns **nil** if there is no local variable with the given index, and +--- raises an error when called with a `level` out of range. (You can call +--- `getinfo` to check whether the level is valid.) Otherwise, it returns the +--- name of the local variable. +---@overload fun(level:number, var:string, value:any):string +---@param thread thread +---@param level number +---@param var string +---@param value any +---@return string +function debug.setlocal(thread, level, var, value) end + +--- +--- Sets the metatable for the given `object` to the given `table` (which +--- can be **nil**). Returns value. +---@param value any +---@param table table +---@return boolean +function debug.setmetatable(value, table) end + +--- +--- This function assigns the value `value` to the upvalue with index `up` +--- of the function `f`. The function returns **nil** if there is no upvalue +--- with the given index. Otherwise, it returns the name of the upvalue. +---@param f fun():any +---@param up number +---@param value any +---@return string +function debug.setupvalue(f, up, value) end + +--- Sets the given `value` as the `n`-th associated to the given `udata`. +--- `udata` must be a full userdata. +--- +--- Returns `udata`, or **nil** if the userdata does not have that value. +---@param udata userdata +---@param value any +---@param n number +---@return userdata +function debug.setuservalue(udata, value, n) end + +--- If `message` is present but is neither a string nor **nil**, this function +--- returns `message` without further processing. Otherwise, it returns a string +--- with a traceback of the call stack. The optional `message` string is +--- appended at the beginning of the traceback. An optional level number +--- `tells` at which level to start the traceback (default is 1, the function +--- c alling `traceback`). +---@overload fun():string +---@param thread thread +---@param message string +---@param level number +---@return string +function debug.traceback(thread, message, level) end + +--- Returns a unique identifier (as a light userdata) for the upvalue numbered +--- `n` from the given function. +--- +--- These unique identifiers allow a program to check whether different +--- closures share upvalues. Lua closures that share an upvalue (that is, that +--- access a same external local variable) will return identical ids for those +--- upvalue indices. +---@param f fun():number +---@param n number +---@return number +function debug.upvalueid(f, n) end + +--- +--- Make the `n1`-th upvalue of the Lua closure f1 refer to the `n2`-th upvalue +--- of the Lua closure f2. +---@param f1 fun():any +---@param n1 number +---@param f2 fun():any +---@param n2 number +function debug.upvaluejoin(f1, n1, f2, n2) end diff --git a/lib/dkjson.lua b/lib/dkjson.lua new file mode 100644 index 0000000..c3dd832 --- /dev/null +++ b/lib/dkjson.lua @@ -0,0 +1,713 @@ +-- Module options: +local always_try_using_lpeg = true +local register_global_module_table = false +local global_module_name = 'json' + +--[==[ + +David Kolf's JSON module for Lua 5.1/5.2 + +Version 2.5 + + +For the documentation see the corresponding readme.txt or visit +. + +You can contact the author by sending an e-mail to 'david' at the +domain 'dkolf.de'. + + +Copyright (C) 2010-2014 David Heiko Kolf + +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. + +--]==] + +-- global dependencies: +local pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset = +pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset +local error, require, pcall, select = error, require, pcall, select +local floor, huge = math.floor, math.huge +local strrep, gsub, strsub, strbyte, strchar, strfind, strlen, strformat = +string.rep, string.gsub, string.sub, string.byte, string.char, +string.find, string.len, string.format +local strmatch = string.match +local concat = table.concat + +local json = { version = "dkjson 2.5" } + +if register_global_module_table then + _G[global_module_name] = json +end + +local _ENV = nil -- blocking globals in Lua 5.2 + +pcall (function() + -- Enable access to blocked metatables. + -- Don't worry, this module doesn't change anything in them. + local debmeta = require "debug".getmetatable + if debmeta then getmetatable = debmeta end +end) + +json.null = setmetatable ({}, { + __tojson = function () return "null" end +}) + +local function isarray (tbl) + local max, n, arraylen = 0, 0, 0 + for k,v in pairs (tbl) do + if k == 'n' and type(v) == 'number' then + arraylen = v + if v > max then + max = v + end + else + if type(k) ~= 'number' or k < 1 or floor(k) ~= k then + return false + end + if k > max then + max = k + end + n = n + 1 + end + end + if max > 10 and max > arraylen and max > n * 2 then + return false -- don't create an array with too many holes + end + return true, max +end + +local escapecodes = { + ["\""] = "\\\"", ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f", + ["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t" +} + +local function escapeutf8 (uchar) + local value = escapecodes[uchar] + if value then + return value + end + local a, b, c, d = strbyte (uchar, 1, 4) + a, b, c, d = a or 0, b or 0, c or 0, d or 0 + if a <= 0x7f then + value = a + elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then + value = (a - 0xc0) * 0x40 + b - 0x80 + elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then + value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80 + elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then + value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80 + else + return "" + end + if value <= 0xffff then + return strformat ("\\u%.4x", value) + elseif value <= 0x10ffff then + -- encode as UTF-16 surrogate pair + value = value - 0x10000 + local highsur, lowsur = 0xD800 + floor (value/0x400), 0xDC00 + (value % 0x400) + return strformat ("\\u%.4x\\u%.4x", highsur, lowsur) + else + return "" + end +end + +local function fsub (str, pattern, repl) + -- gsub always builds a new string in a buffer, even when no match + -- exists. First using find should be more efficient when most strings + -- don't contain the pattern. + if strfind (str, pattern) then + return gsub (str, pattern, repl) + else + return str + end +end + +local function quotestring (value) + -- based on the regexp "escapable" in https://github.com/douglascrockford/JSON-js + value = fsub (value, "[%z\1-\31\"\\\127]", escapeutf8) + if strfind (value, "[\194\216\220\225\226\239]") then + value = fsub (value, "\194[\128-\159\173]", escapeutf8) + value = fsub (value, "\216[\128-\132]", escapeutf8) + value = fsub (value, "\220\143", escapeutf8) + value = fsub (value, "\225\158[\180\181]", escapeutf8) + value = fsub (value, "\226\128[\140-\143\168-\175]", escapeutf8) + value = fsub (value, "\226\129[\160-\175]", escapeutf8) + value = fsub (value, "\239\187\191", escapeutf8) + value = fsub (value, "\239\191[\176-\191]", escapeutf8) + end + return "\"" .. value .. "\"" +end +json.quotestring = quotestring + +local function replace(str, o, n) + local i, j = strfind (str, o, 1, true) + if i then + return strsub(str, 1, i-1) .. n .. strsub(str, j+1, -1) + else + return str + end +end + +-- locale independent num2str and str2num functions +local decpoint, numfilter + +local function updatedecpoint () + decpoint = strmatch(tostring(0.5), "([^05+])") + -- build a filter that can be used to remove group separators + numfilter = "[^0-9%-%+eE" .. gsub(decpoint, "[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%0") .. "]+" +end + +updatedecpoint() + +local function num2str (num) + return replace(fsub(tostring(num), numfilter, ""), decpoint, ".") +end + +local function str2num (str) + local num = tonumber(replace(str, ".", decpoint)) + if not num then + updatedecpoint() + num = tonumber(replace(str, ".", decpoint)) + end + return num +end + +local function addnewline2 (level, buffer, buflen) + buffer[buflen+1] = "\n" + buffer[buflen+2] = strrep (" ", level) + buflen = buflen + 2 + return buflen +end + +function json.addnewline (state) + if state.indent then + state.bufferlen = addnewline2 (state.level or 0, + state.buffer, state.bufferlen or #(state.buffer)) + end +end + +local encode2 -- forward declaration + +local function addpair (key, value, prev, indent, level, buffer, buflen, tables, globalorder, state) + local kt = type (key) + if kt ~= 'string' and kt ~= 'number' then + return nil, "type '" .. kt .. "' is not supported as a key by JSON." + end + if prev then + buflen = buflen + 1 + buffer[buflen] = "," + end + if indent then + buflen = addnewline2 (level, buffer, buflen) + end + buffer[buflen+1] = quotestring (key) + buffer[buflen+2] = ":" + return encode2 (value, indent, level, buffer, buflen + 2, tables, globalorder, state) +end + +local function appendcustom(res, buffer, state) + local buflen = state.bufferlen + if type (res) == 'string' then + buflen = buflen + 1 + buffer[buflen] = res + end + return buflen +end + +local function exception(reason, value, state, buffer, buflen, defaultmessage) + defaultmessage = defaultmessage or reason + local handler = state.exception + if not handler then + return nil, defaultmessage + else + state.bufferlen = buflen + local ret, msg = handler (reason, value, state, defaultmessage) + if not ret then return nil, msg or defaultmessage end + return appendcustom(ret, buffer, state) + end +end + +function json.encodeexception(reason, value, state, defaultmessage) + return quotestring("<" .. defaultmessage .. ">") +end + +encode2 = function (value, indent, level, buffer, buflen, tables, globalorder, state) + local valtype = type (value) + local valmeta = getmetatable (value) + valmeta = type (valmeta) == 'table' and valmeta -- only tables + local valtojson = valmeta and valmeta.__tojson + if valtojson then + if tables[value] then + return exception('reference cycle', value, state, buffer, buflen) + end + tables[value] = true + state.bufferlen = buflen + local ret, msg = valtojson (value, state) + if not ret then return exception('custom encoder failed', value, state, buffer, buflen, msg) end + tables[value] = nil + buflen = appendcustom(ret, buffer, state) + elseif value == nil then + buflen = buflen + 1 + buffer[buflen] = "null" + elseif valtype == 'number' then + local s + if value ~= value or value >= huge or -value >= huge then + -- This is the behaviour of the original JSON implementation. + s = "null" + else + s = num2str (value) + end + buflen = buflen + 1 + buffer[buflen] = s + elseif valtype == 'boolean' then + buflen = buflen + 1 + buffer[buflen] = value and "true" or "false" + elseif valtype == 'string' then + buflen = buflen + 1 + buffer[buflen] = quotestring (value) + elseif valtype == 'table' then + if tables[value] then + return exception('reference cycle', value, state, buffer, buflen) + end + tables[value] = true + level = level + 1 + local isa, n = isarray (value) + if n == 0 and valmeta and valmeta.__jsontype == 'object' then + isa = false + end + local msg + if isa then -- JSON array + buflen = buflen + 1 + buffer[buflen] = "[" + for i = 1, n do + buflen, msg = encode2 (value[i], indent, level, buffer, buflen, tables, globalorder, state) + if not buflen then return nil, msg end + if i < n then + buflen = buflen + 1 + buffer[buflen] = "," + end + end + buflen = buflen + 1 + buffer[buflen] = "]" + else -- JSON object + local prev = false + buflen = buflen + 1 + buffer[buflen] = "{" + local order = valmeta and valmeta.__jsonorder or globalorder + if order then + local used = {} + n = #order + for i = 1, n do + local k = order[i] + local v = value[k] + if v then + used[k] = true + buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state) + prev = true -- add a seperator before the next element + end + end + for k,v in pairs (value) do + if not used[k] then + buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state) + if not buflen then return nil, msg end + prev = true -- add a seperator before the next element + end + end + else -- unordered + for k,v in pairs (value) do + buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state) + if not buflen then return nil, msg end + prev = true -- add a seperator before the next element + end + end + if indent then + buflen = addnewline2 (level - 1, buffer, buflen) + end + buflen = buflen + 1 + buffer[buflen] = "}" + end + tables[value] = nil + else + return exception ('unsupported type', value, state, buffer, buflen, + "type '" .. valtype .. "' is not supported by JSON.") + end + return buflen +end + +function json.encode (value, state) + state = state or {} + local oldbuffer = state.buffer + local buffer = oldbuffer or {} + state.buffer = buffer + updatedecpoint() + local ret, msg = encode2 (value, state.indent, state.level or 0, + buffer, state.bufferlen or 0, state.tables or {}, state.keyorder, state) + if not ret then + error (msg, 2) + elseif oldbuffer == buffer then + state.bufferlen = ret + return true + else + state.bufferlen = nil + state.buffer = nil + return concat (buffer) + end +end + +local function loc (str, where) + local line, pos, linepos = 1, 1, 0 + while true do + pos = strfind (str, "\n", pos, true) + if pos and pos < where then + line = line + 1 + linepos = pos + pos = pos + 1 + else + break + end + end + return "line " .. line .. ", column " .. (where - linepos) +end + +local function unterminated (str, what, where) + return nil, strlen (str) + 1, "unterminated " .. what .. " at " .. loc (str, where) +end + +local function scanwhite (str, pos) + while true do + pos = strfind (str, "%S", pos) + if not pos then return nil end + local sub2 = strsub (str, pos, pos + 1) + if sub2 == "\239\187" and strsub (str, pos + 2, pos + 2) == "\191" then + -- UTF-8 Byte Order Mark + pos = pos + 3 + elseif sub2 == "//" then + pos = strfind (str, "[\n\r]", pos + 2) + if not pos then return nil end + elseif sub2 == "/*" then + pos = strfind (str, "*/", pos + 2) + if not pos then return nil end + pos = pos + 2 + else + return pos + end + end +end + +local escapechars = { + ["\""] = "\"", ["\\"] = "\\", ["/"] = "/", ["b"] = "\b", ["f"] = "\f", + ["n"] = "\n", ["r"] = "\r", ["t"] = "\t" +} + +local function unichar (value) + if value < 0 then + return nil + elseif value <= 0x007f then + return strchar (value) + elseif value <= 0x07ff then + return strchar (0xc0 + floor(value/0x40), + 0x80 + (floor(value) % 0x40)) + elseif value <= 0xffff then + return strchar (0xe0 + floor(value/0x1000), + 0x80 + (floor(value/0x40) % 0x40), + 0x80 + (floor(value) % 0x40)) + elseif value <= 0x10ffff then + return strchar (0xf0 + floor(value/0x40000), + 0x80 + (floor(value/0x1000) % 0x40), + 0x80 + (floor(value/0x40) % 0x40), + 0x80 + (floor(value) % 0x40)) + else + return nil + end +end + +local function scanstring (str, pos) + local lastpos = pos + 1 + local buffer, n = {}, 0 + while true do + local nextpos = strfind (str, "[\"\\]", lastpos) + if not nextpos then + return unterminated (str, "string", pos) + end + if nextpos > lastpos then + n = n + 1 + buffer[n] = strsub (str, lastpos, nextpos - 1) + end + if strsub (str, nextpos, nextpos) == "\"" then + lastpos = nextpos + 1 + break + else + local escchar = strsub (str, nextpos + 1, nextpos + 1) + local value + if escchar == "u" then + value = tonumber (strsub (str, nextpos + 2, nextpos + 5), 16) + if value then + local value2 + if 0xD800 <= value and value <= 0xDBff then + -- we have the high surrogate of UTF-16. Check if there is a + -- low surrogate escaped nearby to combine them. + if strsub (str, nextpos + 6, nextpos + 7) == "\\u" then + value2 = tonumber (strsub (str, nextpos + 8, nextpos + 11), 16) + if value2 and 0xDC00 <= value2 and value2 <= 0xDFFF then + value = (value - 0xD800) * 0x400 + (value2 - 0xDC00) + 0x10000 + else + value2 = nil -- in case it was out of range for a low surrogate + end + end + end + value = value and unichar (value) + if value then + if value2 then + lastpos = nextpos + 12 + else + lastpos = nextpos + 6 + end + end + end + end + if not value then + value = escapechars[escchar] or escchar + lastpos = nextpos + 2 + end + n = n + 1 + buffer[n] = value + end + end + if n == 1 then + return buffer[1], lastpos + elseif n > 1 then + return concat (buffer), lastpos + else + return "", lastpos + end +end + +local scanvalue -- forward declaration + +local function scantable (what, closechar, str, startpos, nullval, objectmeta, arraymeta) + local len = strlen (str) + local tbl, n = {}, 0 + local pos = startpos + 1 + if what == 'object' then + setmetatable (tbl, objectmeta) + else + setmetatable (tbl, arraymeta) + end + while true do + pos = scanwhite (str, pos) + if not pos then return unterminated (str, what, startpos) end + local char = strsub (str, pos, pos) + if char == closechar then + return tbl, pos + 1 + end + local val1, err + val1, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta) + if err then return nil, pos, err end + pos = scanwhite (str, pos) + if not pos then return unterminated (str, what, startpos) end + char = strsub (str, pos, pos) + if char == ":" then + if val1 == nil then + return nil, pos, "cannot use nil as table index (at " .. loc (str, pos) .. ")" + end + pos = scanwhite (str, pos + 1) + if not pos then return unterminated (str, what, startpos) end + local val2 + val2, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta) + if err then return nil, pos, err end + tbl[val1] = val2 + pos = scanwhite (str, pos) + if not pos then return unterminated (str, what, startpos) end + char = strsub (str, pos, pos) + else + n = n + 1 + tbl[n] = val1 + end + if char == "," then + pos = pos + 1 + end + end +end + +scanvalue = function (str, pos, nullval, objectmeta, arraymeta) + pos = pos or 1 + pos = scanwhite (str, pos) + if not pos then + return nil, strlen (str) + 1, "no valid JSON value (reached the end)" + end + local char = strsub (str, pos, pos) + if char == "{" then + return scantable ('object', "}", str, pos, nullval, objectmeta, arraymeta) + elseif char == "[" then + return scantable ('array', "]", str, pos, nullval, objectmeta, arraymeta) + elseif char == "\"" then + return scanstring (str, pos) + else + local pstart, pend = strfind (str, "^%-?[%d%.]+[eE]?[%+%-]?%d*", pos) + if pstart then + local number = str2num (strsub (str, pstart, pend)) + if number then + return number, pend + 1 + end + end + pstart, pend = strfind (str, "^%a%w*", pos) + if pstart then + local name = strsub (str, pstart, pend) + if name == "true" then + return true, pend + 1 + elseif name == "false" then + return false, pend + 1 + elseif name == "null" then + return nullval, pend + 1 + end + end + return nil, pos, "no valid JSON value at " .. loc (str, pos) + end +end + +local function optionalmetatables(...) + if select("#", ...) > 0 then + return ... + else + return {__jsontype = 'object'}, {__jsontype = 'array'} + end +end + +function json.decode (str, pos, nullval, ...) + local objectmeta, arraymeta = optionalmetatables(...) + return scanvalue (str, pos, nullval, objectmeta, arraymeta) +end + +function json.use_lpeg () + local g = require ("lpeg") + + if g.version() == "0.11" then + error "due to a bug in LPeg 0.11, it cannot be used for JSON matching" + end + + local pegmatch = g.match + local P, S, R = g.P, g.S, g.R + + local function ErrorCall (str, pos, msg, state) + if not state.msg then + state.msg = msg .. " at " .. loc (str, pos) + state.pos = pos + end + return false + end + + local function Err (msg) + return g.Cmt (g.Cc (msg) * g.Carg (2), ErrorCall) + end + + local SingleLineComment = P"//" * (1 - S"\n\r")^0 + local MultiLineComment = P"/*" * (1 - P"*/")^0 * P"*/" + local Space = (S" \n\r\t" + P"\239\187\191" + SingleLineComment + MultiLineComment)^0 + + local PlainChar = 1 - S"\"\\\n\r" + local EscapeSequence = (P"\\" * g.C (S"\"\\/bfnrt" + Err "unsupported escape sequence")) / escapechars + local HexDigit = R("09", "af", "AF") + local function UTF16Surrogate (match, pos, high, low) + high, low = tonumber (high, 16), tonumber (low, 16) + if 0xD800 <= high and high <= 0xDBff and 0xDC00 <= low and low <= 0xDFFF then + return true, unichar ((high - 0xD800) * 0x400 + (low - 0xDC00) + 0x10000) + else + return false + end + end + local function UTF16BMP (hex) + return unichar (tonumber (hex, 16)) + end + local U16Sequence = (P"\\u" * g.C (HexDigit * HexDigit * HexDigit * HexDigit)) + local UnicodeEscape = g.Cmt (U16Sequence * U16Sequence, UTF16Surrogate) + U16Sequence/UTF16BMP + local Char = UnicodeEscape + EscapeSequence + PlainChar + local String = P"\"" * g.Cs (Char ^ 0) * (P"\"" + Err "unterminated string") + local Integer = P"-"^(-1) * (P"0" + (R"19" * R"09"^0)) + local Fractal = P"." * R"09"^0 + local Exponent = (S"eE") * (S"+-")^(-1) * R"09"^1 + local Number = (Integer * Fractal^(-1) * Exponent^(-1))/str2num + local Constant = P"true" * g.Cc (true) + P"false" * g.Cc (false) + P"null" * g.Carg (1) + local SimpleValue = Number + String + Constant + local ArrayContent, ObjectContent + + -- The functions parsearray and parseobject parse only a single value/pair + -- at a time and store them directly to avoid hitting the LPeg limits. + local function parsearray (str, pos, nullval, state) + local obj, cont + local npos + local t, nt = {}, 0 + repeat + obj, cont, npos = pegmatch (ArrayContent, str, pos, nullval, state) + if not npos then break end + pos = npos + nt = nt + 1 + t[nt] = obj + until cont == 'last' + return pos, setmetatable (t, state.arraymeta) + end + + local function parseobject (str, pos, nullval, state) + local obj, key, cont + local npos + local t = {} + repeat + key, obj, cont, npos = pegmatch (ObjectContent, str, pos, nullval, state) + if not npos then break end + pos = npos + t[key] = obj + until cont == 'last' + return pos, setmetatable (t, state.objectmeta) + end + + local Array = P"[" * g.Cmt (g.Carg(1) * g.Carg(2), parsearray) * Space * (P"]" + Err "']' expected") + local Object = P"{" * g.Cmt (g.Carg(1) * g.Carg(2), parseobject) * Space * (P"}" + Err "'}' expected") + local Value = Space * (Array + Object + SimpleValue) + local ExpectedValue = Value + Space * Err "value expected" + ArrayContent = Value * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp() + local Pair = g.Cg (Space * String * Space * (P":" + Err "colon expected") * ExpectedValue) + ObjectContent = Pair * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp() + local DecodeValue = ExpectedValue * g.Cp () + + function json.decode (str, pos, nullval, ...) + local state = {} + state.objectmeta, state.arraymeta = optionalmetatables(...) + local obj, retpos = pegmatch (DecodeValue, str, pos, nullval, state) + if state.msg then + return nil, state.pos, state.msg + else + return obj, retpos + end + end + + -- use this function only once: + json.use_lpeg = function () return json end + + json.using_lpeg = true + + return json -- so you can get the module using json = require "dkjson".use_lpeg() +end + +if always_try_using_lpeg then + pcall (json.use_lpeg) +end + +return json diff --git a/lib/global.lua b/lib/global.lua new file mode 100644 index 0000000..be47648 --- /dev/null +++ b/lib/global.lua @@ -0,0 +1,317 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +--- +--- Calls error if the value of its argument `v` is false (i.e., **nil** or +--- **false**); otherwise, returns all its arguments. In case of error, +--- `message` is the error object; when absent, it defaults to "assertion +--- failed!" +---@overload fun(v:any):any +---@param v any +---@param message string +---@return any +function assert(v, message) end + +--- +--- This function is a generic interface to the garbage collector. It performs +--- different functions according to its first argument, `opt`: +--- +--- **"collect"**: performs a full garbage-collection cycle. This is the default +--- option. +--- **"stop"**: stops automatic execution of the garbage collector. The +--- collector will run only when explicitly invoked, until a call to restart it. +--- **"restart"**: restarts automatic execution of the garbage collector. +--- **"count"**: returns the total memory in use by Lua in Kbytes. The value has +--- a fractional part, so that it multiplied by 1024 gives the exact number of +--- bytes in use by Lua (except for overflows). +--- **"step"**: performs a garbage-collection step. The step "size" is +--- controlled by `arg`. With a zero value, the collector will perform one basic +--- (indivisible) step. For non-zero values, the collector will perform as if +--- that amount of memory (in KBytes) had been allocated by Lua. Returns +--- **true** if the step finished a collection cycle. +--- **"setpause"**: sets `arg` as the new value for the *pause* of the collector +--- (see §2.5). Returns the previous value for *pause`. +--- **"incremental"**: Change the collector mode to incremental. This option can +--- be followed by three numbers: the garbage-collector pause, the step +--- multiplier, and the step size. +--- **"generational"**: Change the collector mode to generational. This option +--- can be followed by two numbers: the garbage-collector minor multiplier and +--- the major multiplier. +--- **"isrunning"**: returns a boolean that tells whether the collector is +--- running (i.e., not stopped). +---@overload fun():any +---@param opt string +---@param arg string +---@return any +function collectgarbage(opt, arg) end + +--- +--- Opens the named file and executes its contents as a Lua chunk. When called +--- without arguments, `dofile` executes the contents of the standard input +--- (`stdin`). Returns all values returned by the chunk. In case of errors, +--- `dofile` propagates the error to its caller (that is, `dofile` does not run +--- in protected mode). +---@overload fun():table +---@param filename string +---@return table +function dofile(filename) end + +--- +--- Terminates the last protected function called and returns `message` as the +--- error object. Function `error` never returns. Usually, `error` adds some +--- information about the error position at the beginning of the message, if the +--- message is a string. The `level` argument specifies how to get the error +--- position. With level 1 (the default), the error position is where the +--- `error` function was called. Level 2 points the error to where the function +--- that called `error` was called; and so on. Passing a level 0 avoids the +--- addition of error position information to the message. +---@overload fun(message:string) +---@param message string +---@param level number +function error(message, level) end + +--- +--- A global variable (not a function) that holds the global environment. Lua +--- itself does not use this variable; changing its value does not affect any +--- environment, nor vice versa. +---@class _G +_G = {} + +--- +--- If `object` does not have a metatable, returns **nil**. Otherwise, if the +--- object's metatable has a `"__metatable"` field, returns the associated +--- value. Otherwise, returns the metatable of the given object. +---@param object any +---@return any +function getmetatable(object) end + +--- +--- Returns three values (an iterator function, the table `t`, and 0) so that +--- the construction +--- > `for i,v in ipairs(t) do` *body* `end` +--- will iterate over the key–value pairs (1,`t[1]`), (2,`t[2]`), ..., up to +--- the first absent index. +---@generic V +---@param t table|V[] +---@return fun(tbl: table):number, V +function ipairs(t) end + +--- +--- Loads a chunk. +--- If `chunk` is a string, the chunk is this string. If `chunk` is a function, +--- `load` calls it repeatedly to get the chunk pieces. Each call to `chunk` +--- must return a string that concatenates with previous results. A return of +--- an empty string, **nil**, or no value signals the end of the chunk. +--- +--- If there are no syntactic errors, returns the compiled chunk as a function; +--- otherwise, returns **nil** plus the error message. +--- +--- If the resulting function has upvalues, the first upvalue is set to the +--- value of `env`, if that parameter is given, or to the value of the global +--- environment. Other upvalues are initialized with **nil**. (When you load a +--- main chunk, the resulting function will always have exactly one upvalue, the +--- _ENV variable. However, when you load a binary chunk created from a +--- function (see string.dump), the resulting function can have an arbitrary +--- number of upvalues.) All upvalues are fresh, that is, they are not shared +--- with any other function. +--- +--- `chunkname` is used as the name of the chunk for error messages and debug +--- information. When absent, it defaults to `chunk`, if `chunk` is a string, +--- or to "=(`load`)" otherwise. +--- +--- The string `mode` controls whether the chunk can be text or binary (that is, +--- a precompiled chunk). It may be the string "b" (only binary chunks), "t" +--- (only text chunks), or "bt" (both binary and text). The default is "bt". +--- +--- Lua does not check the consistency of binary chunks. Maliciously crafted +--- binary chunks can crash the interpreter. +---@overload fun(chunk:fun():string):any +---@param chunk fun():string +---@param chunkname string +---@param mode string +---@param env any +function load(chunk, chunkname, mode, env) end + +--- +--- Similar to `load`, but gets the chunk from file `filename` or from the +--- standard input, if no file name is given. +---@overload fun() +---@param filename string +---@param mode string +---@param env any +function loadfile(filename, mode, env) end + +--- +--- Allows a program to traverse all fields of a table. Its first argument is +--- a table and its second argument is an index in this table. `next` returns +--- the next index of the table and its associated value. When called with +--- **nil** as its second argument, `next` returns an initial index and its +--- associated value. When called with the last index, or with **nil** in an +--- empty table, `next` returns **nil**. If the second argument is absent, then +--- it is interpreted as **nil**. In particular, you can use `next(t)` to check +--- whether a table is empty. +--- +--- The order in which the indices are enumerated is not specified, *even for +--- numeric indices*. (To traverse a table in numerical order, use a numerical +--- **for**.) +--- +--- The behavior of `next` is undefined if, during the traversal, you assign +--- any value to a non-existent field in the table. You may however modify +--- existing fields. In particular, you may set existing fields to nil. +---@overload fun(table:table):any +---@param table table +---@param index any +---@return any +function next(table, index) end + +--- +--- If `t` has a metamethod `__pairs`, calls it with `t` as argument and returns +--- the first three results from the call. +--- +--- Otherwise, returns three values: the `next` function, the table `t`, and +--- **nil**, so that the construction +--- `for k,v in pairs(t) do *body* end` +--- will iterate over all key–value pairs of table `t`. +--- +--- See function `next` for the caveats of modifying the table during its +--- traversal. +---@generic K, V +---@param t table|V[] +---@return fun(tbl: table):K, V +function pairs(t) end + +--- +--- Calls function `f` with the given arguments in *protected mode*. This +--- means that any error inside `f` is not propagated; instead, `pcall` catches +--- the error and returns a status code. Its first result is the status code (a +--- boolean), which is true if the call succeeds without errors. In such case, +--- `pcall` also returns all results from the call, after this first result. In +--- case of any error, `pcall` returns **false** plus the error message. +---@overload fun(f:fun():any):boolean|table +---@param f fun():any +---@param arg1 table +---@return boolean|table +function pcall(f, arg1, ...) end + +--- +--- Receives any number of arguments, and prints their values to `stdout`, +--- using the `tostring` function to convert them to strings. `print` is not +--- intended for formatted output, but only as a quick way to show a value, +--- for instance for debugging. For complete control over the output, use +--- `string.format` and `io.write`. +function print(...) end + +--- +--- Checks whether `v1` is equal to `v2`, without the `__eq` metamethod. Returns +--- a boolean. +---@param v1 any +---@param v2 any +---@return boolean +function rawequal(v1, v2) end + +--- +--- Gets the real value of `table[index]`, the `__index` metamethod. `table` +--- must be a table; `index` may be any value. +---@param table table +---@param index any +---@return any +function rawget(table, index) end + +--- +--- Sets the real value of `table[index]` to `value`, without invoking the +--- `__newindex` metamethod. `table` must be a table, `index` any value +--- different from **nil** and NaN, and `value` any Lua value. +---@param table table +---@param index any +---@param value any +function rawset(table, index, value) end + +--- +--- If `index` is a number, returns all arguments after argument number +--- `index`. a negative number indexes from the end (-1 is the last argument). +--- Otherwise, `index` must be the string "#", and `select` returns +--- the total number of extra arguments it received. +---@generic T +---@param index number|string +---@vararg T +---@return T +function select(index, ...) end + +--- +--- Sets the metatable for the given table. (To change the metatable of other +--- types from Lua code, you must use the debug library.) If `metatable` +--- is **nil**, removes the metatable of the given table. If the original +--- metatable has a `"__metatable"` field, raises an error. +--- +--- This function returns `table`. +---@generic T +---@param table T +---@param metatable table +---@return T +function setmetatable(table, metatable) end + +--- +--- When called with no `base`, `tonumber` tries to convert its argument to a +--- number. If the argument is already a number or a string convertible to a +--- number, then `tonumber` returns this number; otherwise, it returns **nil**. +--- +--- The conversion of strings can result in integers or floats, according to the +--- lexical conventions of Lua. (The string may have leading and trailing +--- spaces and a sign.) +--- +--- When called with `base`, then e must be a string to be interpreted as an +--- integer numeral in that base. The base may be any integer between 2 and 36, +--- inclusive. In bases above 10, the letter 'A' (in either upper or lower case) +--- represents 10, 'B' represents 11, and so forth, with 'Z' representing 35. If +--- the string `e` is not a valid numeral in the given base, the function +--- returns **nil**. +---@overload fun(e:string):any +---@param e string +---@param base number +---@return any +function tonumber(e, base) end + +--- +--- Receives a value of any type and converts it to a string in a human-readable +--- format. (For complete control of how numbers are converted, use `string +--- .format`). +--- +--- If the metatable of `v` has a `__tostring` field, then `tostring` calls +--- the corresponding value with `v` as argument, and uses the result of the +--- call as its result. +---@param v any +---@return string +function tostring(v) end + +--- +--- Returns the type of its only argument, coded as a string. The possible +--- results of this function are "`nil`" (a string, not the value **nil**), +--- "`number`", "`string`", "`boolean`", "`table`", "`function`", "`thread`", +--- and "`userdata`". +---@param v any +---@return string +function type(v) end + +--- +--- A global variable (not a function) that holds a string containing the +--- running Lua version. The current value of this variable is "`Lua 5.4`". +_VERSION = "Lua 5.4" + +--- +--- This function is similar to `pcall`, except that it sets a new message +--- handler `msgh`. +---@param f fun():any +---@param msgh fun():string +---@return any +function xpcall(f, msgh, arg1, ...) end diff --git a/lib/io.lua b/lib/io.lua new file mode 100644 index 0000000..f0c76c4 --- /dev/null +++ b/lib/io.lua @@ -0,0 +1,234 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +io = {} + +--- +--- Equivalent to `file:close()`. Without a file, closes the default output +--- file. +---@overload fun():void +---@param file file +function io.close(file) end + +--- +--- Equivalent to `io.output():flush()`. +function io.flush() end + +--- +--- When called with a file name, it opens the named file (in text mode), and +--- sets its handle as the default input file. When called with a file handle, +--- it simply sets this file handle as the default input file. When called +--- without parameters, it returns the current default input file. +--- +--- In case of errors this function raises the error, instead of returning an +--- error code. +---@overload fun():file +---@param file string | file +---@return file +function io.input(file) end + +--- +--- Opens the given file name in read mode and returns an iterator function +--- works like `file:lines(···)` over the opened file. When the iterator +--- function detects the end of file, it returns no values (to finish the loop) +--- and automatically closes the file. +--- +--- The call `io.lines()` (with no file name) is equivalent to `io.input():lines +--- ()`; that is, it iterates over the lines of the default +--- input file. In this case, the iterator does not close the file when the loop +--- ends. +--- +--- In case of errors this function raises the error, instead of returning an +--- error code. +---@overload fun():any +---@param filename string +---@return fun():any +function io.lines(filename, ...) end + +--- +--- This function opens a file, in the mode specified in the string `mode`. In +--- case of success, it returns a new file handle. The `mode` string can be +--- any of the following: +--- +--- **"r"**: read mode (the default); +--- **"w"**: write mode; +--- **"a"**: append mode; +--- **"r+"**: update mode, all previous data is preserved; +--- **"w+"**: update mode, all previous data is erased; +--- **"a+"**: append update mode, previous data is preserved, writing is only +--- allowed at the end of file. +--- +--- The `mode` string can also have a '`b`' at the end, which is needed in +--- some systems to open the file in binary mode. +---@overload fun(filename:string):file +---@param filename string +---@param mode string | '"r"' | '"w"' | '"a"' | '"r+"' | '"w+"' | '"a+"' | '"rb"' | '"wb"' | '"ab"' | '"rb+"' | '"wb+"' | '"ab+"' +---@return file +function io.open(filename, mode) return file end + +--- +--- Similar to `io.input`, but operates over the default output file. +---@overload fun():file +---@param file string | file +---@return file +function io.output(file) end + +--- +--- This function is system dependent and is not available on all platforms. +--- +--- Starts program `prog` in a separated process and returns a file handle that +--- you can use to read data from this program (if `mode` is "`r`", the default) +--- or to write data to this program (if `mode` is "`w`"). +---@overload fun(prog:string):file +---@param prog string +---@param mode string | '"r"' | '"w"' +---@return file +function io.popen(prog, mode) end + +--- +--- Equivalent to `io.input():read(···)`. +function io.read(...) end + +--- +--- In case of success, returns a handle for a temporary file. This file is +--- opened in update mode and it is automatically removed when the program ends. +function io.tmpfile() end + +--- +--- Checks whether `obj` is a valid file handle. Returns the string "`file`" +--- if `obj` is an open file handle, "`closed file`" if `obj` is a closed file +--- handle, or **nil** if `obj` is not a file handle. +---@param obj string|file +---@return file +function io.type(obj) end + +--- +--- Equivalent to `io.output():write(···)`. +function io.write(...) end + +--- File object +---@class file +local file = {} + +--- +--- Closes `file`. Note that files are automatically closed when their +--- handles are garbage collected, but that takes an unpredictable amount of +--- time to happen. +--- +--- When closing a file handle created with `io.popen`, `file:close` returns the +--- same values returned by `os.execute`. +function file:close() end + +--- +--- Saves any written data to `file`. +function file:flush() end + +--- +--- Returns an iterator function that, each time it is called, reads the file +--- according to the given formats. When no format is given, uses "l" as a +--- default. As an example, the construction +--- `for c in file:lines(1) do *body* end` +--- will iterate over all characters of the file, starting at the current +--- position. Unlike `io.lines`, this function does not close the file when the +--- loop ends. +--- +--- In case of errors this function raises the error, instead of returning an +--- error code. +---@return fun():any +function file:lines(...) end + +--- +--- Reads the file `file`, according to the given formats, which specify +--- what to read. For each format, the function returns a string or a number +--- with the characters read, or **nil** if it cannot read data with the +--- specified format. (In this latter case, the function does not read +--- subsequent formats.) When called without parameters, it uses a default +--- format that reads the next line (see below). +---- +--- The available formats are: +--- **"n"**: reads a numeral and returns it as a float or an integer, following +--- the lexical conventions of Lua. (The numeral may have leading spaces and a +--- sign.) This format always reads the longest input sequence that is a valid +--- prefix for a numeral; if that prefix does not form a valid numeral (e.g., an +--- empty string, "`0x`", or "`3.4e-`"), it is discarded and the format returns +--- **nil**; +--- **"a"**: reads the whole file, starting at the current position. On end of +--- file, it returns the empty string; +--- **"l"**: reads the next line skipping the end of line, returning **nil** on +--- end of file. This is the default format. +--- **"L"**: reads the next line keeping the end-of-line character (if present), +--- returning **nil** on end of file; +--- *number*: reads a string with up to this number of bytes, returning **nil** +--- on end of file. If `number` is zero, it reads nothing and returns an +--- empty string, or **nil** on end of file. +function file:read(...) end + +--- +--- Sets and gets the file position, measured from the beginning of the +--- file, to the position given by `offset` plus a base specified by the string +--- `whence`, as follows: +--- **"set"**: base is position 0 (beginning of the file); +--- **"cur"**: base is current position; +--- **"end"**: base is end of file; +--- +--- In case of success, `seek` returns the final file position, measured in +--- bytes from the beginning of the file. If `seek` fails, it returns **nil**, +--- plus a string describing the error. +--- +--- The default value for `whence` is "`cur`", and for `offset` is 0. Therefore, +--- the call `file:seek()` returns the current file position, without changing +--- it; the call `file:seek("set")` sets the position to the beginning of the +--- file (and returns 0); and the call `file:seek("end")` sets the position +--- to the end of the file, and returns its size. +---@overload fun() +---@param whence string | '"set"' | '"cur"' | '"end"' +---@param offset number +function file:seek(whence, offset) end + +--- +--- Sets the buffering mode for an output file. There are three available +--- modes: +--- **"no"**: no buffering; the result of any output operation appears +--- immediately. +--- **"full"**: full buffering; output operation is performed only when the +--- buffer is full (or when you explicitly `flush` the file (see `io.flush`)). +--- **"line"**: line buffering; output is buffered until a newline is output or +--- there is any input from some special files (such as a terminal device). +--- +--- For the last two cases, `size` specifies the size of the buffer, in +--- bytes. The default is an appropriate size. +---@overload fun(mode:string) +---@param mode string | '"no"' | '"full"' | '"line"' +---@param size number +function file:setvbuf(mode, size) end + +--- +--- Writes the value of each of its arguments to the `file`. The arguments +--- must be strings or numbers. +--- +--- In case of success, this function returns `file`. Otherwise it returns +--- **nil** plus a string describing the error. +function file:write(...) end + +--- * `io.stderr`: Standard error. +---@type file +stderr = nil + +--- * `io.stdin`: Standard in. +---@type file +stdin = nil + +--- * `io.stdout`: Standard out. +---@type file +stdout = nil diff --git a/lib/math.lua b/lib/math.lua new file mode 100644 index 0000000..f85e27d --- /dev/null +++ b/lib/math.lua @@ -0,0 +1,200 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +math = {} + +--- +--- Returns the absolute value of `x`. (integer/float) +---@param x number +---@return number +function math.abs(x) return 0 end + +--- +--- Returns the arc cosine of `x` (in radians). +---@param x number +---@return number +function math.acos(x) return 0 end + +--- +--- Returns the arc sine of `x` (in radians). +---@param x number +---@return number +function math.asin(x) return 0 end + +--- +--- Returns the arc tangent of `y/x` (in radians), but uses the signs of both +--- parameters to find the quadrant of the result. (It also handles correctly +--- the case of `x` being zero.) +--- +--- The default value for `x` is 1, so that the call `math.atan(y)`` returns the +--- arc tangent of `y`. +---@overload fun(y:number):number +---@param y number +---@param x number +---@return number +function math.atan(y, x) return 0 end + +--- +--- Returns the smallest integer larger than or equal to `x`. +---@param x number +---@return number +function math.ceil(x) return 0 end + +--- +--- Returns the cosine of `x` (assumed to be in radians). +---@param x number +---@return number +function math.cos(x) return 0 end + +--- +--- Converts the angle `x` from radians to degrees. +---@param x number +---@return number +function math.deg(x) return 0 end + +--- +--- Returns the value *e^x* (where e is the base of natural logarithms). +---@param x number +---@return number +function math.exp(x) end + +--- +--- Returns the largest integer smaller than or equal to `x`. +---@param x number +---@return number +function math.floor(x) end + +--- +--- Returns the remainder of the division of `x` by `y` that rounds the +--- quotient towards zero. (integer/float) +---@param x number +---@param y number +---@return number +function math.fmod(x, y) end + +--- +--- The float value `HUGE_VAL`, a value larger than any other numeric value. +---@type number +math.huge = nil + +--- +--- Returns the logarithm of `x` in the given base. The default for `base` is +--- *e* (so that the function returns the natural logarithm of `x`). +---@overload fun(x:number):number +---@param x number +---@param base number +---@return number +function math.log(x, base) end + +--- +--- Returns the argument with the maximum value, according to the Lua operator +--- `<`. (integer/float) +---@param x number +---@return number +function math.max(x, ...) end + +--- +--- An integer with the maximum value for an integer. +---@type number +math.maxinteger = nil + +--- +--- Returns the argument with the minimum value, according to the Lua operator +--- `<`. (integer/float) +---@param x number +---@return number +function math.min(x, ...) end + +--- +--- An integer with the minimum value for an integer. +---@type number +math.mininteger = nil + +--- +--- Returns the integral part of `x` and the fractional part of `x`. Its second +--- result is always a float. +---@param x number +---@return number +function math.modf(x) end + +--- +--- The value of π. +math.pi = 3.1415 + +--- +--- Converts the angle `x` from degrees to radians. +---@param x number +---@return number +function math.rad(x) end + +--- +--- When called without arguments, returns a pseudo-random float with uniform +--- distribution in the range *[0,1)*. When called with two integers `m` and +--- `n`, `math.random` returns a pseudo-random integer with uniform distribution +--- in the range *[m, n]*. The call `math.random(n)` is equivalent to `math +--- .random`(1,n). +---@overload fun():number +---@param m number +---@param n number +---@return number +function math.random(m, n) end + +--- +--- Sets `x` as the "seed" for the pseudo-random generator: equal seeds +--- produce equal sequences of numbers. +---@param x number +function math.randomseed(x) end + +--- +--- Returns the sine of `x` (assumed to be in radians). +---@param x number +---@return number +function math.sin(x) return 0 end + +--- +--- Returns the square root of `x`. (You can also use the expression `x^0.5` to +--- compute this value.) +---@param x number +---@return number +function math.sqrt(x) return 0 end + +--- +--- Returns the tangent of `x` (assumed to be in radians). +---@param x number +---@return number +function math.tan(x) return 0 end + +--- +--- If the value `x` is convertible to an integer, returns that integer. +--- Otherwise, returns `nil`. +---@param x number +---@return number +function math.tointeger(x) end + +--- +--- Returns "`integer`" if `x` is an integer, "`float`" if it is a float, or +--- **nil** if `x` is not a number. +---@param x number +---@return number +function math.type(x) end + +--- +--- Returns a boolean, true if and only if integer `m` is below integer `n` when +--- they are compared as unsigned integers. +---@param m number +---@param n number +---@return boolean +function math.ult(m, n) end + +return math diff --git a/lib/os.lua b/lib/os.lua new file mode 100644 index 0000000..73a8f91 --- /dev/null +++ b/lib/os.lua @@ -0,0 +1,192 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +os = {} + +--- +--- Returns an approximation of the amount in seconds of CPU time used by +--- the program. +---@return number +function os.clock() end + +--- +--- Returns a string or a table containing date and time, formatted according +--- to the given string `format`. +--- +--- If the `time` argument is present, this is the time to be formatted (see +--- the `os.time` function for a description of this value). Otherwise, +--- `date` formats the current time. +--- +--- If `format` starts with '`!`', then the date is formatted in Coordinated +--- Universal Time. After this optional character, if `format` is the string +--- "`*t`", then `date` returns a table with the following fields: +--- +--- **`year`** (four digits) +--- **`month`** (1–12) +--- **`day`** (1-31) +--- **`hour`** (0-23) +--- **`min`** (0-59) +--- **`sec`** (0-61), due to leap seconds +--- **`wday`** (weekday, 1–7, Sunday is 1) +--- **`yday`** (day of the year, 1–366) +--- **`isdst`** (daylight saving flag, a boolean). This last field may be absent +--- if the information is not available. +--- +--- If `format` is not "`*t`", then `date` returns the date as a string, +--- formatted according to the same rules as the ISO C function `strftime`. +--- +--- When called without arguments, `date` returns a reasonable date and time +--- representation that depends on the host system and on the current locale. +--- (More specifically, `os.date()` is equivalent to `os.date("%c")`.) +--- +--- On non-POSIX systems, this function may be not thread safe because of its +--- reliance on C function `gmtime` and C function `localtime`. +---@overload fun():string|table +---@param format string +---@param time number +---@return string|table +function os.date(format, time) end + +--- +--- Returns the difference, in seconds, from time `t1` to time `t2`. (where the +--- times are values returned by `os.time`). In POSIX, Windows, and some other +--- systems, this value is exactly `t2`-`t1`. +---@param t2 number +---@param t1 number +---@return number +function os.difftime(t2, t1) end + +--- +--- This function is equivalent to the C function `system`. It passes `command` +--- to be executed by an operating system shell. Its first result is **true** if +--- the command terminated successfully, or **nil** otherwise. After this first +--- result the function returns a string plus a number, as follows: +--- +--- **"exit"**: the command terminated normally; the following number is the +--- exit status of the command. +--- **"signal"**: the command was terminated by a signal; the following number +--- is the signal that terminated the command. +--- +--- When called without a command, `os.execute` returns a boolean that is true +--- if a shell is available. +---@overload fun():string|number +---@param command string +---@return string|number +function os.execute(command) end + +--- +--- Calls the ISO C function `exit` to terminate the host program. If `code` is +--- **true**, the returned status is `EXIT_SUCCESS`; if `code` is **false**, the +--- returned status is `EXIT_FAILURE`; if `code` is a number, the returned +--- status is this number. The default value for `code` is **true**. +--- +--- If the optional second argument `close` is true, closes the Lua state before +--- exiting. +---@overload fun():number +---@param code number +---@param close boolean +---@return number +function os.exit(code, close) end + +--- +--- Returns the value of the process environment variable `varname`, or +--- **nil** if the variable is not defined. +---@param varname string +---@return string +function os.getenv(varname) end + +--- +--- Deletes the file (or empty directory, on POSIX systems) with the given name. +--- If this function fails, it returns **nil**, plus a string describing the +--- error and the error code. Otherwise, it returns true. +---@param filename string +---@return nil|string +function os.remove(filename) end + +--- +--- Renames the file or directory named `oldname` to `newname`. If this function +--- fails, it returns **nil**, plus a string describing the error and the error +--- code. Otherwise, it returns true. +---@param oldname string +---@param newname string +---@return nil|string +function os.rename(oldname, newname) end + +--- +--- Sets the current locale of the program. `locale` is a system-dependent +--- string specifying a locale; `category` is an optional string describing +--- which category to change: `"all"`, `"collate"`, `"ctype"`, `"monetary"`, +--- `"numeric"`, or `"time"`; the default category is `"all"`. The function +--- returns the name of the new locale, or **nil** if the request cannot be +--- honored. +--- +--- If `locale` is the empty string, the current locale is set to an +--- implementation-defined native locale. If `locale` is the string "`C`", +--- the current locale is set to the standard C locale. +--- +--- When called with **nil** as the first argument, this function only returns +--- the name of the current locale for the given category. +--- +--- This function may be not thread safe because of its reliance on C function +--- `setlocale`. +---@overload fun(locale:string):string|nil +---@param locale string +---@param category string +---@return string|nil +function os.setlocale(locale, category) end + +--- +--- Returns the current time when called without arguments, or a time +--- representing the date and time specified by the given table. This table +--- must have fields `year`, `month`, and `day`, and may have fields `hour` +--- (default is 12), `min` (default is 0), `sec` (default is 0), and `isdst` +--- (default is **nil**). Other fields are ignored. For a description of these +--- fields, see the `os.date` function. +--- +--- When the function is called, the values in these fields do not need to be +--- inside their valid ranges. For instance, if `sec` is -10, it means 10 seconds +--- before the time specified by the other fields; if `hour` is 1000, it means +--- 1000 hours after the time specified by the other fields. +--- +--- The returned value is a number, whose meaning depends on your system. In +--- POSIX, Windows, and some other systems, this number counts the number of +--- seconds since some given start time (the "epoch"). In other systems, the +--- meaning is not specified, and the number returned by `time` can be used only +--- as an argument to `os.date` and `os.difftime`. +--- +--- When called with a table, `os.time` also normalizes all the fields +--- documented in the `os.date` function, so that they represent the same time +--- as before the call but with values inside their valid ranges. +---@overload fun():number +---@param table table +---@return number +function os.time(table) end + +--- +--- Returns a string with a file name that can be used for a temporary +--- file. The file must be explicitly opened before its use and explicitly +--- removed when no longer needed. +--- +--- On some systems (POSIX), this function also creates a file with that +--- name, to avoid security risks. (Someone else might create the file with +--- wrong permissions in the time between getting the name and creating the +--- file.) You still have to open the file to use it and to remove it (even +--- if you do not use it). +--- +--- When possible, you may prefer to use `io.tmpfile`, which automatically +--- removes the file when the program ends. +---@return string +function os.tmpname() end + +return os diff --git a/lib/package.lua b/lib/package.lua new file mode 100644 index 0000000..c34a935 --- /dev/null +++ b/lib/package.lua @@ -0,0 +1,197 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +package = {} + +--- +--- A string describing some compile-time configurations for packages. This +--- string is a sequence of lines: +--- +--- The first line is the directory separator string. Default is '\' for Windows +--- and '/' for all other systems. +--- The second line is the character that separates templates in a path. Default +--- is ';'. +--- The third line is the string that marks the substitution points in a +--- template. Default is '?'. +--- The fourth line is a string that, in a path in Windows, is replaced by the +--- executable's directory. Default is '!'. +--- The fifth line is a mark to ignore all text after it when building the +--- luaopen_ function name. Default is '-'. +package.config = "" + +--- +--- The path used by `require` to search for a C loader. +--- +--- Lua initializes the C path `package.cpath` in the same way it initializes +--- the Lua path `package.path`, using the environment variable `LUA_CPATH_5_4` +--- or the environment variable `LUA_CPATH`, or a default path defined in +--- `luaconf.h`. +package.cpath = "" + + +--- +--- A table used by `require` to control which modules are already +--- loaded. When you require a module `modname` and `package.loaded[modname]`` +--- is not false, `require` simply returns the value stored there. +--- +--- This variable is only a reference to the real table; assignments to this +--- variable do not change the table used by `require`. +package.loaded = {} + +--- +--- Dynamically links the host program with the C library `libname`. +--- +--- If `funcname` is "*", then it only links with the library, making the +--- symbols exported by the library available to other dynamically linked +--- libraries. Otherwise, it looks for a function `funcname` inside the library +--- and returns this function as a C function. So, `funcname` must follow the +--- `lua_CFunction` prototype (see `lua_CFunction`). +--- +--- This is a low-level function. It completely bypasses the package and module +--- system. Unlike `require`, it does not perform any path searching and does +--- not automatically adds extensions. `libname` must be the complete file name +--- of the C library, including if necessary a path and an extension. `funcname` +--- must be the exact name exported by the C library (which may depend on the C +--- compiler and linker used). +--- +--- This function is not supported by Standard C. As such, it is only available +--- on some platforms (Windows, Linux, Mac OS X, Solaris, BSD, plus other Unix +--- systems that support the `dlfcn` standard). +---@param libname string +---@param funcname string +---@return fun():nil +function package.loadlib(libname, funcname) end + +--- +--- The path used by `require` to search for a Lua loader. +--- +--- At start-up, Lua initializes this variable with the value of the environment +--- variable `LUA_PATH_5_4` or the environment variable `LUA_PATH` or with a +--- default path defined in `luaconf.h`, if those environment variables are not +--- defined. Any ";;" in the value of the environment variable is replaced by +--- the default path. +package.path = "" + +--- +--- A table to store loaders for specific modules (see `require`). +--- +--- This variable is only a reference to the real table; assignments to this +--- variable do not change the table used by `require`. +package.preload = {} + +--- +--- A table used by require to control how to load modules. +--- +--- Each entry in this table is a *searcher function*. When looking for a +--- module, *require* calls each of these searchers in ascending order, with the +--- module name (the argument given to `require`) as its sole parameter. The +--- function can return another function (the module *loader*) plus an extra +--- value that will be passed to that loader, or a string explaining why it did +--- not find that module (or **nil** if it has nothing to say). +--- +--- Lua initializes this table with four searcher functions. +--- +--- The first searcher simply looks for a loader in the `package.preload` table. +--- +--- The second searcher looks for a loader as a Lua library, using the path +--- stored at `package.path`. The search is done as described in function +--- `package.searchpath`. +--- +--- The third searcher looks for a loader as a C library, using the path given +--- by the variable package.cpath`. Again, the search is done as described in +--- function `package.searchpath`. For instance, if the C path is the string +--- > "`./?.so;./?.dll;/usr/local/?/init.so`" +--- the searcher for module foo will try to open the files ``./foo.so, ./foo +--- .dll`, and ``/usr/local/foo/init.so`, in that order. Once it finds a C +--- library, this searcher first uses a dynamic link facility to link the +--- application with the library. Then it tries to find a C function inside the +--- library to be used as the loader. The name of this C function is the string +--- "`luaopen_`" concatenated with a copy of the module name where each dot is +--- replaced by an underscore. Moreover, if the module name has a hyphen, its +--- suffix after (and including) the first hyphen is removed. For instance, if +--- the module name is `a.b.c-v2.1`, the function name will be `luaopen_a_b_c`. +--- +--- The fourth searcher tries an *all-in-one loader*. It searches the C path for +--- a library for the root name of the given module. For instance, when +--- requiring `a.b.c`, it will search for a C library for `a`. If found, it +--- looks into it for an open function for the submodule; in our example, that +--- would be `luaopen_a_b_c`. With this facility, a package can pack several C +--- submodules into one single library, with each submodule keeping its original +--- open function. +--- +--- All searchers except the first one (preload) return as the extra value the +--- file name where the module was found, as returned by `package.searchpath`. +--- The first searcher returns no extra value. +package.searchers = {} + +--- +--- Searches for the given name in the given path. +--- +--- A path is a string containing a sequence of *templates* separated by +--- semicolons. For each template, the function replaces each interrogation mark +--- (if any) in the template with a copy of name wherein all occurrences of +--- `sep` (a dot, by default) were replaced by `rep` (the system's directory +--- separator, by default), and then tries to open the resulting file name. +--- +--- For instance, if the path is the string +--- > "`./?.lua;./?.lc;/usr/local/?/init.lua`" +--- the search for the name `foo.a` will try to open the files `./foo/a.lua`, +--- `./foo/a.lc`, and `/usr/local/foo/a/init.lua`, in that order. +--- +--- Returns the resulting name of the first file that it can open in read mode +--- (after closing the file), or **nil** plus an error message if none succeeds. +--- (This error message lists all file names it tried to open.) +---@overload fun(name:string, path:string):string +---@param name string +---@param path string +---@param sep string +---@param rep string +---@return string +function package.searchpath(name, path, sep, rep) end + +--- +--- Loads the given module. The function starts by looking into the +--- 'package.loaded' table to determine whether `modname` is already +--- loaded. If it is, then `require` returns the value stored at +--- `package.loaded[modname]`. Otherwise, it tries to find a *loader* for +--- the module. +--- +--- To find a loader, `require` is guided by the `package.searchers` sequence. +--- By changing this sequence, we can change how `require` looks for a module. +--- The following explanation is based on the default configuration for +--- `package.searchers`. +--- +--- First `require` queries `package.preload[modname]`. If it has a value, +--- this value (which should be a function) is the loader. Otherwise `require` +--- searches for a Lua loader using the path stored in `package.path`. If +--- that also fails, it searches for a C loader using the path stored in +--- `package.cpath`. If that also fails, it tries an *all-in-one* loader (see +--- `package.loaders`). +--- +--- Once a loader is found, `require` calls the loader with a two argument: +--- `modname` and an extra value dependent on how it got the loader. (If the +--- loader came from a file, this extra value is the file name.) If the loader +--- returns any non-nil value, require assigns the returned value to +--- `package.loaded[modname]`. If the loader does not return a non-nil value and +--- has not assigned any value to `package.loaded[modname]`, then `require` +--- assigns true to this entry. In any case, require returns the final value of +--- `package.loaded[modname]`. +--- +--- If there is any error loading or running the module, or if it cannot find +--- any loader for the module, then `require` raises an error. +---@param modname string +---@return any +function require(modname) end + +return package diff --git a/lib/string.lua b/lib/string.lua new file mode 100644 index 0000000..9bbd652 --- /dev/null +++ b/lib/string.lua @@ -0,0 +1,300 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +--- +--- The type *string* represents immutable sequences of bytes. Lua is 8-bit +--- clean: strings can contain any 8-bit value, including embedded zeros +--- ('`\0`'). Lua is also encoding-agnostic; it makes no assumptions about +--- the contents of a string. +---@class string +string = {} + +--- +--- Returns the internal numerical codes of the characters `s[i]`, `s[i+1]`, +--- ..., `s[j]`. The default value for `i` is 1; the default value for `j` +--- is `i`. These indices are corrected following the same rules of function +--- `string.sub`. +--- +--- Note that numerical codes are not necessarily portable across platforms. +---@overload fun(s:string):number +---@param s string +---@param i number +---@param j number +---@return number +function string.byte(s, i, j) end + +--- +--- Receives zero or more integers. Returns a string with length equal to +--- the number of arguments, in which each character has the internal numerical +--- code equal to its corresponding argument. +--- +--- Note that numerical codes are not necessarily portable across platforms. +---@return string +function string.char(...) end + +--- +--- Returns a string containing a binary representation (*a binary chunk*) of +--- the given function, so that a later `load` on this string returns a +--- copy of the function (but with new upvalues). If strip is a true value, the +--- binary representation may not include all debug information about the +--- function, to save space. +--- +--- Functions with upvalues have only their number of upvalues saved. When (re) +--- loaded, those upvalues receive fresh instances containing **nil**. (You can +--- use the debug library to serialize and reload the upvalues of a function in +--- a way adequate to your needs.) +---@overload fun(func:fun()):string +---@param func fun() +---@param strip boolean +---@return string +function string.dump(func, strip) end + +--- +--- Looks for the first match of `pattern` in the string `s`. If it finds a +--- match, then `find` returns the indices of `s` where this occurrence starts +--- and ends; otherwise, it returns **nil**. A third, optional numerical +--- argument `init` specifies where to start the search; its default value is 1 +--- and can be negative. A value of **true** as a fourth, optional argument +--- `plain` turns off the pattern matching facilities, so the function does a +--- plain "find substring" operation, with no characters in `pattern` being +--- considered "magic". Note that if `plain` is given, then `init` must be given +--- as well. +--- +--- If the pattern has captures, then in a successful match the captured values +--- are also returned, after the two indices. +---@overload fun(s:string, pattern:string):number, number, string +---@param s string +---@param pattern string +---@param init number +---@param plain boolean +---@return number, number, string +function string.find(s, pattern, init, plain) end + +--- +--- Returns a formatted version of its variable number of arguments following +--- the description given in its first argument (which must be a string). The +--- format string follows the same rules as the ISO C function `sprintf`. The +--- only differences are that the options/modifiers `*`, `h`, `L`, `l`, `n`, and +--- `p` are not supported and that there is an extra option, `q`. +--- +--- The `q` option formats booleans, nil, numbers, and strings in a way that the +--- result is a valid constant in Lua source code. Booleans and nil are written +--- in the obvious way (`true`, `false`, `nil`). Floats are written in +--- hexadecimal, to preserve full precision. A string is written between double +--- quotes, using escape sequences when necessary to ensure that it can safely +--- be read back by the Lua interpreter. For instance, the call +--- +--- string.format('%q', 'a string with "quotes" and \n new line') may produce +--- the string: +--- +--- > "a string with \"quotes\" and \ +--- > new line" +--- +--- The options `A`, `a`, `E`, `e`, `f`, `g`, `G` and `g` all expect a number as +--- argument. Options `c`, `d`, `i`, `o`, `u`, `X`, and `x` expect an integer. +--- When Lua is compiled with a C89 compiler, options `A` and `a` (hexadecimal +--- floats) do not support any modifier (flags, width, length). +--- +--- Option `s` expects a string; if its argument is not a string, it is +--- converted to one following the same rules of `tostring`. If the option +--- has any modifier (flags, width, length), the string argument should not +--- contain embedded zeros. +---@param formatstring string +---@return string +function string.format(formatstring, ...) end + +--- +--- Returns an iterator function that, each time it is called, returns the +--- next captures from `pattern` over the string `s`. If `pattern` specifies no +--- captures, then the whole match is produced in each call. +--- +--- As an example, the following loop will iterate over all the words from +--- string `s`, printing one per line: +--- +--- `s = "hello world from Lua"` +--- `for w in string.gmatch(s, "%a+") do` +--- > `print(w)` +--- `end` +--- +--- The next example collects all pairs `key=value` from the given string into a +--- table: +--- +--- `t = {}` +--- s = "from=world, to=Lua"` +--- `for k, v in string.gmatch(s, "(%w+)=(%w+)") do` +--- > `t[k] = v` +--- `end` +--- +--- For this function, a caret '`^`' at the start of a pattern does not work as +--- an anchor, as this would prevent the iteration. +---@param s string +---@param pattern string +---@return fun():string, table +function string.gmatch(s, pattern) end + +--- +--- Returns a copy of `s` in which all (or the first `n`, if given) +--- occurrences of the `pattern` have been replaced by a replacement string +--- specified by `repl`, which can be a string, a table, or a function. `gsub` +--- also returns, as its second value, the total number of matches that +--- occurred. +--- +--- If `repl` is a string, then its value is used for replacement. The character +--- `%` works as an escape character: any sequence in `repl` of the form `%n`, +--- with *n* between 1 and 9, stands for the value of the *n*-th captured +--- substring (see below). The sequence `%0` stands for the whole match. The +--- sequence `%%` stands for a single `%`. +--- +--- If `repl` is a table, then the table is queried for every match, using +--- the first capture as the key; if the pattern specifies no captures, then +--- the whole match is used as the key. +--- +--- If `repl` is a function, then this function is called every time a match +--- occurs, with all captured substrings passed as arguments, in order; if +--- the pattern specifies no captures, then the whole match is passed as a +--- sole argument. +--- +--- If the value returned by the table query or by the function call is a +--- string or a number, then it is used as the replacement string; otherwise, +--- if it is false or nil, then there is no replacement (that is, the original +--- match is kept in the string). +--- +--- Here are some examples: +--- `x = string.gsub("hello world", "(%w+)", "%1 %1")` +--- `-- > x="hello hello world world"` +--- `x = string.gsub("hello world", "%w+", "%0 %0", 1)` +--- `-- > x="hello hello world"` +--- `x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")` +--- `-- > x="world hello Lua from"` +--- `x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)` +--- `-- > x="home = /home/roberto, user = roberto"` +--- `x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)` +--- >> return loadstring(s)() +--- > end) +--- `-- > x="4+5 = 9"` +--- `local t = {name="lua", version="5.4"}` +--- `x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)` +--- > x="lua-5.4.tar.gz" +---@overload fun(s:string, pattern:string, repl:string|fun()):string, number +---@param s string +---@param pattern string +---@param repl string|fun() +---@param n number +---@return string, number +function string.gsub(s, pattern, repl, n) end + +--- +--- Receives a string and returns its length. The empty string `""` has +--- length 0. Embedded zeros are counted, so `"a\000bc\000"` has length 5. +---@param s string +---@return number +function string.len(s) end + +--- +--- Receives a string and returns a copy of this string with all uppercase +--- letters changed to lowercase. All other characters are left unchanged. The +--- definition of what an uppercase letter is depends on the current locale. +---@param s string +---@return string +function string.lower(s) end + +--- +--- Looks for the first *match* of `pattern` in the string `s`. If it +--- finds one, then `match` returns the captures from the pattern; otherwise +--- it returns **nil**. If `pattern` specifies no captures, then the whole match +--- is returned. A third, optional numerical argument `init` specifies where +--- to start the search; its default value is 1 and can be negative. +---@overload fun(s:string, pattern:string):any +---@param s string +---@param pattern string +---@param init number +---@return any +function string.match(s, pattern, init) end + +--- +--- Returns a binary string containing the values `v1`, `v2`, etc. packed (that +--- is, serialized in binary form) according to the format string `fmt`. +---@param fmt string +---@param v1 string +---@param v2 string +---@return string +function string.pack(fmt, v1, v2, ...) end + +--- +--- Returns the size of a string resulting from `string.pack` with the given +--- format. The format string cannot have the variable-length options '`s`' or +--- '`z`' +---@param fmt string +---@return number +function string.packsize(fmt) end + +--- +--- Returns a string that is the concatenation of `n` copies of the string +--- `s` separated by the string `sep`. The default value for `sep` is the empty +--- string (that is, no separator). Returns the empty string if n is not +--- positive. +--- +--- Note that it is very easy to exhaust the memory of your machine with a +--- single call to this function. +---@overload fun(s:string, n:number):string +---@param s string +---@param n number +---@param sep string +---@return string +function string.rep(s, n, sep) end + +--- +--- Returns a string that is the string `s` reversed. +---@param s string +---@return string +function string.reverse(s) end + +--- +--- Returns the substring of `s` that starts at `i` and continues until +--- `j`; `i` and `j` can be negative. If `j` is absent, then it is assumed to +--- be equal to -1 (which is the same as the string length). In particular, +--- the call `string.sub(s,1,j)` returns a prefix of `s` with length `j`, and +--- `string.sub(s, -i)` (for a positive i) returns a suffix of `s` with length +--- `i`. +--- +--- If, after the translation of negative indices, `i` is less than 1, it is +--- corrected to 1. If `j` is greater than the string length, it is corrected to +--- that length. If, after these corrections, `i` is greater than `j`, the +--- function returns the empty string. +---@overload fun(s:string, i:number):string +---@param s string +---@param i number +---@param j number +---@return string +function string.sub(s, i, j) end + +--- +--- Returns the values packed in string `s` according to the format string +--- `fmt`. An optional `pos` marks where to start reading in `s` (default is 1). +--- After the read values, this function also returns the index of the first +--- unread byte in `s`. +---@overload fun(fmt:string, s:string):string +---@param fmt string +---@param s string +---@param pos number +---@return string +function string.unpack(fmt, s, pos) end + +--- +--- Receives a string and returns a copy of this string with all lowercase +--- letters changed to uppercase. All other characters are left unchanged. The +--- definition of what a lowercase letter is depends on the current locale. +---@param s string +---@return string +function string.upper(s) end diff --git a/lib/table.lua b/lib/table.lua new file mode 100644 index 0000000..9eb02a7 --- /dev/null +++ b/lib/table.lua @@ -0,0 +1,116 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +table = {} + +--- +--- Given a list where all elements are strings or numbers, returns the string +--- `list[i]..sep..list[i+1] ... sep..list[j]`. The default value for +--- `sep` is the empty string, the default for `i` is 1, and the default for +--- `j` is #list. If `i` is greater than `j`, returns the empty string. +---@overload fun(list:table):string +---@overload fun(list:table, sep:string):string +---@overload fun(list:table, sep:string, i:number):string +---@param list table +---@param sep string +---@param i number +---@param j number +---@return string +function table.concat(list, sep, i, j) end + +--- +--- Inserts element `value` at position `pos` in `list`, shifting up the +--- elements to `list[pos]`, `list[pos+1]`, `···`, `list[#list]`. The default +--- value for `pos` is ``#list+1`, so that a call `table.insert(t,x)`` inserts +--- `x` at the end of list `t`. +---@overload fun(list:table, value:any):number +---@param list table +---@param pos number +---@param value any +---@return number +function table.insert(list, pos, value) end + +--- +--- Moves elements from table a1 to table `a2`, performing the equivalent to +--- the following multiple assignment: `a2[t]`,`··· = a1[f]`,`···,a1[e]`. The +--- default for `a2` is `a1`. The destination range can overlap with the source +--- range. The number of elements to be moved must fit in a Lua integer. +--- +--- Returns the destination table `a2`. +---@overload fun(a1:table, f:number, e:number, t:number):table +---@param a1 table +---@param f number +---@param e number +---@param t number +---@param a2 table +---@return table +function table.move(a1, f, e, t, a2) end + +--- +--- Returns a new table with all arguments stored into keys 1, 2, etc. and +--- with a field "`n`" with the total number of arguments. Note that the +--- resulting table may not be a sequence, if some arguments are **nil**. +---@return table +function table.pack(...) end + +--- +--- Removes from `list` the element at position `pos`, returning the value of +--- the removed element. When `pos` is an integer between 1 and `#list`, it +--- shifts down the elements `list[pos+1]`, `list[pos+2]`, `···`, +--- `list[#list]` and erases element `list[#list]`; The index pos can also be 0 +--- when `#list` is 0, or `#list` + 1; in those cases, the function erases +--- the element `list[pos]`. +--- +--- The default value for `pos` is `#list`, so that a call `table.remove(l)` +--- removes the last element of list `l`. +---@overload fun(list:table | V[]):V +---@generic V +---@param list table +---@param pos number +---@return V +function table.remove(list, pos) end + +--- +--- Sorts list elements in a given order, *in-place*, from `list[1]` to +--- `list[#list]`. If `comp` is given, then it must be a function that receives +--- two list elements and returns true when the first element must come before +--- the second in the final order (so that, after the sort, `i < j` implies not +--- `comp(list[j],list[i]))`. If `comp` is not given, then the standard Lua +--- operator `<` is used instead. +--- +--- Note that the `comp` function must define a strict partial order over the +--- elements in the list; that is, it must be asymmetric and transitive. +--- Otherwise, no valid sort may be possible. +--- +--- The sort algorithm is not stable: elements considered equal by the given +--- order may have their relative positions changed by the sort. +---@overload fun(list:table):number +---@generic V +---@param list table | V[] +---@param comp fun(a:V, b:V):boolean +---@return number +function table.sort(list, comp) end + +--- +--- Returns the elements from the given list. This function is equivalent to +--- return `list[i]`, `list[i+1]`, `···`, `list[j]` +--- By default, i is 1 and j is #list. +---@overload fun(list:table):any +---@param list table +---@param i number +---@param j number +---@return any +function table.unpack(list, i, j) end + +return table diff --git a/lib/utf8.lua b/lib/utf8.lua new file mode 100644 index 0000000..83e3530 --- /dev/null +++ b/lib/utf8.lua @@ -0,0 +1,82 @@ +-- Copyright (c) 2018. tangzx(love.tangzx@qq.com) +-- +-- Licensed under the Apache License, Version 2.0 (the "License"); you may not +-- use this file except in compliance with the License. You may obtain a copy of +-- the License at +-- +-- http://www.apache.org/licenses/LICENSE-2.0 +-- +-- Unless required by applicable law or agreed to in writing, software +-- distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +-- WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +-- License for the specific language governing permissions and limitations under +-- the License. + +utf8 = {} + +--- +--- Receives zero or more integers, converts each one to its corresponding +--- UTF-8 byte sequence and returns a string with the concatenation of all +--- these sequences. +---@return string +function utf8.char(...) end + +--- +--- The pattern (a string, not a function) "`[\0-\x7F\xC2-\xF4][\x80-\xBF]*`", +--- which matches exactly one UTF-8 byte sequence, assuming that the subject +--- is a valid UTF-8 string. +---@type string +utf8.charpattern = "" + +--- +--- Returns values so that the construction +--- > `for p, c in utf8.codes(s) do` *body* `end` +--- will iterate over all characters in string `s`, with `p` being the position +--- (in bytes) and `c` the code point of each character. It raises an error if +--- it meets any invalid byte sequence. +---@param s string +---@return string +function utf8.codes(s) end + +--- +--- Returns the codepoints (as integers) from all characters in `s` that start +--- between byte position `i` and `j` (both included). The default for `i` is +--- 1 and for `j` is `i`. It raises an error if it meets any invalid byte +--- sequence. +---@overload fun(s:string):number +---@param s string +---@param i number +---@param j number +---@return number +function utf8.codepoint (s, i, j) end + +--- +--- Returns the number of UTF-8 characters in string `s` that start between +--- positions `i` and `j` (both inclusive). The default for `i` is 1 and for +--- `j` is -1. If it finds any invalid byte sequence, returns a false value +--- plus the position of the first invalid byte. +---@overload fun(s:string):number +---@param s string +---@param i number +---@param j number +---@return number +function utf8.len(s, i, j) end + +--- +--- Returns the position (in bytes) where the encoding of the `n`-th character +--- of `s` (counting from position `i`) starts. A negative `n` gets +--- characters before position `i`. The default for `i` is 1 when `n` is +--- non-negative and `#s + 1` otherwise, so that `utf8.offset(s, -n)` gets the +--- offset of the `n`-th character from the end of the string. If the +--- specified character is neither in the subject nor right after its end, +--- the function returns nil. As a special case, when `n` is 0 the function +--- returns the start of the encoding of the character that contains the `i`-th +--- byte of `s`. +--- +--- This function assumes that `s` is a valid UTF-8 string. +---@overload fun(s:string):number +---@param s string +---@param n number +---@param i number +---@return number +function utf8.offset (s, n, i) end diff --git a/vm.go b/vm.go index a840c48..bf74ce0 100644 --- a/vm.go +++ b/vm.go @@ -9,10 +9,12 @@ package lua import ( "fmt" - _ "github.com/vadv/gopher-lua-libs" + libs "github.com/vadv/gopher-lua-libs" luaCompile "github.com/yuin/gopher-lua" "github.com/yuin/gopher-lua/ast" "github.com/yuin/gopher-lua/parse" + "os" + "path/filepath" "strings" "sync" ) @@ -22,7 +24,19 @@ var ( ) // InitVM 初始化lua虚拟机 -func InitVM(poolSize int, preComplierScript map[string]string) error { +func InitVM(poolSize int, libPath []string, preComplierScript map[string]string) error { + if len(libPath) == 0 { + libPath = []string{"./lib"} // 默认使用内置的lib + } + pathStr := "" + for _, path := range libPath { + // 绝对路径 + libDir, _ := filepath.Abs(path) + libDir = filepath.Join(libDir, "?.lua") + pathStr += ";" + libDir + } + pathStr += ";;" + os.Setenv("LUA_PATH", pathStr) if poolSize <= 0 { poolSize = 32 } @@ -82,6 +96,8 @@ func (v *VM) GetVm() *luaCompile.LState { return luaCompile.NewState() } l := v.pool[len(v.pool)-1] + // 基于libs预导入lua的常用模块 + libs.Preload(l) v.pool = v.pool[:len(v.pool)-1] return l } diff --git a/vm_test.go b/vm_test.go index b34216d..333942b 100644 --- a/vm_test.go +++ b/vm_test.go @@ -8,10 +8,26 @@ package lua import ( + "fmt" "testing" ) func TestNewVm(t *testing.T) { - v := NewVm() - v.Run(`print("hello world"); return "hahaha", "heiheihei"`) + scriptTable := map[string]string{ + "json": `local json = require("dkjson") +local lua_table = { +name = "wx771720", +age = 18, +married = true, +skills = {"typescript", "unity", "lua"} +} +local json_str = json.encode(lua_table) +print(json_str) -- 输出JSON字符串`, + } + if err := InitVM(1024, nil, scriptTable); err != nil { + panic(err.Error()) + } + + _, err := VMInstance.RunPreCompileScript("json") + fmt.Println(err) }