hslua 0.9.5.2 → 1.0.0

raw patch · 172 files changed

+28634/−27970 lines, 172 filesdep +criteriondep +deepseqdep −tasty-expected-failuredep ~basedep ~bytestringdep ~containersPVP ok

version bump matches the API change (PVP)

Dependencies added: criterion, deepseq

Dependencies removed: tasty-expected-failure

Dependency ranges changed: base, bytestring, containers, quickcheck-instances, tasty, tasty-hunit, tasty-quickcheck, text

API changes (from Hackage documentation)

Files

• CHANGELOG.md +116/−2
• COPYRIGHT +0/−22
• LICENSE +23/−0
• README.md +39/−52
• benchmark/benchmark-functions.c +40/−0
• benchmark/benchmark-hslua.hsc +103/−0
• cbits/error-conversion/error-conversion.c +250/−0
• cbits/error-conversion/error-conversion.h +24/−0
• cbits/lua-5.3.5/lapi.c +1299/−0
• cbits/lua-5.3.5/lapi.h +24/−0
• cbits/lua-5.3.5/lauxlib.c +1043/−0
• cbits/lua-5.3.5/lauxlib.h +264/−0
• cbits/lua-5.3.5/lbaselib.c +498/−0
• cbits/lua-5.3.5/lbitlib.c +233/−0
• cbits/lua-5.3.5/lcode.c +1203/−0
• cbits/lua-5.3.5/lcode.h +88/−0
• cbits/lua-5.3.5/lcorolib.c +168/−0
• cbits/lua-5.3.5/lctype.c +55/−0
• cbits/lua-5.3.5/lctype.h +95/−0
• cbits/lua-5.3.5/ldblib.c +456/−0
• cbits/lua-5.3.5/ldebug.c +699/−0
• cbits/lua-5.3.5/ldebug.h +39/−0
• cbits/lua-5.3.5/ldo.c +802/−0
• cbits/lua-5.3.5/ldo.h +58/−0
• cbits/lua-5.3.5/ldump.c +215/−0
• cbits/lua-5.3.5/lfunc.c +151/−0
• cbits/lua-5.3.5/lfunc.h +61/−0
• cbits/lua-5.3.5/lgc.c +1179/−0
• cbits/lua-5.3.5/lgc.h +147/−0
• cbits/lua-5.3.5/linit.c +68/−0
• cbits/lua-5.3.5/liolib.c +776/−0
• cbits/lua-5.3.5/llex.c +565/−0
• cbits/lua-5.3.5/llex.h +85/−0
• cbits/lua-5.3.5/llimits.h +323/−0
• cbits/lua-5.3.5/lmathlib.c +410/−0
• cbits/lua-5.3.5/lmem.c +100/−0
• cbits/lua-5.3.5/lmem.h +69/−0
• cbits/lua-5.3.5/loadlib.c +790/−0
• cbits/lua-5.3.5/lobject.c +522/−0
• cbits/lua-5.3.5/lobject.h +549/−0
• cbits/lua-5.3.5/lopcodes.c +124/−0
• cbits/lua-5.3.5/lopcodes.h +297/−0
• cbits/lua-5.3.5/loslib.c +409/−0
• cbits/lua-5.3.5/lparser.c +1650/−0
• cbits/lua-5.3.5/lparser.h +133/−0
• cbits/lua-5.3.5/lprefix.h +45/−0
• cbits/lua-5.3.5/lstate.c +347/−0
• cbits/lua-5.3.5/lstate.h +253/−0
• cbits/lua-5.3.5/lstring.c +248/−0
• cbits/lua-5.3.5/lstring.h +49/−0
• cbits/lua-5.3.5/lstrlib.c +1584/−0
• cbits/lua-5.3.5/ltable.c +688/−0
• cbits/lua-5.3.5/ltable.h +66/−0
• cbits/lua-5.3.5/ltablib.c +450/−0
• cbits/lua-5.3.5/ltm.c +165/−0
• cbits/lua-5.3.5/ltm.h +76/−0
• cbits/lua-5.3.5/lua.h +486/−0
• cbits/lua-5.3.5/luaconf.h +790/−0
• cbits/lua-5.3.5/lualib.h +61/−0
• cbits/lua-5.3.5/lundump.c +279/−0
• cbits/lua-5.3.5/lundump.h +32/−0
• cbits/lua-5.3.5/lutf8lib.c +256/−0
• cbits/lua-5.3.5/lvm.c +1322/−0
• cbits/lua-5.3.5/lvm.h +113/−0
• cbits/lua-5.3.5/lzio.c +68/−0
• cbits/lua-5.3.5/lzio.h +66/−0
• hslua.cabal +188/−186
• lua-5.3.4/lapi.c +0/−1298
• lua-5.3.4/lapi.h +0/−24
• lua-5.3.4/lauxlib.c +0/−1043
• lua-5.3.4/lauxlib.h +0/−264
• lua-5.3.4/lbaselib.c +0/−498
• lua-5.3.4/lbitlib.c +0/−233
• lua-5.3.4/lcode.c +0/−1203
• lua-5.3.4/lcode.h +0/−88
• lua-5.3.4/lcorolib.c +0/−168
• lua-5.3.4/lctype.c +0/−55
• lua-5.3.4/lctype.h +0/−95
• lua-5.3.4/ldblib.c +0/−456
• lua-5.3.4/ldebug.c +0/−698
• lua-5.3.4/ldebug.h +0/−39
• lua-5.3.4/ldo.c +0/−802
• lua-5.3.4/ldo.h +0/−58
• lua-5.3.4/ldump.c +0/−215
• lua-5.3.4/lfunc.c +0/−151
• lua-5.3.4/lfunc.h +0/−61
• lua-5.3.4/lgc.c +0/−1178
• lua-5.3.4/lgc.h +0/−147
• lua-5.3.4/linit.c +0/−68
• lua-5.3.4/liolib.c +0/−771
• lua-5.3.4/llex.c +0/−565
• lua-5.3.4/llex.h +0/−85
• lua-5.3.4/llimits.h +0/−323
• lua-5.3.4/lmathlib.c +0/−410
• lua-5.3.4/lmem.c +0/−100
• lua-5.3.4/lmem.h +0/−69
• lua-5.3.4/loadlib.c +0/−790
• lua-5.3.4/lobject.c +0/−521
• lua-5.3.4/lobject.h +0/−549
• lua-5.3.4/lopcodes.c +0/−124
• lua-5.3.4/lopcodes.h +0/−297
• lua-5.3.4/loslib.c +0/−407
• lua-5.3.4/lparser.c +0/−1650
• lua-5.3.4/lparser.h +0/−133
• lua-5.3.4/lprefix.h +0/−45
• lua-5.3.4/lstate.c +0/−347
• lua-5.3.4/lstate.h +0/−235
• lua-5.3.4/lstring.c +0/−248
• lua-5.3.4/lstring.h +0/−49
• lua-5.3.4/lstrlib.c +0/−1584
• lua-5.3.4/ltable.c +0/−669
• lua-5.3.4/ltable.h +0/−66
• lua-5.3.4/ltablib.c +0/−450
• lua-5.3.4/ltm.c +0/−165
• lua-5.3.4/ltm.h +0/−76
• lua-5.3.4/lua.h +0/−486
• lua-5.3.4/luaconf.h +0/−783
• lua-5.3.4/lualib.h +0/−61
• lua-5.3.4/lundump.c +0/−279
• lua-5.3.4/lundump.h +0/−32
• lua-5.3.4/lutf8lib.c +0/−256
• lua-5.3.4/lvm.c +0/−1322
• lua-5.3.4/lvm.h +0/−113
• lua-5.3.4/lzio.c +0/−68
• lua-5.3.4/lzio.h +0/−66
• prelude/Prelude.hs +0/−22
• safer-api/safer-api.c +0/−212
• safer-api/safer-api.h +0/−23
• src/Foreign/Lua.hs +22/−107
• src/Foreign/Lua/Api.hs +0/−1257
• src/Foreign/Lua/Api/Constants.hsc +0/−82
• src/Foreign/Lua/Api/RawBindings.hsc +0/−652
• src/Foreign/Lua/Api/Types.hsc +0/−287
• src/Foreign/Lua/Core.hs +181/−0
• src/Foreign/Lua/Core/Auxiliary.hsc +256/−0
• src/Foreign/Lua/Core/Constants.hsc +41/−0
• src/Foreign/Lua/Core/Error.hs +138/−0
• src/Foreign/Lua/Core/Functions.hs +942/−0
• src/Foreign/Lua/Core/RawBindings.hsc +381/−0
• src/Foreign/Lua/Core/Types.hsc +373/−0
• src/Foreign/Lua/FunctionCalling.hs +0/−202
• src/Foreign/Lua/FunctionCalling.hsc +168/−0
• src/Foreign/Lua/Types.hs +6/−32
• src/Foreign/Lua/Types/Error.hs +0/−77
• src/Foreign/Lua/Types/FromLuaStack.hs +0/−276
• src/Foreign/Lua/Types/Lua.hs +0/−74
• src/Foreign/Lua/Types/Peekable.hs +258/−0
• src/Foreign/Lua/Types/Pushable.hs +212/−0
• src/Foreign/Lua/Types/ToLuaStack.hs +0/−200
• src/Foreign/Lua/Userdata.hs +140/−0
• src/Foreign/Lua/Utf8.hs +44/−0
• src/Foreign/Lua/Util.hs +63/−61
• test/Foreign/Lua/ApiTest.hs +0/−306
• test/Foreign/Lua/Core/AuxiliaryTests.hs +16/−0
• test/Foreign/Lua/Core/ErrorTests.hs +25/−0
• test/Foreign/Lua/CoreTests.hs +473/−0
• test/Foreign/Lua/FunctionCallingTest.hs +0/−121
• test/Foreign/Lua/FunctionCallingTests.hs +123/−0
• test/Foreign/Lua/Types/FromLuaStackTest.hs +0/−78
• test/Foreign/Lua/Types/PeekableTests.hs +139/−0
• test/Foreign/Lua/Types/PushableTests.hs +115/−0
• test/Foreign/Lua/Types/ToLuaStackTest.hs +0/−113
• test/Foreign/Lua/TypesTest.hs +0/−159
• test/Foreign/Lua/TypesTests.hs +171/−0
• test/Foreign/Lua/UserdataTests.hs +103/−0
• test/Foreign/Lua/UtilTest.hs +0/−54
• test/Foreign/Lua/UtilTests.hs +107/−0
• test/Foreign/LuaTest.hs +0/−247
• test/Foreign/LuaTests.hs +185/−0
• test/Test/HsLua/Arbitrary.hs +6/−6
• test/Test/HsLua/Util.hs +55/−9
• test/test-hslua.hs +17/−15

@@ -1,8 +1,122 @@ ## Changelog +### 1.0.0++#### New features++- Error handling at language borders has been vastly improved and is now+  mostly automatic. Haskell's `Foreign.Lua.Exception`s are transformed+  into Lua errors and *vice versa*. Lua-side wrappers are no longer+  necessary.++- Haskell functions are no longer pushed as userdata by+  `pushHaskellFunction`, but as C functions. This simplifies tasks where+  Lua expects true function objects object (for example when looking for+  module loaders).++- Added stack instance for++  + Data.Set.Set,+  + Integer,+  + Int,+  + Float, and+  + Double.++  Instances for numbers fall back to strings when the+  representation as a Lua number would cause a loss of precision.++- Haskell functions pushed with `pushHaskellFunction` can now be+  garbage collected by Lua without having to call back into+  Haskell. The callback into Haskell by the GC had previously+  caused programs to hang in some situations.++- Bindings to more Lua C API functions and macros: `isinteger`, `load`,+  `loadbuffer`, and `pushglobaltable`.++- Any Haskell value can be pushed to the Lua stack as userdata via+  `pushAny` and retrieved via `peekAny`. Additional functions are+  provided to setup the userdata metatable.++- The C preprocessor constants `LUA_LOADED_TABLE` and+  `LUA_PRELOAD_TABLE` are made available as+  `loadedTableRegistryField` and `preloadTableRegistryField`,+  respectively.++- Additional small helper functions:++  + `peekRead` -- read value from a string.+  + `popValue` -- peek value at the top of the Lua stack, then+    remove it from the stack regardless of whether peeking was+    successful or not.++#### Naming++- The *Lua* prefix was removed from types (`State`, `Integer`, `Number`,+  `Exception`) and the respective infix from functions (`try`, `run`,+  `runWith`, `runEither`). HsLua should be imported qualified to avoid+  name collisions.++- Terminology now consistently uses *exception* to refer to Haskell+  exceptions, and *error* for Lua errors; function names changed+  accordingly (`throwException`, `catchException`,+  `withExceptionMessage`).++- Module *Foreign.Lua.Api* was renamed to *Foreign.Lua.Core*.++- *Foreign.Lua.lerror* was renamed to *Foreign.Lua.error*.++- Typeclass *ToLuaStack* was renamed to *Pushable*.++- Typeclass *FromLuaStack* was renamed to *Peekable*.++- Cabal flag *use-pkgconfig* was renamed to *pkg-config* (which is the+   flag name used by other projects such a zlib).+++#### Type signatures++- The return value of `lua_newuserdata` is *CSize* (was *CInt*).++- Table index parameter in `rawgeti` and `rawseti` must be of type+  *LuaInteger*, but were of type *Int*.++- The number of upvalues passed to `pushcclosure` must be of type+  *NumArgs*.++- `Lua.error` has type *Lua NumResults*, simplifying its use in+    HaskellFunctions.++- Retrieval functions which can fail, i.e. `tocfunction`, `tointeger`,+  `tonumber`, `tostring`, `tothread`, and `touserdata`, use the *Maybe*+  type to indicate success or failure, avoiding the need to perform+  additional checks.++#### Removed Features++- Support for Lua versions before 5.3 has been dropped.++- Support for GHC 7.8 has been dropped.++- `wrapHaskellFunction` has been made internal and is no longer+   exported.++#### Changed behavior++- Peekable instances for numbers and strings became more forgiving.+  Peeking of basic types now follows Lua's default conversion rules:++  + numbers can be given as strings, and *vice versa*;+  + any value can be converted into a boolean -- only `nil` and `false`+    are peeked as `False`, all other as `True`.++#### Other++- Many internal improvements and additions such as a benchmarking suite,+  code cleanups, better tests, etc.+ ### 0.9.5.{1,2} -- Relax upper bound on exceptions+- Relaxed upper bound on *exceptions*.  ### 0.9.5 @@ -125,7 +239,7 @@ - The signature of `concat` was changed from `Int -> Lua ()` to   `NumArgs -> Lua ()`. - The signature of `loadfile` was changed from `String -> Lua Int` to-  `String -> Lua Status`. +  `String -> Lua Status`. - The type `LTYPE` was renamed to `Type`, its constructors were renamed to   follow the pattern `Type<Typename>`. `LuaRelation` was renamed to   `RelationalOperator`, the *Lua* prefix was removed from its constructors.

@@ -1,22 +0,0 @@-Copyright (C) 1994-2017 Lua.org, PUC-Rio.-Copyright (C) 2007-2012 Gracjan Polak-Copyright (C) 2012-2015 Ömer Sinan Ağacan-Copyright (C) 2016-2017 Albert Krewinkel--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.

@@ -0,0 +1,23 @@+Copyright (C) 1994-2018 Lua.org, PUC-Rio.+Copyright (C) 2007-2012 Gracjan Polak+Copyright (C) 2012-2015 Ömer Sinan Ağacan+Copyright (C) 2016-2018 Albert Krewinkel++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.

@@ -1,15 +1,15 @@-# hslua – Lua interpreter interface for Haskell+# HsLua – Bindings to Lua, an embeddable scripting language  [![Build Status]](https://travis-ci.org/hslua/hslua) [![AppVeyor Status]](https://ci.appveyor.com/project/tarleb/hslua-r2y18) [![Hackage]](https://hackage.haskell.org/package/hslua) -Hslua provides bindings, wrappers, types, and helper functions to bridge haskell-and lua.+HsLua provides bindings, wrappers, types, and helper functions to bridge+Haskell and Lua.  [Build Status]: https://travis-ci.org/hslua/hslua.svg?branch=master [AppVeyor Status]: https://ci.appveyor.com/api/projects/status/ldutrilgxhpcau94/branch/master?svg=true-[Hackage]: http://img.shields.io/hackage/v/hslua.svg+[Hackage]: https://img.shields.io/hackage/v/hslua.svg   Overview@@ -21,29 +21,28 @@ software and embedded devices. This package provides Haskell bindings to Lua, enable coders to embed the language into their programs, making them scriptable. -HsLua ships with batteries included and includes the most recent Lua version.-However, cabal flags make it easy to swap this out in favor of a Lua version-already installed on the host system. It supports the versions 5.1, 5.2, 5.3,-and LuaJIT.+HsLua ships with batteries included and includes the most recent Lua version+(i.e., Lua 5.3.5). Cabal flags make it easy to compile against a system-wide Lua+installation.   Interacting with Lua --------------------  HsLua provides the `Lua` type to define Lua operations. The operations are-executed by calling `runLua`. A simple "Hello, World" program, using the Lua+executed by calling `run`. A simple "Hello, World" program, using the Lua `print` function, is given below:  ``` haskell-import Foreign.Lua+import Foreign.Lua as Lua  main :: IO ()-main = runLua prog+main = Lua.run prog   where     prog :: Lua ()     prog = do-      openlibs  -- load lua libraries so we can use 'print'-      callFunc "print" "Hello, World!"+      Lua.openlibs  -- load Lua libraries so we can use 'print'+      Lua.callFunc "print" "Hello, World!" ```  ### The Lua stack@@ -84,7 +83,7 @@  ``` haskell -- | A value that can be read from the Lua stack.-class FromLuaStack a where+class Peekable a where   -- | Check if at index @n@ there is a convertible Lua value and   --   if so return it.  Throws a @'LuaException'@ otherwise.   peek :: StackIndex -> Lua a@@ -94,7 +93,7 @@  ``` haskell -- | A value that can be pushed to the Lua stack.-class ToLuaStack a where+class Pushable a where   -- | Pushes a value onto Lua stack, casting it into meaningfully   --   nearest Lua type.   push :: a -> Lua ()@@ -102,7 +101,7 @@  Many basic data types (except for numeric types, see the FAQ) have instances for these type classes. New instances can be defined for custom types using the-functions in `Foreign.Lua.Api` (also exported in `Foreign.Lua`).+functions in `Foreign.Lua.Core` (also exported in `Foreign.Lua`).   Build flags@@ -113,14 +112,8 @@ - `system-lua`: Use the locally installed Lua version instead of the version   shipped as part of HsLua. -- `use-pkgconfig`: Use `pkg-config` to discover library and include paths. This-  is used only when the `system-lua` flag is set or implied.--- `lua501`: Build against Lua 5.1; this implies the flag `system-lua` as well.--- `lua502`: Build against Lua 5.2; this implies the flag `system-lua` as well.--- `luajit`: Build against LuaJIT; this implies the flag `system-lua` as well.+- `pkg-config`: Use *pkg-config* to discover library and include paths. Setting+  this flag implies `system-lua`.  - `allow-unsafe-gc`: Allow optimizations which make Lua's garbage collection   potentially unsafe; haskell finalizers must be handled with extreme care. This@@ -130,48 +123,42 @@  - `lua_32bits`: Compile Lua for a 32-bits system (e.g., i386, PowerPC G4). +- `export-dynamic`: Add all symbols to dynamic symbol table; disabling this+  will make it possible to create fully static binaries, but renders loading+  of dynamic C libraries impossible. + ### Example: using a different lua version -To use a system-wide installed Lua/LuaJIT when linking hslua as a dependency,-build/install your package using `--constraint="hslua +system-lua"` or for-LuaJIT: `--constraint="hslua +luajit"`. For example, you can install Pandoc with-hslua that uses system-wide LuaJIT like this:+To use a system-wide installed Lua when linking hslua as a dependency,+build/install your package using `--constraint="hslua +system-lua"`. For+example, you can install Pandoc with hslua that uses system-wide Lua like+this:  ``` sh-cabal install pandoc --constraint="hslua +system-lua +luajit"+cabal install pandoc --constraint="hslua +system-lua" ```  or with stack:  ``` sh-stack install pandoc --flag=hslua:luajit+stack install pandoc --flag=hslua:system-lua ```  -FAQ+Q&A --- -**Is anybody using this?** Absolutely. E.g., [Pandoc](https://pandoc.org), the-universal document converter, is written in Haskell and includes a Lua-interpreter, enabling programmatic modifications of documents via Lua.-Furthermore, custom output formats can be defined via Lua scripts. This has been-used in [pandoc-scholar](https://github.com/pandoc-scholar/pandoc-scholar)-([paper](https://peerj.com/articles/cs-112/)) to allow for semantically enriched-scholarly articles.+- **Can I see some examples?** Basic examples are available in the+    [*hslua-examples*](https://github.com/hslua/hslua-examples) repository. -**Where are the coroutine related functions?** Yielding from a coroutine works-via `longjmp`, which plays very badly with Haskell's RTS. Tests to get-coroutines working with HsLua were unsuccessful. No coroutine related functions-are exported from the default module for that reason. However, raw bindings to-the C API functions are still provided in `Foreign.Lua.RawBindings`. If you get-coroutines to work, or just believe that there should be wrapper functions for-other reasons, we'd love to hear from you.+    A big project build with hslua is [Pandoc](https://pandoc.org), the+    universal document converter. It is written in Haskell and includes a Lua+    interpreter, enabling programmatic modifications of documents via Lua.+    Furthermore, custom output formats can be defined via Lua scripts. -**Why are there no predefined stack instances for default numerical types?**-HsLua defines instances for the `FromLuaStack` and `ToLuaStack` type-classes-only if the following law holds: `return x == push x *> peek x`. Lua can be-compiled with customized number types, making it impossible to verify the-correctness of the above equation. Furthermore, instances for numerical types-can be based on those of LuaInteger and LuaNumber and are easy to write.-Therefor hslua doesn't provide any such instances.+- **Where are the coroutine related functions?** Yielding from a coroutine works+    via `longjmp`, which plays very badly with Haskell's RTS. Tests to get+    coroutines working with HsLua were unsuccessful. No coroutine related+    functions are exported from the default module for that reason. Pull+    requests intended to fix this are very welcome.

@@ -0,0 +1,40 @@+#include <string.h>+#include "benchmark-functions.h"++/*+** getlfield+*/+int hslua__getlfield(lua_State *L)+{+  lua_gettable(L, 1);+  return 1;+}++int hslua_getlfield(lua_State *L, int index, const char *k, size_t len)+{+  lua_pushvalue(L, index);+  lua_pushlstring(L, k, len);+  lua_pushcfunction(L, hslua__getlfield);+  lua_insert(L, -3);+  return -lua_pcall(L, 2, 1, 0);+}++/*+** setfield+*/+int hslua__setfield(lua_State *L)+{+  const char *k = lua_tostring(L, 3);+  lua_pushvalue(L, 1);+  lua_setfield(L, 2, k);+  return 0;+}++int hslua_setfield(lua_State *L, int index, const char *k)+{+  lua_pushvalue(L, index);+  lua_pushstring(L, k);+  lua_pushcfunction(L, hslua__setfield);+  lua_insert(L, -4);+  return -lua_pcall(L, 3, 0, 0);+}

@@ -0,0 +1,103 @@+{-+Copyright © 2018 Albert Krewinkel++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.+-}+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE OverloadedStrings #-}++import Control.DeepSeq+import Control.Monad (void)+import Criterion.Main+import Criterion.Types (Config(..))+import Data.ByteString (ByteString)+import Foreign.C (CString (..), CSize (..), CInt (..))+import Foreign.Lua (Lua, StackIndex)++import qualified Foreign.Lua as Lua+import qualified Data.ByteString as B+import qualified Data.ByteString.Unsafe as B++#include "benchmark-functions.h"++luaBench :: NFData b+         => String+         -> Lua a    -- ^ Setup+         -> Lua b    -- ^ Operation to benchmark+         -> Benchmark+luaBench name setupOp benchOp = do+  bench name .+    perRunEnvWithCleanup (setupLua setupOp) teardownLua $ \l ->+      Lua.runWith l benchOp++setupLua :: Lua a -> IO Lua.State+setupLua setupOp = do+  l <- Lua.newstate+  _ <- Lua.runWith l setupOp+  return l++teardownLua :: Lua.State -> IO ()+teardownLua = Lua.close++setupTableWithFooField :: Lua ()+setupTableWithFooField = do+  Lua.newtable+  Lua.pushstring "foo"+  Lua.setfield (Lua.nthFromTop 2) "bar"++main :: IO ()+main = defaultMain+  [ luaBench "getfield" setupTableWithFooField (Lua.getfield Lua.stackTop "foo")+  , luaBench "getlfield" setupTableWithFooField (getlfield Lua.stackTop "foo")+  , luaBench "setfield"+             (Lua.newtable *> Lua.pushboolean True)+             (Lua.setfield (Lua.nthFromTop 2) "foo")+  , luaBench "setfield_old"+             (Lua.newtable *> Lua.pushboolean True)+             (setfield_old (Lua.nthFromTop 2) "foo")+  , luaBench "getglobal" (return ()) (Lua.getglobal "foo")+  , luaBench "setglobal" (Lua.pushboolean True) (Lua.setglobal "foo")+  , luaBench "setraw"+             (Lua.newtable *> Lua.pushstring "foo" *> Lua.pushboolean True)+             (Lua.rawset (Lua.nthFromTop 3))+  ]++instance NFData Lua.State+++-- Functions for comparison++-- | Getting a string field with lua_pushlstring and lua_gettable+foreign import ccall "hslua_getlfield"+  hslua_getlfield :: Lua.State -> StackIndex -> CString -> CSize -> IO CInt++getlfield :: StackIndex -> ByteString -> Lua CInt+getlfield i s = do+  l <- Lua.state+  Lua.liftIO $ B.unsafeUseAsCStringLen s $ \(strPtr, len) ->+    hslua_getlfield l i strPtr (fromIntegral len)++-- | Getting a string field with lua_pushlstring and lua_gettable+foreign import ccall "hslua_setfield"+  hslua_setfield :: Lua.State -> StackIndex -> CString -> IO CInt++setfield_old :: StackIndex -> ByteString -> Lua CInt+setfield_old i s = do+  l <- Lua.state+  Lua.liftIO $ B.useAsCString s (hslua_setfield l i)

@@ -0,0 +1,250 @@+#include <stdio.h>+#include <string.h>+#include <HsFFI.h>+#include "error-conversion.h"++/* *********************************************************************+ * Transforming Haskell errors to Lua errors+ * *********************************************************************/+void hslua_pushhaskellerr(lua_State *L)+{+  lua_getfield(L, LUA_REGISTRYINDEX, "HSLUA_ERR");+}++/*+** Checks whether the object at the given index is a Haskell error.+*/+int hslua_is_haskell_error(lua_State *L, int idx) {+  hslua_pushhaskellerr(L);+  int is_err = lua_rawequal(L, idx, -1);+  lua_pop(L, 1);                /* pop haskellerr used for equality test */+  return is_err;+}++/*+** Converts a Haskell function into a CFunction.+**+** We signal an error on the haskell side by passing two values: the+** special haskellerr object and the error message. The function+** returned an error iff there are exactly two results objects where the+** first object is the special HSLUA_ERR registry entry.+*/+int hslua_call_hs(lua_State *L)+{+  int nargs = lua_gettop(L);+  /* Push HaskellImportFunction and call the underlying function */+  lua_pushvalue(L, lua_upvalueindex(1));+  lua_insert(L, 1);+  lua_call(L, nargs, LUA_MULTRET);++  /* Check whether an error value was returned */+  int nres = lua_gettop(L);++  /* If there are two results, the first of which is the special error+   * object, then the other object is thrown as an error.+   */+  if (nres == 2 && hslua_is_haskell_error(L, 1)) {+    return lua_error(L);        /* throw 2nd return value as error */+  }++  return nres;+}++/* *********************************************************************+ * Garbage Collection+ * *********************************************************************/++/*+** Free stable Haskell pointer in userdata.+*/+int hslua_userdata_gc(lua_State *L)+{+  HsStablePtr *userdata = lua_touserdata(L, 1);+  if (userdata) {+    hs_free_stable_ptr(*userdata);+  }+  return 0;+}+++/* *********************************************************************+ * Transforming Lua errors to Haskell errors+ * *********************************************************************/++/*+** compare+*/+int hslua__compare(lua_State *L)+{+  int op = lua_tointeger(L, 3);+  int res = lua_compare(L, 1, 2, op);+  lua_pushinteger(L, res);+  return 1;+}++int hslua_compare(lua_State *L, int index1, int index2, int op)+{+  index1 = lua_absindex(L, index1);+  index2 = lua_absindex(L, index2);+  lua_pushcfunction(L, hslua__compare);+  lua_pushvalue(L, index1);+  lua_pushvalue(L, index2);+  lua_pushinteger(L, op);+  int callres = lua_pcall(L, 3, 1, 0);+  if (callres != 0) {+    return -callres;+  }+  int res = lua_tointeger(L, -1);+  lua_pop(L, 1);+  return res;+}+++/*+** concat+*/+int hslua__concat(lua_State *L)+{+  lua_concat(L, lua_gettop(L));+  return 1;+}++int hslua_concat(lua_State *L, int n)+{+  lua_pushcfunction(L, hslua__concat);+  lua_insert(L, -n - 1);+  return -lua_pcall(L, n, 1, 0);+}+++/*+** getglobal+*/+int hslua__getglobal(lua_State *L)+{+  lua_gettable(L, 1);+  return 1;+}++int hslua_getglobal(lua_State *L, const char *name, size_t len)+{+  lua_pushcfunction(L, hslua__getglobal);+  lua_pushglobaltable(L);+  lua_pushlstring(L, name, len);+  return -lua_pcall(L, 2, 1, 0);+}+++/*+** gettable+*/+int hslua__gettable(lua_State *L)+{+  lua_pushvalue(L, 1);+  lua_gettable(L, 2);+  return 1;+}++int hslua_gettable(lua_State *L, int index)+{+  lua_pushvalue(L, index);+  lua_pushcfunction(L, hslua__gettable);+  lua_insert(L, -3);+  return -lua_pcall(L, 2, 1, 0);+}+++/*+** setglobal+*/+int hslua__setglobal(lua_State *L)+{+  /* index 1: value */+  /* index 2: the global table */+  /* index 3: key */+  lua_pushvalue(L, 1);+  lua_settable(L, 2);+  return 0;+}++int hslua_setglobal(lua_State *L, const char *name, size_t len)+{+  /* we expect the new value to be at the top of the stack */+  lua_pushglobaltable(L);+  lua_pushlstring(L, name, len);+  lua_pushcfunction(L, hslua__setglobal);+  lua_insert(L, -4);+  return -lua_pcall(L, 3, 0, 0);+}+++/*+** settable+*/+int hslua__settable(lua_State *L)+{+  lua_pushvalue(L, 1); /* key */+  lua_pushvalue(L, 2); /* value */+  lua_settable(L, 3);  /* table is the third argument */+  return 0;+}++int hslua_settable(lua_State *L, int index)+{+  lua_pushvalue(L, index);+  lua_pushcfunction(L, hslua__settable);+  lua_insert(L, -4);+  return -lua_pcall(L, 3, 0, 0);+}+++/*+** next+*/+int hslua__next(lua_State *L)+{+  lua_pushvalue(L, 1);+  return lua_next(L, 2) ? 2 : 0;+}++int hslua_next(lua_State *L, int index)+{+  int oldsize = lua_gettop(L);+  lua_pushvalue(L, index);+  lua_pushcfunction(L, hslua__next);+  lua_insert(L, -3);+  int res = lua_pcall(L, 2, LUA_MULTRET, 0);+  if (res != 0) {+    /* error */+    return (- res);+  }+  /* success */+  return (lua_gettop(L) - oldsize + 1); /* correct for popped value */+}+++/*+** Auxiliary Library+*/++/*+** tolstring'+*/+int hsluaL__tolstring(lua_State *L)+{+  luaL_tolstring(L, 1, NULL);+  return 1;+}++const char *hsluaL_tolstring(lua_State *L, int index, size_t *len)+{+  lua_pushvalue(L, index);+  lua_pushcfunction(L, hsluaL__tolstring);+  lua_insert(L, -2);+  int res = lua_pcall(L, 1, 1, 0);+  if (res != 0) {+    /* error */+    return NULL;+  }+  return lua_tolstring(L, -1, len);+}

@@ -0,0 +1,24 @@+#include "lua.h"+#include "lauxlib.h"++int hslua_call_hs(lua_State *L);++int hslua_userdata_gc(lua_State *L);++int hslua_compare(lua_State *L, int index1, int index2, int op);++int hslua_concat(lua_State *L, int n);++int hslua_getglobal(lua_State *L, const char *name, size_t len);++int hslua_gettable(lua_State *L, int index);++int hslua_setglobal(lua_State *L, const char *k, size_t len);++int hslua_settable(lua_State *L, int index);++int hslua_next(lua_State *L, int index);+++/* auxiliary library */+const char *hsluaL_tolstring(lua_State *L, int index, size_t *len);

@@ -0,0 +1,1299 @@+/*+** $Id: lapi.c,v 2.259.1.2 2017/12/06 18:35:12 roberto Exp $+** Lua API+** See Copyright Notice in lua.h+*/++#define lapi_c+#define LUA_CORE++#include "lprefix.h"+++#include <stdarg.h>+#include <string.h>++#include "lua.h"++#include "lapi.h"+#include "ldebug.h"+#include "ldo.h"+#include "lfunc.h"+#include "lgc.h"+#include "lmem.h"+#include "lobject.h"+#include "lstate.h"+#include "lstring.h"+#include "ltable.h"+#include "ltm.h"+#include "lundump.h"+#include "lvm.h"++++const char lua_ident[] =+  "$LuaVersion: " LUA_COPYRIGHT " $"+  "$LuaAuthors: " LUA_AUTHORS " $";+++/* value at a non-valid index */+#define NONVALIDVALUE		cast(TValue *, luaO_nilobject)++/* corresponding test */+#define isvalid(o)	((o) != luaO_nilobject)++/* test for pseudo index */+#define ispseudo(i)		((i) <= LUA_REGISTRYINDEX)++/* test for upvalue */+#define isupvalue(i)		((i) < LUA_REGISTRYINDEX)++/* test for valid but not pseudo index */+#define isstackindex(i, o)	(isvalid(o) && !ispseudo(i))++#define api_checkvalidindex(l,o)  api_check(l, isvalid(o), "invalid index")++#define api_checkstackindex(l, i, o)  \+	api_check(l, isstackindex(i, o), "index not in the stack")+++static TValue *index2addr (lua_State *L, int idx) {+  CallInfo *ci = L->ci;+  if (idx > 0) {+    TValue *o = ci->func + idx;+    api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");+    if (o >= L->top) return NONVALIDVALUE;+    else return o;+  }+  else if (!ispseudo(idx)) {  /* negative index */+    api_check(L, idx != 0 && -idx <= L->top - (ci->func + 1), "invalid index");+    return L->top + idx;+  }+  else if (idx == LUA_REGISTRYINDEX)+    return &G(L)->l_registry;+  else {  /* upvalues */+    idx = LUA_REGISTRYINDEX - idx;+    api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large");+    if (ttislcf(ci->func))  /* light C function? */+      return NONVALIDVALUE;  /* it has no upvalues */+    else {+      CClosure *func = clCvalue(ci->func);+      return (idx <= func->nupvalues) ? &func->upvalue[idx-1] : NONVALIDVALUE;+    }+  }+}+++/*+** to be called by 'lua_checkstack' in protected mode, to grow stack+** capturing memory errors+*/+static void growstack (lua_State *L, void *ud) {+  int size = *(int *)ud;+  luaD_growstack(L, size);+}+++LUA_API int lua_checkstack (lua_State *L, int n) {+  int res;+  CallInfo *ci = L->ci;+  lua_lock(L);+  api_check(L, n >= 0, "negative 'n'");+  if (L->stack_last - L->top > n)  /* stack large enough? */+    res = 1;  /* yes; check is OK */+  else {  /* no; need to grow stack */+    int inuse = cast_int(L->top - L->stack) + EXTRA_STACK;+    if (inuse > LUAI_MAXSTACK - n)  /* can grow without overflow? */+      res = 0;  /* no */+    else  /* try to grow stack */+      res = (luaD_rawrunprotected(L, &growstack, &n) == LUA_OK);+  }+  if (res && ci->top < L->top + n)+    ci->top = L->top + n;  /* adjust frame top */+  lua_unlock(L);+  return res;+}+++LUA_API void lua_xmove (lua_State *from, lua_State *to, int n) {+  int i;+  if (from == to) return;+  lua_lock(to);+  api_checknelems(from, n);+  api_check(from, G(from) == G(to), "moving among independent states");+  api_check(from, to->ci->top - to->top >= n, "stack overflow");+  from->top -= n;+  for (i = 0; i < n; i++) {+    setobj2s(to, to->top, from->top + i);+    to->top++;  /* stack already checked by previous 'api_check' */+  }+  lua_unlock(to);+}+++LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) {+  lua_CFunction old;+  lua_lock(L);+  old = G(L)->panic;+  G(L)->panic = panicf;+  lua_unlock(L);+  return old;+}+++LUA_API const lua_Number *lua_version (lua_State *L) {+  static const lua_Number version = LUA_VERSION_NUM;+  if (L == NULL) return &version;+  else return G(L)->version;+}++++/*+** basic stack manipulation+*/+++/*+** convert an acceptable stack index into an absolute index+*/+LUA_API int lua_absindex (lua_State *L, int idx) {+  return (idx > 0 || ispseudo(idx))+         ? idx+         : cast_int(L->top - L->ci->func) + idx;+}+++LUA_API int lua_gettop (lua_State *L) {+  return cast_int(L->top - (L->ci->func + 1));+}+++LUA_API void lua_settop (lua_State *L, int idx) {+  StkId func = L->ci->func;+  lua_lock(L);+  if (idx >= 0) {+    api_check(L, idx <= L->stack_last - (func + 1), "new top too large");+    while (L->top < (func + 1) + idx)+      setnilvalue(L->top++);+    L->top = (func + 1) + idx;+  }+  else {+    api_check(L, -(idx+1) <= (L->top - (func + 1)), "invalid new top");+    L->top += idx+1;  /* 'subtract' index (index is negative) */+  }+  lua_unlock(L);+}+++/*+** Reverse the stack segment from 'from' to 'to'+** (auxiliary to 'lua_rotate')+*/+static void reverse (lua_State *L, StkId from, StkId to) {+  for (; from < to; from++, to--) {+    TValue temp;+    setobj(L, &temp, from);+    setobjs2s(L, from, to);+    setobj2s(L, to, &temp);+  }+}+++/*+** Let x = AB, where A is a prefix of length 'n'. Then,+** rotate x n == BA. But BA == (A^r . B^r)^r.+*/+LUA_API void lua_rotate (lua_State *L, int idx, int n) {+  StkId p, t, m;+  lua_lock(L);+  t = L->top - 1;  /* end of stack segment being rotated */+  p = index2addr(L, idx);  /* start of segment */+  api_checkstackindex(L, idx, p);+  api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'");+  m = (n >= 0 ? t - n : p - n - 1);  /* end of prefix */+  reverse(L, p, m);  /* reverse the prefix with length 'n' */+  reverse(L, m + 1, t);  /* reverse the suffix */+  reverse(L, p, t);  /* reverse the entire segment */+  lua_unlock(L);+}+++LUA_API void lua_copy (lua_State *L, int fromidx, int toidx) {+  TValue *fr, *to;+  lua_lock(L);+  fr = index2addr(L, fromidx);+  to = index2addr(L, toidx);+  api_checkvalidindex(L, to);+  setobj(L, to, fr);+  if (isupvalue(toidx))  /* function upvalue? */+    luaC_barrier(L, clCvalue(L->ci->func), fr);+  /* LUA_REGISTRYINDEX does not need gc barrier+     (collector revisits it before finishing collection) */+  lua_unlock(L);+}+++LUA_API void lua_pushvalue (lua_State *L, int idx) {+  lua_lock(L);+  setobj2s(L, L->top, index2addr(L, idx));+  api_incr_top(L);+  lua_unlock(L);+}++++/*+** access functions (stack -> C)+*/+++LUA_API int lua_type (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  return (isvalid(o) ? ttnov(o) : LUA_TNONE);+}+++LUA_API const char *lua_typename (lua_State *L, int t) {+  UNUSED(L);+  api_check(L, LUA_TNONE <= t && t < LUA_NUMTAGS, "invalid tag");+  return ttypename(t);+}+++LUA_API int lua_iscfunction (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  return (ttislcf(o) || (ttisCclosure(o)));+}+++LUA_API int lua_isinteger (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  return ttisinteger(o);+}+++LUA_API int lua_isnumber (lua_State *L, int idx) {+  lua_Number n;+  const TValue *o = index2addr(L, idx);+  return tonumber(o, &n);+}+++LUA_API int lua_isstring (lua_State *L, int idx) {+  const TValue *o = index2addr(L, idx);+  return (ttisstring(o) || cvt2str(o));+}+++LUA_API int lua_isuserdata (lua_State *L, int idx) {+  const TValue *o = index2addr(L, idx);+  return (ttisfulluserdata(o) || ttislightuserdata(o));+}+++LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {+  StkId o1 = index2addr(L, index1);+  StkId o2 = index2addr(L, index2);+  return (isvalid(o1) && isvalid(o2)) ? luaV_rawequalobj(o1, o2) : 0;+}+++LUA_API void lua_arith (lua_State *L, int op) {+  lua_lock(L);+  if (op != LUA_OPUNM && op != LUA_OPBNOT)+    api_checknelems(L, 2);  /* all other operations expect two operands */+  else {  /* for unary operations, add fake 2nd operand */+    api_checknelems(L, 1);+    setobjs2s(L, L->top, L->top - 1);+    api_incr_top(L);+  }+  /* first operand at top - 2, second at top - 1; result go to top - 2 */+  luaO_arith(L, op, L->top - 2, L->top - 1, L->top - 2);+  L->top--;  /* remove second operand */+  lua_unlock(L);+}+++LUA_API int lua_compare (lua_State *L, int index1, int index2, int op) {+  StkId o1, o2;+  int i = 0;+  lua_lock(L);  /* may call tag method */+  o1 = index2addr(L, index1);+  o2 = index2addr(L, index2);+  if (isvalid(o1) && isvalid(o2)) {+    switch (op) {+      case LUA_OPEQ: i = luaV_equalobj(L, o1, o2); break;+      case LUA_OPLT: i = luaV_lessthan(L, o1, o2); break;+      case LUA_OPLE: i = luaV_lessequal(L, o1, o2); break;+      default: api_check(L, 0, "invalid option");+    }+  }+  lua_unlock(L);+  return i;+}+++LUA_API size_t lua_stringtonumber (lua_State *L, const char *s) {+  size_t sz = luaO_str2num(s, L->top);+  if (sz != 0)+    api_incr_top(L);+  return sz;+}+++LUA_API lua_Number lua_tonumberx (lua_State *L, int idx, int *pisnum) {+  lua_Number n;+  const TValue *o = index2addr(L, idx);+  int isnum = tonumber(o, &n);+  if (!isnum)+    n = 0;  /* call to 'tonumber' may change 'n' even if it fails */+  if (pisnum) *pisnum = isnum;+  return n;+}+++LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {+  lua_Integer res;+  const TValue *o = index2addr(L, idx);+  int isnum = tointeger(o, &res);+  if (!isnum)+    res = 0;  /* call to 'tointeger' may change 'n' even if it fails */+  if (pisnum) *pisnum = isnum;+  return res;+}+++LUA_API int lua_toboolean (lua_State *L, int idx) {+  const TValue *o = index2addr(L, idx);+  return !l_isfalse(o);+}+++LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {+  StkId o = index2addr(L, idx);+  if (!ttisstring(o)) {+    if (!cvt2str(o)) {  /* not convertible? */+      if (len != NULL) *len = 0;+      return NULL;+    }+    lua_lock(L);  /* 'luaO_tostring' may create a new string */+    luaO_tostring(L, o);+    luaC_checkGC(L);+    o = index2addr(L, idx);  /* previous call may reallocate the stack */+    lua_unlock(L);+  }+  if (len != NULL)+    *len = vslen(o);+  return svalue(o);+}+++LUA_API size_t lua_rawlen (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  switch (ttype(o)) {+    case LUA_TSHRSTR: return tsvalue(o)->shrlen;+    case LUA_TLNGSTR: return tsvalue(o)->u.lnglen;+    case LUA_TUSERDATA: return uvalue(o)->len;+    case LUA_TTABLE: return luaH_getn(hvalue(o));+    default: return 0;+  }+}+++LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  if (ttislcf(o)) return fvalue(o);+  else if (ttisCclosure(o))+    return clCvalue(o)->f;+  else return NULL;  /* not a C function */+}+++LUA_API void *lua_touserdata (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  switch (ttnov(o)) {+    case LUA_TUSERDATA: return getudatamem(uvalue(o));+    case LUA_TLIGHTUSERDATA: return pvalue(o);+    default: return NULL;+  }+}+++LUA_API lua_State *lua_tothread (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  return (!ttisthread(o)) ? NULL : thvalue(o);+}+++LUA_API const void *lua_topointer (lua_State *L, int idx) {+  StkId o = index2addr(L, idx);+  switch (ttype(o)) {+    case LUA_TTABLE: return hvalue(o);+    case LUA_TLCL: return clLvalue(o);+    case LUA_TCCL: return clCvalue(o);+    case LUA_TLCF: return cast(void *, cast(size_t, fvalue(o)));+    case LUA_TTHREAD: return thvalue(o);+    case LUA_TUSERDATA: return getudatamem(uvalue(o));+    case LUA_TLIGHTUSERDATA: return pvalue(o);+    default: return NULL;+  }+}++++/*+** push functions (C -> stack)+*/+++LUA_API void lua_pushnil (lua_State *L) {+  lua_lock(L);+  setnilvalue(L->top);+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_pushnumber (lua_State *L, lua_Number n) {+  lua_lock(L);+  setfltvalue(L->top, n);+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {+  lua_lock(L);+  setivalue(L->top, n);+  api_incr_top(L);+  lua_unlock(L);+}+++/*+** Pushes on the stack a string with given length. Avoid using 's' when+** 'len' == 0 (as 's' can be NULL in that case), due to later use of+** 'memcmp' and 'memcpy'.+*/+LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) {+  TString *ts;+  lua_lock(L);+  ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len);+  setsvalue2s(L, L->top, ts);+  api_incr_top(L);+  luaC_checkGC(L);+  lua_unlock(L);+  return getstr(ts);+}+++LUA_API const char *lua_pushstring (lua_State *L, const char *s) {+  lua_lock(L);+  if (s == NULL)+    setnilvalue(L->top);+  else {+    TString *ts;+    ts = luaS_new(L, s);+    setsvalue2s(L, L->top, ts);+    s = getstr(ts);  /* internal copy's address */+  }+  api_incr_top(L);+  luaC_checkGC(L);+  lua_unlock(L);+  return s;+}+++LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,+                                      va_list argp) {+  const char *ret;+  lua_lock(L);+  ret = luaO_pushvfstring(L, fmt, argp);+  luaC_checkGC(L);+  lua_unlock(L);+  return ret;+}+++LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) {+  const char *ret;+  va_list argp;+  lua_lock(L);+  va_start(argp, fmt);+  ret = luaO_pushvfstring(L, fmt, argp);+  va_end(argp);+  luaC_checkGC(L);+  lua_unlock(L);+  return ret;+}+++LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {+  lua_lock(L);+  if (n == 0) {+    setfvalue(L->top, fn);+    api_incr_top(L);+  }+  else {+    CClosure *cl;+    api_checknelems(L, n);+    api_check(L, n <= MAXUPVAL, "upvalue index too large");+    cl = luaF_newCclosure(L, n);+    cl->f = fn;+    L->top -= n;+    while (n--) {+      setobj2n(L, &cl->upvalue[n], L->top + n);+      /* does not need barrier because closure is white */+    }+    setclCvalue(L, L->top, cl);+    api_incr_top(L);+    luaC_checkGC(L);+  }+  lua_unlock(L);+}+++LUA_API void lua_pushboolean (lua_State *L, int b) {+  lua_lock(L);+  setbvalue(L->top, (b != 0));  /* ensure that true is 1 */+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_pushlightuserdata (lua_State *L, void *p) {+  lua_lock(L);+  setpvalue(L->top, p);+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API int lua_pushthread (lua_State *L) {+  lua_lock(L);+  setthvalue(L, L->top, L);+  api_incr_top(L);+  lua_unlock(L);+  return (G(L)->mainthread == L);+}++++/*+** get functions (Lua -> stack)+*/+++static int auxgetstr (lua_State *L, const TValue *t, const char *k) {+  const TValue *slot;+  TString *str = luaS_new(L, k);+  if (luaV_fastget(L, t, str, slot, luaH_getstr)) {+    setobj2s(L, L->top, slot);+    api_incr_top(L);+  }+  else {+    setsvalue2s(L, L->top, str);+    api_incr_top(L);+    luaV_finishget(L, t, L->top - 1, L->top - 1, slot);+  }+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++LUA_API int lua_getglobal (lua_State *L, const char *name) {+  Table *reg = hvalue(&G(L)->l_registry);+  lua_lock(L);+  return auxgetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);+}+++LUA_API int lua_gettable (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  t = index2addr(L, idx);+  luaV_gettable(L, t, L->top - 1, L->top - 1);+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++LUA_API int lua_getfield (lua_State *L, int idx, const char *k) {+  lua_lock(L);+  return auxgetstr(L, index2addr(L, idx), k);+}+++LUA_API int lua_geti (lua_State *L, int idx, lua_Integer n) {+  StkId t;+  const TValue *slot;+  lua_lock(L);+  t = index2addr(L, idx);+  if (luaV_fastget(L, t, n, slot, luaH_getint)) {+    setobj2s(L, L->top, slot);+    api_incr_top(L);+  }+  else {+    setivalue(L->top, n);+    api_incr_top(L);+    luaV_finishget(L, t, L->top - 1, L->top - 1, slot);+  }+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++LUA_API int lua_rawget (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  t = index2addr(L, idx);+  api_check(L, ttistable(t), "table expected");+  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++LUA_API int lua_rawgeti (lua_State *L, int idx, lua_Integer n) {+  StkId t;+  lua_lock(L);+  t = index2addr(L, idx);+  api_check(L, ttistable(t), "table expected");+  setobj2s(L, L->top, luaH_getint(hvalue(t), n));+  api_incr_top(L);+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++LUA_API int lua_rawgetp (lua_State *L, int idx, const void *p) {+  StkId t;+  TValue k;+  lua_lock(L);+  t = index2addr(L, idx);+  api_check(L, ttistable(t), "table expected");+  setpvalue(&k, cast(void *, p));+  setobj2s(L, L->top, luaH_get(hvalue(t), &k));+  api_incr_top(L);+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {+  Table *t;+  lua_lock(L);+  t = luaH_new(L);+  sethvalue(L, L->top, t);+  api_incr_top(L);+  if (narray > 0 || nrec > 0)+    luaH_resize(L, t, narray, nrec);+  luaC_checkGC(L);+  lua_unlock(L);+}+++LUA_API int lua_getmetatable (lua_State *L, int objindex) {+  const TValue *obj;+  Table *mt;+  int res = 0;+  lua_lock(L);+  obj = index2addr(L, objindex);+  switch (ttnov(obj)) {+    case LUA_TTABLE:+      mt = hvalue(obj)->metatable;+      break;+    case LUA_TUSERDATA:+      mt = uvalue(obj)->metatable;+      break;+    default:+      mt = G(L)->mt[ttnov(obj)];+      break;+  }+  if (mt != NULL) {+    sethvalue(L, L->top, mt);+    api_incr_top(L);+    res = 1;+  }+  lua_unlock(L);+  return res;+}+++LUA_API int lua_getuservalue (lua_State *L, int idx) {+  StkId o;+  lua_lock(L);+  o = index2addr(L, idx);+  api_check(L, ttisfulluserdata(o), "full userdata expected");+  getuservalue(L, uvalue(o), L->top);+  api_incr_top(L);+  lua_unlock(L);+  return ttnov(L->top - 1);+}+++/*+** set functions (stack -> Lua)+*/++/*+** t[k] = value at the top of the stack (where 'k' is a string)+*/+static void auxsetstr (lua_State *L, const TValue *t, const char *k) {+  const TValue *slot;+  TString *str = luaS_new(L, k);+  api_checknelems(L, 1);+  if (luaV_fastset(L, t, str, slot, luaH_getstr, L->top - 1))+    L->top--;  /* pop value */+  else {+    setsvalue2s(L, L->top, str);  /* push 'str' (to make it a TValue) */+    api_incr_top(L);+    luaV_finishset(L, t, L->top - 1, L->top - 2, slot);+    L->top -= 2;  /* pop value and key */+  }+  lua_unlock(L);  /* lock done by caller */+}+++LUA_API void lua_setglobal (lua_State *L, const char *name) {+  Table *reg = hvalue(&G(L)->l_registry);+  lua_lock(L);  /* unlock done in 'auxsetstr' */+  auxsetstr(L, luaH_getint(reg, LUA_RIDX_GLOBALS), name);+}+++LUA_API void lua_settable (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  api_checknelems(L, 2);+  t = index2addr(L, idx);+  luaV_settable(L, t, L->top - 2, L->top - 1);+  L->top -= 2;  /* pop index and value */+  lua_unlock(L);+}+++LUA_API void lua_setfield (lua_State *L, int idx, const char *k) {+  lua_lock(L);  /* unlock done in 'auxsetstr' */+  auxsetstr(L, index2addr(L, idx), k);+}+++LUA_API void lua_seti (lua_State *L, int idx, lua_Integer n) {+  StkId t;+  const TValue *slot;+  lua_lock(L);+  api_checknelems(L, 1);+  t = index2addr(L, idx);+  if (luaV_fastset(L, t, n, slot, luaH_getint, L->top - 1))+    L->top--;  /* pop value */+  else {+    setivalue(L->top, n);+    api_incr_top(L);+    luaV_finishset(L, t, L->top - 1, L->top - 2, slot);+    L->top -= 2;  /* pop value and key */+  }+  lua_unlock(L);+}+++LUA_API void lua_rawset (lua_State *L, int idx) {+  StkId o;+  TValue *slot;+  lua_lock(L);+  api_checknelems(L, 2);+  o = index2addr(L, idx);+  api_check(L, ttistable(o), "table expected");+  slot = luaH_set(L, hvalue(o), L->top - 2);+  setobj2t(L, slot, L->top - 1);+  invalidateTMcache(hvalue(o));+  luaC_barrierback(L, hvalue(o), L->top-1);+  L->top -= 2;+  lua_unlock(L);+}+++LUA_API void lua_rawseti (lua_State *L, int idx, lua_Integer n) {+  StkId o;+  lua_lock(L);+  api_checknelems(L, 1);+  o = index2addr(L, idx);+  api_check(L, ttistable(o), "table expected");+  luaH_setint(L, hvalue(o), n, L->top - 1);+  luaC_barrierback(L, hvalue(o), L->top-1);+  L->top--;+  lua_unlock(L);+}+++LUA_API void lua_rawsetp (lua_State *L, int idx, const void *p) {+  StkId o;+  TValue k, *slot;+  lua_lock(L);+  api_checknelems(L, 1);+  o = index2addr(L, idx);+  api_check(L, ttistable(o), "table expected");+  setpvalue(&k, cast(void *, p));+  slot = luaH_set(L, hvalue(o), &k);+  setobj2t(L, slot, L->top - 1);+  luaC_barrierback(L, hvalue(o), L->top - 1);+  L->top--;+  lua_unlock(L);+}+++LUA_API int lua_setmetatable (lua_State *L, int objindex) {+  TValue *obj;+  Table *mt;+  lua_lock(L);+  api_checknelems(L, 1);+  obj = index2addr(L, objindex);+  if (ttisnil(L->top - 1))+    mt = NULL;+  else {+    api_check(L, ttistable(L->top - 1), "table expected");+    mt = hvalue(L->top - 1);+  }+  switch (ttnov(obj)) {+    case LUA_TTABLE: {+      hvalue(obj)->metatable = mt;+      if (mt) {+        luaC_objbarrier(L, gcvalue(obj), mt);+        luaC_checkfinalizer(L, gcvalue(obj), mt);+      }+      break;+    }+    case LUA_TUSERDATA: {+      uvalue(obj)->metatable = mt;+      if (mt) {+        luaC_objbarrier(L, uvalue(obj), mt);+        luaC_checkfinalizer(L, gcvalue(obj), mt);+      }+      break;+    }+    default: {+      G(L)->mt[ttnov(obj)] = mt;+      break;+    }+  }+  L->top--;+  lua_unlock(L);+  return 1;+}+++LUA_API void lua_setuservalue (lua_State *L, int idx) {+  StkId o;+  lua_lock(L);+  api_checknelems(L, 1);+  o = index2addr(L, idx);+  api_check(L, ttisfulluserdata(o), "full userdata expected");+  setuservalue(L, uvalue(o), L->top - 1);+  luaC_barrier(L, gcvalue(o), L->top - 1);+  L->top--;+  lua_unlock(L);+}+++/*+** 'load' and 'call' functions (run Lua code)+*/+++#define checkresults(L,na,nr) \+     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)), \+	"results from function overflow current stack size")+++LUA_API void lua_callk (lua_State *L, int nargs, int nresults,+                        lua_KContext ctx, lua_KFunction k) {+  StkId func;+  lua_lock(L);+  api_check(L, k == NULL || !isLua(L->ci),+    "cannot use continuations inside hooks");+  api_checknelems(L, nargs+1);+  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");+  checkresults(L, nargs, nresults);+  func = L->top - (nargs+1);+  if (k != NULL && L->nny == 0) {  /* need to prepare continuation? */+    L->ci->u.c.k = k;  /* save continuation */+    L->ci->u.c.ctx = ctx;  /* save context */+    luaD_call(L, func, nresults);  /* do the call */+  }+  else  /* no continuation or no yieldable */+    luaD_callnoyield(L, func, nresults);  /* just do the call */+  adjustresults(L, nresults);+  lua_unlock(L);+}++++/*+** Execute a protected call.+*/+struct CallS {  /* data to 'f_call' */+  StkId func;+  int nresults;+};+++static void f_call (lua_State *L, void *ud) {+  struct CallS *c = cast(struct CallS *, ud);+  luaD_callnoyield(L, c->func, c->nresults);+}++++LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,+                        lua_KContext ctx, lua_KFunction k) {+  struct CallS c;+  int status;+  ptrdiff_t func;+  lua_lock(L);+  api_check(L, k == NULL || !isLua(L->ci),+    "cannot use continuations inside hooks");+  api_checknelems(L, nargs+1);+  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");+  checkresults(L, nargs, nresults);+  if (errfunc == 0)+    func = 0;+  else {+    StkId o = index2addr(L, errfunc);+    api_checkstackindex(L, errfunc, o);+    func = savestack(L, o);+  }+  c.func = L->top - (nargs+1);  /* function to be called */+  if (k == NULL || L->nny > 0) {  /* no continuation or no yieldable? */+    c.nresults = nresults;  /* do a 'conventional' protected call */+    status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);+  }+  else {  /* prepare continuation (call is already protected by 'resume') */+    CallInfo *ci = L->ci;+    ci->u.c.k = k;  /* save continuation */+    ci->u.c.ctx = ctx;  /* save context */+    /* save information for error recovery */+    ci->extra = savestack(L, c.func);+    ci->u.c.old_errfunc = L->errfunc;+    L->errfunc = func;+    setoah(ci->callstatus, L->allowhook);  /* save value of 'allowhook' */+    ci->callstatus |= CIST_YPCALL;  /* function can do error recovery */+    luaD_call(L, c.func, nresults);  /* do the call */+    ci->callstatus &= ~CIST_YPCALL;+    L->errfunc = ci->u.c.old_errfunc;+    status = LUA_OK;  /* if it is here, there were no errors */+  }+  adjustresults(L, nresults);+  lua_unlock(L);+  return status;+}+++LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,+                      const char *chunkname, const char *mode) {+  ZIO z;+  int status;+  lua_lock(L);+  if (!chunkname) chunkname = "?";+  luaZ_init(L, &z, reader, data);+  status = luaD_protectedparser(L, &z, chunkname, mode);+  if (status == LUA_OK) {  /* no errors? */+    LClosure *f = clLvalue(L->top - 1);  /* get newly created function */+    if (f->nupvalues >= 1) {  /* does it have an upvalue? */+      /* get global table from registry */+      Table *reg = hvalue(&G(L)->l_registry);+      const TValue *gt = luaH_getint(reg, LUA_RIDX_GLOBALS);+      /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */+      setobj(L, f->upvals[0]->v, gt);+      luaC_upvalbarrier(L, f->upvals[0]);+    }+  }+  lua_unlock(L);+  return status;+}+++LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data, int strip) {+  int status;+  TValue *o;+  lua_lock(L);+  api_checknelems(L, 1);+  o = L->top - 1;+  if (isLfunction(o))+    status = luaU_dump(L, getproto(o), writer, data, strip);+  else+    status = 1;+  lua_unlock(L);+  return status;+}+++LUA_API int lua_status (lua_State *L) {+  return L->status;+}+++/*+** Garbage-collection function+*/++LUA_API int lua_gc (lua_State *L, int what, int data) {+  int res = 0;+  global_State *g;+  lua_lock(L);+  g = G(L);+  switch (what) {+    case LUA_GCSTOP: {+      g->gcrunning = 0;+      break;+    }+    case LUA_GCRESTART: {+      luaE_setdebt(g, 0);+      g->gcrunning = 1;+      break;+    }+    case LUA_GCCOLLECT: {+      luaC_fullgc(L, 0);+      break;+    }+    case LUA_GCCOUNT: {+      /* GC values are expressed in Kbytes: #bytes/2^10 */+      res = cast_int(gettotalbytes(g) >> 10);+      break;+    }+    case LUA_GCCOUNTB: {+      res = cast_int(gettotalbytes(g) & 0x3ff);+      break;+    }+    case LUA_GCSTEP: {+      l_mem debt = 1;  /* =1 to signal that it did an actual step */+      lu_byte oldrunning = g->gcrunning;+      g->gcrunning = 1;  /* allow GC to run */+      if (data == 0) {+        luaE_setdebt(g, -GCSTEPSIZE);  /* to do a "small" step */+        luaC_step(L);+      }+      else {  /* add 'data' to total debt */+        debt = cast(l_mem, data) * 1024 + g->GCdebt;+        luaE_setdebt(g, debt);+        luaC_checkGC(L);+      }+      g->gcrunning = oldrunning;  /* restore previous state */+      if (debt > 0 && g->gcstate == GCSpause)  /* end of cycle? */+        res = 1;  /* signal it */+      break;+    }+    case LUA_GCSETPAUSE: {+      res = g->gcpause;+      g->gcpause = data;+      break;+    }+    case LUA_GCSETSTEPMUL: {+      res = g->gcstepmul;+      if (data < 40) data = 40;  /* avoid ridiculous low values (and 0) */+      g->gcstepmul = data;+      break;+    }+    case LUA_GCISRUNNING: {+      res = g->gcrunning;+      break;+    }+    default: res = -1;  /* invalid option */+  }+  lua_unlock(L);+  return res;+}++++/*+** miscellaneous functions+*/+++LUA_API int lua_error (lua_State *L) {+  lua_lock(L);+  api_checknelems(L, 1);+  luaG_errormsg(L);+  /* code unreachable; will unlock when control actually leaves the kernel */+  return 0;  /* to avoid warnings */+}+++LUA_API int lua_next (lua_State *L, int idx) {+  StkId t;+  int more;+  lua_lock(L);+  t = index2addr(L, idx);+  api_check(L, ttistable(t), "table expected");+  more = luaH_next(L, hvalue(t), L->top - 1);+  if (more) {+    api_incr_top(L);+  }+  else  /* no more elements */+    L->top -= 1;  /* remove key */+  lua_unlock(L);+  return more;+}+++LUA_API void lua_concat (lua_State *L, int n) {+  lua_lock(L);+  api_checknelems(L, n);+  if (n >= 2) {+    luaV_concat(L, n);+  }+  else if (n == 0) {  /* push empty string */+    setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));+    api_incr_top(L);+  }+  /* else n == 1; nothing to do */+  luaC_checkGC(L);+  lua_unlock(L);+}+++LUA_API void lua_len (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  t = index2addr(L, idx);+  luaV_objlen(L, L->top, t);+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) {+  lua_Alloc f;+  lua_lock(L);+  if (ud) *ud = G(L)->ud;+  f = G(L)->frealloc;+  lua_unlock(L);+  return f;+}+++LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud) {+  lua_lock(L);+  G(L)->ud = ud;+  G(L)->frealloc = f;+  lua_unlock(L);+}+++LUA_API void *lua_newuserdata (lua_State *L, size_t size) {+  Udata *u;+  lua_lock(L);+  u = luaS_newudata(L, size);+  setuvalue(L, L->top, u);+  api_incr_top(L);+  luaC_checkGC(L);+  lua_unlock(L);+  return getudatamem(u);+}++++static const char *aux_upvalue (StkId fi, int n, TValue **val,+                                CClosure **owner, UpVal **uv) {+  switch (ttype(fi)) {+    case LUA_TCCL: {  /* C closure */+      CClosure *f = clCvalue(fi);+      if (!(1 <= n && n <= f->nupvalues)) return NULL;+      *val = &f->upvalue[n-1];+      if (owner) *owner = f;+      return "";+    }+    case LUA_TLCL: {  /* Lua closure */+      LClosure *f = clLvalue(fi);+      TString *name;+      Proto *p = f->p;+      if (!(1 <= n && n <= p->sizeupvalues)) return NULL;+      *val = f->upvals[n-1]->v;+      if (uv) *uv = f->upvals[n - 1];+      name = p->upvalues[n-1].name;+      return (name == NULL) ? "(*no name)" : getstr(name);+    }+    default: return NULL;  /* not a closure */+  }+}+++LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {+  const char *name;+  TValue *val = NULL;  /* to avoid warnings */+  lua_lock(L);+  name = aux_upvalue(index2addr(L, funcindex), n, &val, NULL, NULL);+  if (name) {+    setobj2s(L, L->top, val);+    api_incr_top(L);+  }+  lua_unlock(L);+  return name;+}+++LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n) {+  const char *name;+  TValue *val = NULL;  /* to avoid warnings */+  CClosure *owner = NULL;+  UpVal *uv = NULL;+  StkId fi;+  lua_lock(L);+  fi = index2addr(L, funcindex);+  api_checknelems(L, 1);+  name = aux_upvalue(fi, n, &val, &owner, &uv);+  if (name) {+    L->top--;+    setobj(L, val, L->top);+    if (owner) { luaC_barrier(L, owner, L->top); }+    else if (uv) { luaC_upvalbarrier(L, uv); }+  }+  lua_unlock(L);+  return name;+}+++static UpVal **getupvalref (lua_State *L, int fidx, int n, LClosure **pf) {+  LClosure *f;+  StkId fi = index2addr(L, fidx);+  api_check(L, ttisLclosure(fi), "Lua function expected");+  f = clLvalue(fi);+  api_check(L, (1 <= n && n <= f->p->sizeupvalues), "invalid upvalue index");+  if (pf) *pf = f;+  return &f->upvals[n - 1];  /* get its upvalue pointer */+}+++LUA_API void *lua_upvalueid (lua_State *L, int fidx, int n) {+  StkId fi = index2addr(L, fidx);+  switch (ttype(fi)) {+    case LUA_TLCL: {  /* lua closure */+      return *getupvalref(L, fidx, n, NULL);+    }+    case LUA_TCCL: {  /* C closure */+      CClosure *f = clCvalue(fi);+      api_check(L, 1 <= n && n <= f->nupvalues, "invalid upvalue index");+      return &f->upvalue[n - 1];+    }+    default: {+      api_check(L, 0, "closure expected");+      return NULL;+    }+  }+}+++LUA_API void lua_upvaluejoin (lua_State *L, int fidx1, int n1,+                                            int fidx2, int n2) {+  LClosure *f1;+  UpVal **up1 = getupvalref(L, fidx1, n1, &f1);+  UpVal **up2 = getupvalref(L, fidx2, n2, NULL);+  luaC_upvdeccount(L, *up1);+  *up1 = *up2;+  (*up1)->refcount++;+  if (upisopen(*up1)) (*up1)->u.open.touched = 1;+  luaC_upvalbarrier(L, *up1);+}++

@@ -0,0 +1,24 @@+/*+** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $+** Auxiliary functions from Lua API+** See Copyright Notice in lua.h+*/++#ifndef lapi_h+#define lapi_h+++#include "llimits.h"+#include "lstate.h"++#define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \+				"stack overflow");}++#define adjustresults(L,nres) \+    { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }++#define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \+				  "not enough elements in the stack")+++#endif

@@ -0,0 +1,1043 @@+/*+** $Id: lauxlib.c,v 1.289.1.1 2017/04/19 17:20:42 roberto Exp $+** Auxiliary functions for building Lua libraries+** See Copyright Notice in lua.h+*/++#define lauxlib_c+#define LUA_LIB++#include "lprefix.h"+++#include <errno.h>+#include <stdarg.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>+++/*+** This file uses only the official API of Lua.+** Any function declared here could be written as an application function.+*/++#include "lua.h"++#include "lauxlib.h"+++/*+** {======================================================+** Traceback+** =======================================================+*/+++#define LEVELS1	10	/* size of the first part of the stack */+#define LEVELS2	11	/* size of the second part of the stack */++++/*+** search for 'objidx' in table at index -1.+** return 1 + string at top if find a good name.+*/+static int findfield (lua_State *L, int objidx, int level) {+  if (level == 0 || !lua_istable(L, -1))+    return 0;  /* not found */+  lua_pushnil(L);  /* start 'next' loop */+  while (lua_next(L, -2)) {  /* for each pair in table */+    if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */+      if (lua_rawequal(L, objidx, -1)) {  /* found object? */+        lua_pop(L, 1);  /* remove value (but keep name) */+        return 1;+      }+      else if (findfield(L, objidx, level - 1)) {  /* try recursively */+        lua_remove(L, -2);  /* remove table (but keep name) */+        lua_pushliteral(L, ".");+        lua_insert(L, -2);  /* place '.' between the two names */+        lua_concat(L, 3);+        return 1;+      }+    }+    lua_pop(L, 1);  /* remove value */+  }+  return 0;  /* not found */+}+++/*+** Search for a name for a function in all loaded modules+*/+static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {+  int top = lua_gettop(L);+  lua_getinfo(L, "f", ar);  /* push function */+  lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);+  if (findfield(L, top + 1, 2)) {+    const char *name = lua_tostring(L, -1);+    if (strncmp(name, "_G.", 3) == 0) {  /* name start with '_G.'? */+      lua_pushstring(L, name + 3);  /* push name without prefix */+      lua_remove(L, -2);  /* remove original name */+    }+    lua_copy(L, -1, top + 1);  /* move name to proper place */+    lua_pop(L, 2);  /* remove pushed values */+    return 1;+  }+  else {+    lua_settop(L, top);  /* remove function and global table */+    return 0;+  }+}+++static void pushfuncname (lua_State *L, lua_Debug *ar) {+  if (pushglobalfuncname(L, ar)) {  /* try first a global name */+    lua_pushfstring(L, "function '%s'", lua_tostring(L, -1));+    lua_remove(L, -2);  /* remove name */+  }+  else if (*ar->namewhat != '\0')  /* is there a name from code? */+    lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name);  /* use it */+  else if (*ar->what == 'm')  /* main? */+      lua_pushliteral(L, "main chunk");+  else if (*ar->what != 'C')  /* for Lua functions, use <file:line> */+    lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);+  else  /* nothing left... */+    lua_pushliteral(L, "?");+}+++static int lastlevel (lua_State *L) {+  lua_Debug ar;+  int li = 1, le = 1;+  /* find an upper bound */+  while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }+  /* do a binary search */+  while (li < le) {+    int m = (li + le)/2;+    if (lua_getstack(L, m, &ar)) li = m + 1;+    else le = m;+  }+  return le - 1;+}+++LUALIB_API void luaL_traceback (lua_State *L, lua_State *L1,+                                const char *msg, int level) {+  lua_Debug ar;+  int top = lua_gettop(L);+  int last = lastlevel(L1);+  int n1 = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1;+  if (msg)+    lua_pushfstring(L, "%s\n", msg);+  luaL_checkstack(L, 10, NULL);+  lua_pushliteral(L, "stack traceback:");+  while (lua_getstack(L1, level++, &ar)) {+    if (n1-- == 0) {  /* too many levels? */+      lua_pushliteral(L, "\n\t...");  /* add a '...' */+      level = last - LEVELS2 + 1;  /* and skip to last ones */+    }+    else {+      lua_getinfo(L1, "Slnt", &ar);+      lua_pushfstring(L, "\n\t%s:", ar.short_src);+      if (ar.currentline > 0)+        lua_pushfstring(L, "%d:", ar.currentline);+      lua_pushliteral(L, " in ");+      pushfuncname(L, &ar);+      if (ar.istailcall)+        lua_pushliteral(L, "\n\t(...tail calls...)");+      lua_concat(L, lua_gettop(L) - top);+    }+  }+  lua_concat(L, lua_gettop(L) - top);+}++/* }====================================================== */+++/*+** {======================================================+** Error-report functions+** =======================================================+*/++LUALIB_API int luaL_argerror (lua_State *L, int arg, const char *extramsg) {+  lua_Debug ar;+  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */+    return luaL_error(L, "bad argument #%d (%s)", arg, extramsg);+  lua_getinfo(L, "n", &ar);+  if (strcmp(ar.namewhat, "method") == 0) {+    arg--;  /* do not count 'self' */+    if (arg == 0)  /* error is in the self argument itself? */+      return luaL_error(L, "calling '%s' on bad self (%s)",+                           ar.name, extramsg);+  }+  if (ar.name == NULL)+    ar.name = (pushglobalfuncname(L, &ar)) ? lua_tostring(L, -1) : "?";+  return luaL_error(L, "bad argument #%d to '%s' (%s)",+                        arg, ar.name, extramsg);+}+++static int typeerror (lua_State *L, int arg, const char *tname) {+  const char *msg;+  const char *typearg;  /* name for the type of the actual argument */+  if (luaL_getmetafield(L, arg, "__name") == LUA_TSTRING)+    typearg = lua_tostring(L, -1);  /* use the given type name */+  else if (lua_type(L, arg) == LUA_TLIGHTUSERDATA)+    typearg = "light userdata";  /* special name for messages */+  else+    typearg = luaL_typename(L, arg);  /* standard name */+  msg = lua_pushfstring(L, "%s expected, got %s", tname, typearg);+  return luaL_argerror(L, arg, msg);+}+++static void tag_error (lua_State *L, int arg, int tag) {+  typeerror(L, arg, lua_typename(L, tag));+}+++/*+** The use of 'lua_pushfstring' ensures this function does not+** need reserved stack space when called.+*/+LUALIB_API void luaL_where (lua_State *L, int level) {+  lua_Debug ar;+  if (lua_getstack(L, level, &ar)) {  /* check function at level */+    lua_getinfo(L, "Sl", &ar);  /* get info about it */+    if (ar.currentline > 0) {  /* is there info? */+      lua_pushfstring(L, "%s:%d: ", ar.short_src, ar.currentline);+      return;+    }+  }+  lua_pushfstring(L, "");  /* else, no information available... */+}+++/*+** Again, the use of 'lua_pushvfstring' ensures this function does+** not need reserved stack space when called. (At worst, it generates+** an error with "stack overflow" instead of the given message.)+*/+LUALIB_API int luaL_error (lua_State *L, const char *fmt, ...) {+  va_list argp;+  va_start(argp, fmt);+  luaL_where(L, 1);+  lua_pushvfstring(L, fmt, argp);+  va_end(argp);+  lua_concat(L, 2);+  return lua_error(L);+}+++LUALIB_API int luaL_fileresult (lua_State *L, int stat, const char *fname) {+  int en = errno;  /* calls to Lua API may change this value */+  if (stat) {+    lua_pushboolean(L, 1);+    return 1;+  }+  else {+    lua_pushnil(L);+    if (fname)+      lua_pushfstring(L, "%s: %s", fname, strerror(en));+    else+      lua_pushstring(L, strerror(en));+    lua_pushinteger(L, en);+    return 3;+  }+}+++#if !defined(l_inspectstat)	/* { */++#if defined(LUA_USE_POSIX)++#include <sys/wait.h>++/*+** use appropriate macros to interpret 'pclose' return status+*/+#define l_inspectstat(stat,what)  \+   if (WIFEXITED(stat)) { stat = WEXITSTATUS(stat); } \+   else if (WIFSIGNALED(stat)) { stat = WTERMSIG(stat); what = "signal"; }++#else++#define l_inspectstat(stat,what)  /* no op */++#endif++#endif				/* } */+++LUALIB_API int luaL_execresult (lua_State *L, int stat) {+  const char *what = "exit";  /* type of termination */+  if (stat == -1)  /* error? */+    return luaL_fileresult(L, 0, NULL);+  else {+    l_inspectstat(stat, what);  /* interpret result */+    if (*what == 'e' && stat == 0)  /* successful termination? */+      lua_pushboolean(L, 1);+    else+      lua_pushnil(L);+    lua_pushstring(L, what);+    lua_pushinteger(L, stat);+    return 3;  /* return true/nil,what,code */+  }+}++/* }====================================================== */+++/*+** {======================================================+** Userdata's metatable manipulation+** =======================================================+*/++LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {+  if (luaL_getmetatable(L, tname) != LUA_TNIL)  /* name already in use? */+    return 0;  /* leave previous value on top, but return 0 */+  lua_pop(L, 1);+  lua_createtable(L, 0, 2);  /* create metatable */+  lua_pushstring(L, tname);+  lua_setfield(L, -2, "__name");  /* metatable.__name = tname */+  lua_pushvalue(L, -1);+  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */+  return 1;+}+++LUALIB_API void luaL_setmetatable (lua_State *L, const char *tname) {+  luaL_getmetatable(L, tname);+  lua_setmetatable(L, -2);+}+++LUALIB_API void *luaL_testudata (lua_State *L, int ud, const char *tname) {+  void *p = lua_touserdata(L, ud);+  if (p != NULL) {  /* value is a userdata? */+    if (lua_getmetatable(L, ud)) {  /* does it have a metatable? */+      luaL_getmetatable(L, tname);  /* get correct metatable */+      if (!lua_rawequal(L, -1, -2))  /* not the same? */+        p = NULL;  /* value is a userdata with wrong metatable */+      lua_pop(L, 2);  /* remove both metatables */+      return p;+    }+  }+  return NULL;  /* value is not a userdata with a metatable */+}+++LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {+  void *p = luaL_testudata(L, ud, tname);+  if (p == NULL) typeerror(L, ud, tname);+  return p;+}++/* }====================================================== */+++/*+** {======================================================+** Argument check functions+** =======================================================+*/++LUALIB_API int luaL_checkoption (lua_State *L, int arg, const char *def,+                                 const char *const lst[]) {+  const char *name = (def) ? luaL_optstring(L, arg, def) :+                             luaL_checkstring(L, arg);+  int i;+  for (i=0; lst[i]; i++)+    if (strcmp(lst[i], name) == 0)+      return i;+  return luaL_argerror(L, arg,+                       lua_pushfstring(L, "invalid option '%s'", name));+}+++/*+** Ensures the stack has at least 'space' extra slots, raising an error+** if it cannot fulfill the request. (The error handling needs a few+** extra slots to format the error message. In case of an error without+** this extra space, Lua will generate the same 'stack overflow' error,+** but without 'msg'.)+*/+LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) {+  if (!lua_checkstack(L, space)) {+    if (msg)+      luaL_error(L, "stack overflow (%s)", msg);+    else+      luaL_error(L, "stack overflow");+  }+}+++LUALIB_API void luaL_checktype (lua_State *L, int arg, int t) {+  if (lua_type(L, arg) != t)+    tag_error(L, arg, t);+}+++LUALIB_API void luaL_checkany (lua_State *L, int arg) {+  if (lua_type(L, arg) == LUA_TNONE)+    luaL_argerror(L, arg, "value expected");+}+++LUALIB_API const char *luaL_checklstring (lua_State *L, int arg, size_t *len) {+  const char *s = lua_tolstring(L, arg, len);+  if (!s) tag_error(L, arg, LUA_TSTRING);+  return s;+}+++LUALIB_API const char *luaL_optlstring (lua_State *L, int arg,+                                        const char *def, size_t *len) {+  if (lua_isnoneornil(L, arg)) {+    if (len)+      *len = (def ? strlen(def) : 0);+    return def;+  }+  else return luaL_checklstring(L, arg, len);+}+++LUALIB_API lua_Number luaL_checknumber (lua_State *L, int arg) {+  int isnum;+  lua_Number d = lua_tonumberx(L, arg, &isnum);+  if (!isnum)+    tag_error(L, arg, LUA_TNUMBER);+  return d;+}+++LUALIB_API lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number def) {+  return luaL_opt(L, luaL_checknumber, arg, def);+}+++static void interror (lua_State *L, int arg) {+  if (lua_isnumber(L, arg))+    luaL_argerror(L, arg, "number has no integer representation");+  else+    tag_error(L, arg, LUA_TNUMBER);+}+++LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int arg) {+  int isnum;+  lua_Integer d = lua_tointegerx(L, arg, &isnum);+  if (!isnum) {+    interror(L, arg);+  }+  return d;+}+++LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int arg,+                                                      lua_Integer def) {+  return luaL_opt(L, luaL_checkinteger, arg, def);+}++/* }====================================================== */+++/*+** {======================================================+** Generic Buffer manipulation+** =======================================================+*/++/* userdata to box arbitrary data */+typedef struct UBox {+  void *box;+  size_t bsize;+} UBox;+++static void *resizebox (lua_State *L, int idx, size_t newsize) {+  void *ud;+  lua_Alloc allocf = lua_getallocf(L, &ud);+  UBox *box = (UBox *)lua_touserdata(L, idx);+  void *temp = allocf(ud, box->box, box->bsize, newsize);+  if (temp == NULL && newsize > 0) {  /* allocation error? */+    resizebox(L, idx, 0);  /* free buffer */+    luaL_error(L, "not enough memory for buffer allocation");+  }+  box->box = temp;+  box->bsize = newsize;+  return temp;+}+++static int boxgc (lua_State *L) {+  resizebox(L, 1, 0);+  return 0;+}+++static void *newbox (lua_State *L, size_t newsize) {+  UBox *box = (UBox *)lua_newuserdata(L, sizeof(UBox));+  box->box = NULL;+  box->bsize = 0;+  if (luaL_newmetatable(L, "LUABOX")) {  /* creating metatable? */+    lua_pushcfunction(L, boxgc);+    lua_setfield(L, -2, "__gc");  /* metatable.__gc = boxgc */+  }+  lua_setmetatable(L, -2);+  return resizebox(L, -1, newsize);+}+++/*+** check whether buffer is using a userdata on the stack as a temporary+** buffer+*/+#define buffonstack(B)	((B)->b != (B)->initb)+++/*+** returns a pointer to a free area with at least 'sz' bytes+*/+LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) {+  lua_State *L = B->L;+  if (B->size - B->n < sz) {  /* not enough space? */+    char *newbuff;+    size_t newsize = B->size * 2;  /* double buffer size */+    if (newsize - B->n < sz)  /* not big enough? */+      newsize = B->n + sz;+    if (newsize < B->n || newsize - B->n < sz)+      luaL_error(L, "buffer too large");+    /* create larger buffer */+    if (buffonstack(B))+      newbuff = (char *)resizebox(L, -1, newsize);+    else {  /* no buffer yet */+      newbuff = (char *)newbox(L, newsize);+      memcpy(newbuff, B->b, B->n * sizeof(char));  /* copy original content */+    }+    B->b = newbuff;+    B->size = newsize;+  }+  return &B->b[B->n];+}+++LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {+  if (l > 0) {  /* avoid 'memcpy' when 's' can be NULL */+    char *b = luaL_prepbuffsize(B, l);+    memcpy(b, s, l * sizeof(char));+    luaL_addsize(B, l);+  }+}+++LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) {+  luaL_addlstring(B, s, strlen(s));+}+++LUALIB_API void luaL_pushresult (luaL_Buffer *B) {+  lua_State *L = B->L;+  lua_pushlstring(L, B->b, B->n);+  if (buffonstack(B)) {+    resizebox(L, -2, 0);  /* delete old buffer */+    lua_remove(L, -2);  /* remove its header from the stack */+  }+}+++LUALIB_API void luaL_pushresultsize (luaL_Buffer *B, size_t sz) {+  luaL_addsize(B, sz);+  luaL_pushresult(B);+}+++LUALIB_API void luaL_addvalue (luaL_Buffer *B) {+  lua_State *L = B->L;+  size_t l;+  const char *s = lua_tolstring(L, -1, &l);+  if (buffonstack(B))+    lua_insert(L, -2);  /* put value below buffer */+  luaL_addlstring(B, s, l);+  lua_remove(L, (buffonstack(B)) ? -2 : -1);  /* remove value */+}+++LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {+  B->L = L;+  B->b = B->initb;+  B->n = 0;+  B->size = LUAL_BUFFERSIZE;+}+++LUALIB_API char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz) {+  luaL_buffinit(L, B);+  return luaL_prepbuffsize(B, sz);+}++/* }====================================================== */+++/*+** {======================================================+** Reference system+** =======================================================+*/++/* index of free-list header */+#define freelist	0+++LUALIB_API int luaL_ref (lua_State *L, int t) {+  int ref;+  if (lua_isnil(L, -1)) {+    lua_pop(L, 1);  /* remove from stack */+    return LUA_REFNIL;  /* 'nil' has a unique fixed reference */+  }+  t = lua_absindex(L, t);+  lua_rawgeti(L, t, freelist);  /* get first free element */+  ref = (int)lua_tointeger(L, -1);  /* ref = t[freelist] */+  lua_pop(L, 1);  /* remove it from stack */+  if (ref != 0) {  /* any free element? */+    lua_rawgeti(L, t, ref);  /* remove it from list */+    lua_rawseti(L, t, freelist);  /* (t[freelist] = t[ref]) */+  }+  else  /* no free elements */+    ref = (int)lua_rawlen(L, t) + 1;  /* get a new reference */+  lua_rawseti(L, t, ref);+  return ref;+}+++LUALIB_API void luaL_unref (lua_State *L, int t, int ref) {+  if (ref >= 0) {+    t = lua_absindex(L, t);+    lua_rawgeti(L, t, freelist);+    lua_rawseti(L, t, ref);  /* t[ref] = t[freelist] */+    lua_pushinteger(L, ref);+    lua_rawseti(L, t, freelist);  /* t[freelist] = ref */+  }+}++/* }====================================================== */+++/*+** {======================================================+** Load functions+** =======================================================+*/++typedef struct LoadF {+  int n;  /* number of pre-read characters */+  FILE *f;  /* file being read */+  char buff[BUFSIZ];  /* area for reading file */+} LoadF;+++static const char *getF (lua_State *L, void *ud, size_t *size) {+  LoadF *lf = (LoadF *)ud;+  (void)L;  /* not used */+  if (lf->n > 0) {  /* are there pre-read characters to be read? */+    *size = lf->n;  /* return them (chars already in buffer) */+    lf->n = 0;  /* no more pre-read characters */+  }+  else {  /* read a block from file */+    /* 'fread' can return > 0 *and* set the EOF flag. If next call to+       'getF' called 'fread', it might still wait for user input.+       The next check avoids this problem. */+    if (feof(lf->f)) return NULL;+    *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);  /* read block */+  }+  return lf->buff;+}+++static int errfile (lua_State *L, const char *what, int fnameindex) {+  const char *serr = strerror(errno);+  const char *filename = lua_tostring(L, fnameindex) + 1;+  lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);+  lua_remove(L, fnameindex);+  return LUA_ERRFILE;+}+++static int skipBOM (LoadF *lf) {+  const char *p = "\xEF\xBB\xBF";  /* UTF-8 BOM mark */+  int c;+  lf->n = 0;+  do {+    c = getc(lf->f);+    if (c == EOF || c != *(const unsigned char *)p++) return c;+    lf->buff[lf->n++] = c;  /* to be read by the parser */+  } while (*p != '\0');+  lf->n = 0;  /* prefix matched; discard it */+  return getc(lf->f);  /* return next character */+}+++/*+** reads the first character of file 'f' and skips an optional BOM mark+** in its beginning plus its first line if it starts with '#'. Returns+** true if it skipped the first line.  In any case, '*cp' has the+** first "valid" character of the file (after the optional BOM and+** a first-line comment).+*/+static int skipcomment (LoadF *lf, int *cp) {+  int c = *cp = skipBOM(lf);+  if (c == '#') {  /* first line is a comment (Unix exec. file)? */+    do {  /* skip first line */+      c = getc(lf->f);+    } while (c != EOF && c != '\n');+    *cp = getc(lf->f);  /* skip end-of-line, if present */+    return 1;  /* there was a comment */+  }+  else return 0;  /* no comment */+}+++LUALIB_API int luaL_loadfilex (lua_State *L, const char *filename,+                                             const char *mode) {+  LoadF lf;+  int status, readstatus;+  int c;+  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */+  if (filename == NULL) {+    lua_pushliteral(L, "=stdin");+    lf.f = stdin;+  }+  else {+    lua_pushfstring(L, "@%s", filename);+    lf.f = fopen(filename, "r");+    if (lf.f == NULL) return errfile(L, "open", fnameindex);+  }+  if (skipcomment(&lf, &c))  /* read initial portion */+    lf.buff[lf.n++] = '\n';  /* add line to correct line numbers */+  if (c == LUA_SIGNATURE[0] && filename) {  /* binary file? */+    lf.f = freopen(filename, "rb", lf.f);  /* reopen in binary mode */+    if (lf.f == NULL) return errfile(L, "reopen", fnameindex);+    skipcomment(&lf, &c);  /* re-read initial portion */+  }+  if (c != EOF)+    lf.buff[lf.n++] = c;  /* 'c' is the first character of the stream */+  status = lua_load(L, getF, &lf, lua_tostring(L, -1), mode);+  readstatus = ferror(lf.f);+  if (filename) fclose(lf.f);  /* close file (even in case of errors) */+  if (readstatus) {+    lua_settop(L, fnameindex);  /* ignore results from 'lua_load' */+    return errfile(L, "read", fnameindex);+  }+  lua_remove(L, fnameindex);+  return status;+}+++typedef struct LoadS {+  const char *s;+  size_t size;+} LoadS;+++static const char *getS (lua_State *L, void *ud, size_t *size) {+  LoadS *ls = (LoadS *)ud;+  (void)L;  /* not used */+  if (ls->size == 0) return NULL;+  *size = ls->size;+  ls->size = 0;+  return ls->s;+}+++LUALIB_API int luaL_loadbufferx (lua_State *L, const char *buff, size_t size,+                                 const char *name, const char *mode) {+  LoadS ls;+  ls.s = buff;+  ls.size = size;+  return lua_load(L, getS, &ls, name, mode);+}+++LUALIB_API int luaL_loadstring (lua_State *L, const char *s) {+  return luaL_loadbuffer(L, s, strlen(s), s);+}++/* }====================================================== */++++LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {+  if (!lua_getmetatable(L, obj))  /* no metatable? */+    return LUA_TNIL;+  else {+    int tt;+    lua_pushstring(L, event);+    tt = lua_rawget(L, -2);+    if (tt == LUA_TNIL)  /* is metafield nil? */+      lua_pop(L, 2);  /* remove metatable and metafield */+    else+      lua_remove(L, -2);  /* remove only metatable */+    return tt;  /* return metafield type */+  }+}+++LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {+  obj = lua_absindex(L, obj);+  if (luaL_getmetafield(L, obj, event) == LUA_TNIL)  /* no metafield? */+    return 0;+  lua_pushvalue(L, obj);+  lua_call(L, 1, 1);+  return 1;+}+++LUALIB_API lua_Integer luaL_len (lua_State *L, int idx) {+  lua_Integer l;+  int isnum;+  lua_len(L, idx);+  l = lua_tointegerx(L, -1, &isnum);+  if (!isnum)+    luaL_error(L, "object length is not an integer");+  lua_pop(L, 1);  /* remove object */+  return l;+}+++LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {+  if (luaL_callmeta(L, idx, "__tostring")) {  /* metafield? */+    if (!lua_isstring(L, -1))+      luaL_error(L, "'__tostring' must return a string");+  }+  else {+    switch (lua_type(L, idx)) {+      case LUA_TNUMBER: {+        if (lua_isinteger(L, idx))+          lua_pushfstring(L, "%I", (LUAI_UACINT)lua_tointeger(L, idx));+        else+          lua_pushfstring(L, "%f", (LUAI_UACNUMBER)lua_tonumber(L, idx));+        break;+      }+      case LUA_TSTRING:+        lua_pushvalue(L, idx);+        break;+      case LUA_TBOOLEAN:+        lua_pushstring(L, (lua_toboolean(L, idx) ? "true" : "false"));+        break;+      case LUA_TNIL:+        lua_pushliteral(L, "nil");+        break;+      default: {+        int tt = luaL_getmetafield(L, idx, "__name");  /* try name */+        const char *kind = (tt == LUA_TSTRING) ? lua_tostring(L, -1) :+                                                 luaL_typename(L, idx);+        lua_pushfstring(L, "%s: %p", kind, lua_topointer(L, idx));+        if (tt != LUA_TNIL)+          lua_remove(L, -2);  /* remove '__name' */+        break;+      }+    }+  }+  return lua_tolstring(L, -1, len);+}+++/*+** {======================================================+** Compatibility with 5.1 module functions+** =======================================================+*/+#if defined(LUA_COMPAT_MODULE)++static const char *luaL_findtable (lua_State *L, int idx,+                                   const char *fname, int szhint) {+  const char *e;+  if (idx) lua_pushvalue(L, idx);+  do {+    e = strchr(fname, '.');+    if (e == NULL) e = fname + strlen(fname);+    lua_pushlstring(L, fname, e - fname);+    if (lua_rawget(L, -2) == LUA_TNIL) {  /* no such field? */+      lua_pop(L, 1);  /* remove this nil */+      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */+      lua_pushlstring(L, fname, e - fname);+      lua_pushvalue(L, -2);+      lua_settable(L, -4);  /* set new table into field */+    }+    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */+      lua_pop(L, 2);  /* remove table and value */+      return fname;  /* return problematic part of the name */+    }+    lua_remove(L, -2);  /* remove previous table */+    fname = e + 1;+  } while (*e == '.');+  return NULL;+}+++/*+** Count number of elements in a luaL_Reg list.+*/+static int libsize (const luaL_Reg *l) {+  int size = 0;+  for (; l && l->name; l++) size++;+  return size;+}+++/*+** Find or create a module table with a given name. The function+** first looks at the LOADED table and, if that fails, try a+** global variable with that name. In any case, leaves on the stack+** the module table.+*/+LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,+                                 int sizehint) {+  luaL_findtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE, 1);+  if (lua_getfield(L, -1, modname) != LUA_TTABLE) {  /* no LOADED[modname]? */+    lua_pop(L, 1);  /* remove previous result */+    /* try global variable (and create one if it does not exist) */+    lua_pushglobaltable(L);+    if (luaL_findtable(L, 0, modname, sizehint) != NULL)+      luaL_error(L, "name conflict for module '%s'", modname);+    lua_pushvalue(L, -1);+    lua_setfield(L, -3, modname);  /* LOADED[modname] = new table */+  }+  lua_remove(L, -2);  /* remove LOADED table */+}+++LUALIB_API void luaL_openlib (lua_State *L, const char *libname,+                               const luaL_Reg *l, int nup) {+  luaL_checkversion(L);+  if (libname) {+    luaL_pushmodule(L, libname, libsize(l));  /* get/create library table */+    lua_insert(L, -(nup + 1));  /* move library table to below upvalues */+  }+  if (l)+    luaL_setfuncs(L, l, nup);+  else+    lua_pop(L, nup);  /* remove upvalues */+}++#endif+/* }====================================================== */++/*+** set functions from list 'l' into table at top - 'nup'; each+** function gets the 'nup' elements at the top as upvalues.+** Returns with only the table at the stack.+*/+LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) {+  luaL_checkstack(L, nup, "too many upvalues");+  for (; l->name != NULL; l++) {  /* fill the table with given functions */+    int i;+    for (i = 0; i < nup; i++)  /* copy upvalues to the top */+      lua_pushvalue(L, -nup);+    lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */+    lua_setfield(L, -(nup + 2), l->name);+  }+  lua_pop(L, nup);  /* remove upvalues */+}+++/*+** ensure that stack[idx][fname] has a table and push that table+** into the stack+*/+LUALIB_API int luaL_getsubtable (lua_State *L, int idx, const char *fname) {+  if (lua_getfield(L, idx, fname) == LUA_TTABLE)+    return 1;  /* table already there */+  else {+    lua_pop(L, 1);  /* remove previous result */+    idx = lua_absindex(L, idx);+    lua_newtable(L);+    lua_pushvalue(L, -1);  /* copy to be left at top */+    lua_setfield(L, idx, fname);  /* assign new table to field */+    return 0;  /* false, because did not find table there */+  }+}+++/*+** Stripped-down 'require': After checking "loaded" table, calls 'openf'+** to open a module, registers the result in 'package.loaded' table and,+** if 'glb' is true, also registers the result in the global table.+** Leaves resulting module on the top.+*/+LUALIB_API void luaL_requiref (lua_State *L, const char *modname,+                               lua_CFunction openf, int glb) {+  luaL_getsubtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);+  lua_getfield(L, -1, modname);  /* LOADED[modname] */+  if (!lua_toboolean(L, -1)) {  /* package not already loaded? */+    lua_pop(L, 1);  /* remove field */+    lua_pushcfunction(L, openf);+    lua_pushstring(L, modname);  /* argument to open function */+    lua_call(L, 1, 1);  /* call 'openf' to open module */+    lua_pushvalue(L, -1);  /* make copy of module (call result) */+    lua_setfield(L, -3, modname);  /* LOADED[modname] = module */+  }+  lua_remove(L, -2);  /* remove LOADED table */+  if (glb) {+    lua_pushvalue(L, -1);  /* copy of module */+    lua_setglobal(L, modname);  /* _G[modname] = module */+  }+}+++LUALIB_API const char *luaL_gsub (lua_State *L, const char *s, const char *p,+                                                               const char *r) {+  const char *wild;+  size_t l = strlen(p);+  luaL_Buffer b;+  luaL_buffinit(L, &b);+  while ((wild = strstr(s, p)) != NULL) {+    luaL_addlstring(&b, s, wild - s);  /* push prefix */+    luaL_addstring(&b, r);  /* push replacement in place of pattern */+    s = wild + l;  /* continue after 'p' */+  }+  luaL_addstring(&b, s);  /* push last suffix */+  luaL_pushresult(&b);+  return lua_tostring(L, -1);+}+++static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {+  (void)ud; (void)osize;  /* not used */+  if (nsize == 0) {+    free(ptr);+    return NULL;+  }+  else+    return realloc(ptr, nsize);+}+++static int panic (lua_State *L) {+  lua_writestringerror("PANIC: unprotected error in call to Lua API (%s)\n",+                        lua_tostring(L, -1));+  return 0;  /* return to Lua to abort */+}+++LUALIB_API lua_State *luaL_newstate (void) {+  lua_State *L = lua_newstate(l_alloc, NULL);+  if (L) lua_atpanic(L, &panic);+  return L;+}+++LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {+  const lua_Number *v = lua_version(L);+  if (sz != LUAL_NUMSIZES)  /* check numeric types */+    luaL_error(L, "core and library have incompatible numeric types");+  if (v != lua_version(NULL))+    luaL_error(L, "multiple Lua VMs detected");+  else if (*v != ver)+    luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",+                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);+}+

@@ -0,0 +1,264 @@+/*+** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $+** Auxiliary functions for building Lua libraries+** See Copyright Notice in lua.h+*/+++#ifndef lauxlib_h+#define lauxlib_h+++#include <stddef.h>+#include <stdio.h>++#include "lua.h"++++/* extra error code for 'luaL_loadfilex' */+#define LUA_ERRFILE     (LUA_ERRERR+1)+++/* key, in the registry, for table of loaded modules */+#define LUA_LOADED_TABLE	"_LOADED"+++/* key, in the registry, for table of preloaded loaders */+#define LUA_PRELOAD_TABLE	"_PRELOAD"+++typedef struct luaL_Reg {+  const char *name;+  lua_CFunction func;+} luaL_Reg;+++#define LUAL_NUMSIZES	(sizeof(lua_Integer)*16 + sizeof(lua_Number))++LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz);+#define luaL_checkversion(L)  \+	  luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES)++LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);+LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg);+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg,+                                                          size_t *l);+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg,+                                          const char *def, size_t *l);+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg);+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def);++LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg);+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg,+                                          lua_Integer def);++LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);+LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t);+LUALIB_API void (luaL_checkany) (lua_State *L, int arg);++LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);+LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);++LUALIB_API void (luaL_where) (lua_State *L, int lvl);+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);++LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def,+                                   const char *const lst[]);++LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);++/* predefined references */+#define LUA_NOREF       (-2)+#define LUA_REFNIL      (-1)++LUALIB_API int (luaL_ref) (lua_State *L, int t);+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);++LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,+                                               const char *mode);++#define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)++LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,+                                   const char *name, const char *mode);+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);++LUALIB_API lua_State *(luaL_newstate) (void);++LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx);++LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,+                                                  const char *r);++LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);++LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);++LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,+                                  const char *msg, int level);++LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,+                                 lua_CFunction openf, int glb);++/*+** ===============================================================+** some useful macros+** ===============================================================+*/+++#define luaL_newlibtable(L,l)	\+  lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)++#define luaL_newlib(L,l)  \+  (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))++#define luaL_argcheck(L, cond,arg,extramsg)	\+		((void)((cond) || luaL_argerror(L, (arg), (extramsg))))+#define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))+#define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))++#define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))++#define luaL_dofile(L, fn) \+	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))++#define luaL_dostring(L, s) \+	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))++#define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))++#define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))++#define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)+++/*+** {======================================================+** Generic Buffer manipulation+** =======================================================+*/++typedef struct luaL_Buffer {+  char *b;  /* buffer address */+  size_t size;  /* buffer size */+  size_t n;  /* number of characters in buffer */+  lua_State *L;+  char initb[LUAL_BUFFERSIZE];  /* initial buffer */+} luaL_Buffer;+++#define luaL_addchar(B,c) \+  ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \+   ((B)->b[(B)->n++] = (c)))++#define luaL_addsize(B,s)	((B)->n += (s))++LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);++#define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)++/* }====================================================== */++++/*+** {======================================================+** File handles for IO library+** =======================================================+*/++/*+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and+** initial structure 'luaL_Stream' (it may contain other fields+** after that initial structure).+*/++#define LUA_FILEHANDLE          "FILE*"+++typedef struct luaL_Stream {+  FILE *f;  /* stream (NULL for incompletely created streams) */+  lua_CFunction closef;  /* to close stream (NULL for closed streams) */+} luaL_Stream;++/* }====================================================== */++++/* compatibility with old module system */+#if defined(LUA_COMPAT_MODULE)++LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,+                                   int sizehint);+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,+                                const luaL_Reg *l, int nup);++#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))++#endif+++/*+** {==================================================================+** "Abstraction Layer" for basic report of messages and errors+** ===================================================================+*/++/* print a string */+#if !defined(lua_writestring)+#define lua_writestring(s,l)   fwrite((s), sizeof(char), (l), stdout)+#endif++/* print a newline and flush the output */+#if !defined(lua_writeline)+#define lua_writeline()        (lua_writestring("\n", 1), fflush(stdout))+#endif++/* print an error message */+#if !defined(lua_writestringerror)+#define lua_writestringerror(s,p) \+        (fprintf(stderr, (s), (p)), fflush(stderr))+#endif++/* }================================================================== */+++/*+** {============================================================+** Compatibility with deprecated conversions+** =============================================================+*/+#if defined(LUA_COMPAT_APIINTCASTS)++#define luaL_checkunsigned(L,a)	((lua_Unsigned)luaL_checkinteger(L,a))+#define luaL_optunsigned(L,a,d)	\+	((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d)))++#define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))+#define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))++#define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))+#define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))++#endif+/* }============================================================ */++++#endif++

@@ -0,0 +1,498 @@+/*+** $Id: lbaselib.c,v 1.314.1.1 2017/04/19 17:39:34 roberto Exp $+** Basic library+** See Copyright Notice in lua.h+*/++#define lbaselib_c+#define LUA_LIB++#include "lprefix.h"+++#include <ctype.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"+++static int luaB_print (lua_State *L) {+  int n = lua_gettop(L);  /* number of arguments */+  int i;+  lua_getglobal(L, "tostring");+  for (i=1; i<=n; i++) {+    const char *s;+    size_t l;+    lua_pushvalue(L, -1);  /* function to be called */+    lua_pushvalue(L, i);   /* value to print */+    lua_call(L, 1, 1);+    s = lua_tolstring(L, -1, &l);  /* get result */+    if (s == NULL)+      return luaL_error(L, "'tostring' must return a string to 'print'");+    if (i>1) lua_writestring("\t", 1);+    lua_writestring(s, l);+    lua_pop(L, 1);  /* pop result */+  }+  lua_writeline();+  return 0;+}+++#define SPACECHARS	" \f\n\r\t\v"++static const char *b_str2int (const char *s, int base, lua_Integer *pn) {+  lua_Unsigned n = 0;+  int neg = 0;+  s += strspn(s, SPACECHARS);  /* skip initial spaces */+  if (*s == '-') { s++; neg = 1; }  /* handle signal */+  else if (*s == '+') s++;+  if (!isalnum((unsigned char)*s))  /* no digit? */+    return NULL;+  do {+    int digit = (isdigit((unsigned char)*s)) ? *s - '0'+                   : (toupper((unsigned char)*s) - 'A') + 10;+    if (digit >= base) return NULL;  /* invalid numeral */+    n = n * base + digit;+    s++;+  } while (isalnum((unsigned char)*s));+  s += strspn(s, SPACECHARS);  /* skip trailing spaces */+  *pn = (lua_Integer)((neg) ? (0u - n) : n);+  return s;+}+++static int luaB_tonumber (lua_State *L) {+  if (lua_isnoneornil(L, 2)) {  /* standard conversion? */+    luaL_checkany(L, 1);+    if (lua_type(L, 1) == LUA_TNUMBER) {  /* already a number? */+      lua_settop(L, 1);  /* yes; return it */+      return 1;+    }+    else {+      size_t l;+      const char *s = lua_tolstring(L, 1, &l);+      if (s != NULL && lua_stringtonumber(L, s) == l + 1)+        return 1;  /* successful conversion to number */+      /* else not a number */+    }+  }+  else {+    size_t l;+    const char *s;+    lua_Integer n = 0;  /* to avoid warnings */+    lua_Integer base = luaL_checkinteger(L, 2);+    luaL_checktype(L, 1, LUA_TSTRING);  /* no numbers as strings */+    s = lua_tolstring(L, 1, &l);+    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");+    if (b_str2int(s, (int)base, &n) == s + l) {+      lua_pushinteger(L, n);+      return 1;+    }  /* else not a number */+  }  /* else not a number */+  lua_pushnil(L);  /* not a number */+  return 1;+}+++static int luaB_error (lua_State *L) {+  int level = (int)luaL_optinteger(L, 2, 1);+  lua_settop(L, 1);+  if (lua_type(L, 1) == LUA_TSTRING && level > 0) {+    luaL_where(L, level);   /* add extra information */+    lua_pushvalue(L, 1);+    lua_concat(L, 2);+  }+  return lua_error(L);+}+++static int luaB_getmetatable (lua_State *L) {+  luaL_checkany(L, 1);+  if (!lua_getmetatable(L, 1)) {+    lua_pushnil(L);+    return 1;  /* no metatable */+  }+  luaL_getmetafield(L, 1, "__metatable");+  return 1;  /* returns either __metatable field (if present) or metatable */+}+++static int luaB_setmetatable (lua_State *L) {+  int t = lua_type(L, 2);+  luaL_checktype(L, 1, LUA_TTABLE);+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,+                    "nil or table expected");+  if (luaL_getmetafield(L, 1, "__metatable") != LUA_TNIL)+    return luaL_error(L, "cannot change a protected metatable");+  lua_settop(L, 2);+  lua_setmetatable(L, 1);+  return 1;+}+++static int luaB_rawequal (lua_State *L) {+  luaL_checkany(L, 1);+  luaL_checkany(L, 2);+  lua_pushboolean(L, lua_rawequal(L, 1, 2));+  return 1;+}+++static int luaB_rawlen (lua_State *L) {+  int t = lua_type(L, 1);+  luaL_argcheck(L, t == LUA_TTABLE || t == LUA_TSTRING, 1,+                   "table or string expected");+  lua_pushinteger(L, lua_rawlen(L, 1));+  return 1;+}+++static int luaB_rawget (lua_State *L) {+  luaL_checktype(L, 1, LUA_TTABLE);+  luaL_checkany(L, 2);+  lua_settop(L, 2);+  lua_rawget(L, 1);+  return 1;+}++static int luaB_rawset (lua_State *L) {+  luaL_checktype(L, 1, LUA_TTABLE);+  luaL_checkany(L, 2);+  luaL_checkany(L, 3);+  lua_settop(L, 3);+  lua_rawset(L, 1);+  return 1;+}+++static int luaB_collectgarbage (lua_State *L) {+  static const char *const opts[] = {"stop", "restart", "collect",+    "count", "step", "setpause", "setstepmul",+    "isrunning", NULL};+  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,+    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,+    LUA_GCISRUNNING};+  int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];+  int ex = (int)luaL_optinteger(L, 2, 0);+  int res = lua_gc(L, o, ex);+  switch (o) {+    case LUA_GCCOUNT: {+      int b = lua_gc(L, LUA_GCCOUNTB, 0);+      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));+      return 1;+    }+    case LUA_GCSTEP: case LUA_GCISRUNNING: {+      lua_pushboolean(L, res);+      return 1;+    }+    default: {+      lua_pushinteger(L, res);+      return 1;+    }+  }+}+++static int luaB_type (lua_State *L) {+  int t = lua_type(L, 1);+  luaL_argcheck(L, t != LUA_TNONE, 1, "value expected");+  lua_pushstring(L, lua_typename(L, t));+  return 1;+}+++static int pairsmeta (lua_State *L, const char *method, int iszero,+                      lua_CFunction iter) {+  luaL_checkany(L, 1);+  if (luaL_getmetafield(L, 1, method) == LUA_TNIL) {  /* no metamethod? */+    lua_pushcfunction(L, iter);  /* will return generator, */+    lua_pushvalue(L, 1);  /* state, */+    if (iszero) lua_pushinteger(L, 0);  /* and initial value */+    else lua_pushnil(L);+  }+  else {+    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */+    lua_call(L, 1, 3);  /* get 3 values from metamethod */+  }+  return 3;+}+++static int luaB_next (lua_State *L) {+  luaL_checktype(L, 1, LUA_TTABLE);+  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */+  if (lua_next(L, 1))+    return 2;+  else {+    lua_pushnil(L);+    return 1;+  }+}+++static int luaB_pairs (lua_State *L) {+  return pairsmeta(L, "__pairs", 0, luaB_next);+}+++/*+** Traversal function for 'ipairs'+*/+static int ipairsaux (lua_State *L) {+  lua_Integer i = luaL_checkinteger(L, 2) + 1;+  lua_pushinteger(L, i);+  return (lua_geti(L, 1, i) == LUA_TNIL) ? 1 : 2;+}+++/*+** 'ipairs' function. Returns 'ipairsaux', given "table", 0.+** (The given "table" may not be a table.)+*/+static int luaB_ipairs (lua_State *L) {+#if defined(LUA_COMPAT_IPAIRS)+  return pairsmeta(L, "__ipairs", 1, ipairsaux);+#else+  luaL_checkany(L, 1);+  lua_pushcfunction(L, ipairsaux);  /* iteration function */+  lua_pushvalue(L, 1);  /* state */+  lua_pushinteger(L, 0);  /* initial value */+  return 3;+#endif+}+++static int load_aux (lua_State *L, int status, int envidx) {+  if (status == LUA_OK) {+    if (envidx != 0) {  /* 'env' parameter? */+      lua_pushvalue(L, envidx);  /* environment for loaded function */+      if (!lua_setupvalue(L, -2, 1))  /* set it as 1st upvalue */+        lua_pop(L, 1);  /* remove 'env' if not used by previous call */+    }+    return 1;+  }+  else {  /* error (message is on top of the stack) */+    lua_pushnil(L);+    lua_insert(L, -2);  /* put before error message */+    return 2;  /* return nil plus error message */+  }+}+++static int luaB_loadfile (lua_State *L) {+  const char *fname = luaL_optstring(L, 1, NULL);+  const char *mode = luaL_optstring(L, 2, NULL);+  int env = (!lua_isnone(L, 3) ? 3 : 0);  /* 'env' index or 0 if no 'env' */+  int status = luaL_loadfilex(L, fname, mode);+  return load_aux(L, status, env);+}+++/*+** {======================================================+** Generic Read function+** =======================================================+*/+++/*+** reserved slot, above all arguments, to hold a copy of the returned+** string to avoid it being collected while parsed. 'load' has four+** optional arguments (chunk, source name, mode, and environment).+*/+#define RESERVEDSLOT	5+++/*+** Reader for generic 'load' function: 'lua_load' uses the+** stack for internal stuff, so the reader cannot change the+** stack top. Instead, it keeps its resulting string in a+** reserved slot inside the stack.+*/+static const char *generic_reader (lua_State *L, void *ud, size_t *size) {+  (void)(ud);  /* not used */+  luaL_checkstack(L, 2, "too many nested functions");+  lua_pushvalue(L, 1);  /* get function */+  lua_call(L, 0, 1);  /* call it */+  if (lua_isnil(L, -1)) {+    lua_pop(L, 1);  /* pop result */+    *size = 0;+    return NULL;+  }+  else if (!lua_isstring(L, -1))+    luaL_error(L, "reader function must return a string");+  lua_replace(L, RESERVEDSLOT);  /* save string in reserved slot */+  return lua_tolstring(L, RESERVEDSLOT, size);+}+++static int luaB_load (lua_State *L) {+  int status;+  size_t l;+  const char *s = lua_tolstring(L, 1, &l);+  const char *mode = luaL_optstring(L, 3, "bt");+  int env = (!lua_isnone(L, 4) ? 4 : 0);  /* 'env' index or 0 if no 'env' */+  if (s != NULL) {  /* loading a string? */+    const char *chunkname = luaL_optstring(L, 2, s);+    status = luaL_loadbufferx(L, s, l, chunkname, mode);+  }+  else {  /* loading from a reader function */+    const char *chunkname = luaL_optstring(L, 2, "=(load)");+    luaL_checktype(L, 1, LUA_TFUNCTION);+    lua_settop(L, RESERVEDSLOT);  /* create reserved slot */+    status = lua_load(L, generic_reader, NULL, chunkname, mode);+  }+  return load_aux(L, status, env);+}++/* }====================================================== */+++static int dofilecont (lua_State *L, int d1, lua_KContext d2) {+  (void)d1;  (void)d2;  /* only to match 'lua_Kfunction' prototype */+  return lua_gettop(L) - 1;+}+++static int luaB_dofile (lua_State *L) {+  const char *fname = luaL_optstring(L, 1, NULL);+  lua_settop(L, 1);+  if (luaL_loadfile(L, fname) != LUA_OK)+    return lua_error(L);+  lua_callk(L, 0, LUA_MULTRET, 0, dofilecont);+  return dofilecont(L, 0, 0);+}+++static int luaB_assert (lua_State *L) {+  if (lua_toboolean(L, 1))  /* condition is true? */+    return lua_gettop(L);  /* return all arguments */+  else {  /* error */+    luaL_checkany(L, 1);  /* there must be a condition */+    lua_remove(L, 1);  /* remove it */+    lua_pushliteral(L, "assertion failed!");  /* default message */+    lua_settop(L, 1);  /* leave only message (default if no other one) */+    return luaB_error(L);  /* call 'error' */+  }+}+++static int luaB_select (lua_State *L) {+  int n = lua_gettop(L);+  if (lua_type(L, 1) == LUA_TSTRING && *lua_tostring(L, 1) == '#') {+    lua_pushinteger(L, n-1);+    return 1;+  }+  else {+    lua_Integer i = luaL_checkinteger(L, 1);+    if (i < 0) i = n + i;+    else if (i > n) i = n;+    luaL_argcheck(L, 1 <= i, 1, "index out of range");+    return n - (int)i;+  }+}+++/*+** Continuation function for 'pcall' and 'xpcall'. Both functions+** already pushed a 'true' before doing the call, so in case of success+** 'finishpcall' only has to return everything in the stack minus+** 'extra' values (where 'extra' is exactly the number of items to be+** ignored).+*/+static int finishpcall (lua_State *L, int status, lua_KContext extra) {+  if (status != LUA_OK && status != LUA_YIELD) {  /* error? */+    lua_pushboolean(L, 0);  /* first result (false) */+    lua_pushvalue(L, -2);  /* error message */+    return 2;  /* return false, msg */+  }+  else+    return lua_gettop(L) - (int)extra;  /* return all results */+}+++static int luaB_pcall (lua_State *L) {+  int status;+  luaL_checkany(L, 1);+  lua_pushboolean(L, 1);  /* first result if no errors */+  lua_insert(L, 1);  /* put it in place */+  status = lua_pcallk(L, lua_gettop(L) - 2, LUA_MULTRET, 0, 0, finishpcall);+  return finishpcall(L, status, 0);+}+++/*+** Do a protected call with error handling. After 'lua_rotate', the+** stack will have <f, err, true, f, [args...]>; so, the function passes+** 2 to 'finishpcall' to skip the 2 first values when returning results.+*/+static int luaB_xpcall (lua_State *L) {+  int status;+  int n = lua_gettop(L);+  luaL_checktype(L, 2, LUA_TFUNCTION);  /* check error function */+  lua_pushboolean(L, 1);  /* first result */+  lua_pushvalue(L, 1);  /* function */+  lua_rotate(L, 3, 2);  /* move them below function's arguments */+  status = lua_pcallk(L, n - 2, LUA_MULTRET, 2, 2, finishpcall);+  return finishpcall(L, status, 2);+}+++static int luaB_tostring (lua_State *L) {+  luaL_checkany(L, 1);+  luaL_tolstring(L, 1, NULL);+  return 1;+}+++static const luaL_Reg base_funcs[] = {+  {"assert", luaB_assert},+  {"collectgarbage", luaB_collectgarbage},+  {"dofile", luaB_dofile},+  {"error", luaB_error},+  {"getmetatable", luaB_getmetatable},+  {"ipairs", luaB_ipairs},+  {"loadfile", luaB_loadfile},+  {"load", luaB_load},+#if defined(LUA_COMPAT_LOADSTRING)+  {"loadstring", luaB_load},+#endif+  {"next", luaB_next},+  {"pairs", luaB_pairs},+  {"pcall", luaB_pcall},+  {"print", luaB_print},+  {"rawequal", luaB_rawequal},+  {"rawlen", luaB_rawlen},+  {"rawget", luaB_rawget},+  {"rawset", luaB_rawset},+  {"select", luaB_select},+  {"setmetatable", luaB_setmetatable},+  {"tonumber", luaB_tonumber},+  {"tostring", luaB_tostring},+  {"type", luaB_type},+  {"xpcall", luaB_xpcall},+  /* placeholders */+  {"_G", NULL},+  {"_VERSION", NULL},+  {NULL, NULL}+};+++LUAMOD_API int luaopen_base (lua_State *L) {+  /* open lib into global table */+  lua_pushglobaltable(L);+  luaL_setfuncs(L, base_funcs, 0);+  /* set global _G */+  lua_pushvalue(L, -1);+  lua_setfield(L, -2, "_G");+  /* set global _VERSION */+  lua_pushliteral(L, LUA_VERSION);+  lua_setfield(L, -2, "_VERSION");+  return 1;+}+

@@ -0,0 +1,233 @@+/*+** $Id: lbitlib.c,v 1.30.1.1 2017/04/19 17:20:42 roberto Exp $+** Standard library for bitwise operations+** See Copyright Notice in lua.h+*/++#define lbitlib_c+#define LUA_LIB++#include "lprefix.h"+++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"+++#if defined(LUA_COMPAT_BITLIB)		/* { */+++#define pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))+#define checkunsigned(L,i)	((lua_Unsigned)luaL_checkinteger(L,i))+++/* number of bits to consider in a number */+#if !defined(LUA_NBITS)+#define LUA_NBITS	32+#endif+++/*+** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must+** be made in two parts to avoid problems when LUA_NBITS is equal to the+** number of bits in a lua_Unsigned.)+*/+#define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))+++/* macro to trim extra bits */+#define trim(x)		((x) & ALLONES)+++/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */+#define mask(n)		(~((ALLONES << 1) << ((n) - 1)))++++static lua_Unsigned andaux (lua_State *L) {+  int i, n = lua_gettop(L);+  lua_Unsigned r = ~(lua_Unsigned)0;+  for (i = 1; i <= n; i++)+    r &= checkunsigned(L, i);+  return trim(r);+}+++static int b_and (lua_State *L) {+  lua_Unsigned r = andaux(L);+  pushunsigned(L, r);+  return 1;+}+++static int b_test (lua_State *L) {+  lua_Unsigned r = andaux(L);+  lua_pushboolean(L, r != 0);+  return 1;+}+++static int b_or (lua_State *L) {+  int i, n = lua_gettop(L);+  lua_Unsigned r = 0;+  for (i = 1; i <= n; i++)+    r |= checkunsigned(L, i);+  pushunsigned(L, trim(r));+  return 1;+}+++static int b_xor (lua_State *L) {+  int i, n = lua_gettop(L);+  lua_Unsigned r = 0;+  for (i = 1; i <= n; i++)+    r ^= checkunsigned(L, i);+  pushunsigned(L, trim(r));+  return 1;+}+++static int b_not (lua_State *L) {+  lua_Unsigned r = ~checkunsigned(L, 1);+  pushunsigned(L, trim(r));+  return 1;+}+++static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {+  if (i < 0) {  /* shift right? */+    i = -i;+    r = trim(r);+    if (i >= LUA_NBITS) r = 0;+    else r >>= i;+  }+  else {  /* shift left */+    if (i >= LUA_NBITS) r = 0;+    else r <<= i;+    r = trim(r);+  }+  pushunsigned(L, r);+  return 1;+}+++static int b_lshift (lua_State *L) {+  return b_shift(L, checkunsigned(L, 1), luaL_checkinteger(L, 2));+}+++static int b_rshift (lua_State *L) {+  return b_shift(L, checkunsigned(L, 1), -luaL_checkinteger(L, 2));+}+++static int b_arshift (lua_State *L) {+  lua_Unsigned r = checkunsigned(L, 1);+  lua_Integer i = luaL_checkinteger(L, 2);+  if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))+    return b_shift(L, r, -i);+  else {  /* arithmetic shift for 'negative' number */+    if (i >= LUA_NBITS) r = ALLONES;+    else+      r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i));  /* add signal bit */+    pushunsigned(L, r);+    return 1;+  }+}+++static int b_rot (lua_State *L, lua_Integer d) {+  lua_Unsigned r = checkunsigned(L, 1);+  int i = d & (LUA_NBITS - 1);  /* i = d % NBITS */+  r = trim(r);+  if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */+    r = (r << i) | (r >> (LUA_NBITS - i));+  pushunsigned(L, trim(r));+  return 1;+}+++static int b_lrot (lua_State *L) {+  return b_rot(L, luaL_checkinteger(L, 2));+}+++static int b_rrot (lua_State *L) {+  return b_rot(L, -luaL_checkinteger(L, 2));+}+++/*+** get field and width arguments for field-manipulation functions,+** checking whether they are valid.+** ('luaL_error' called without 'return' to avoid later warnings about+** 'width' being used uninitialized.)+*/+static int fieldargs (lua_State *L, int farg, int *width) {+  lua_Integer f = luaL_checkinteger(L, farg);+  lua_Integer w = luaL_optinteger(L, farg + 1, 1);+  luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");+  luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");+  if (f + w > LUA_NBITS)+    luaL_error(L, "trying to access non-existent bits");+  *width = (int)w;+  return (int)f;+}+++static int b_extract (lua_State *L) {+  int w;+  lua_Unsigned r = trim(checkunsigned(L, 1));+  int f = fieldargs(L, 2, &w);+  r = (r >> f) & mask(w);+  pushunsigned(L, r);+  return 1;+}+++static int b_replace (lua_State *L) {+  int w;+  lua_Unsigned r = trim(checkunsigned(L, 1));+  lua_Unsigned v = trim(checkunsigned(L, 2));+  int f = fieldargs(L, 3, &w);+  lua_Unsigned m = mask(w);+  r = (r & ~(m << f)) | ((v & m) << f);+  pushunsigned(L, r);+  return 1;+}+++static const luaL_Reg bitlib[] = {+  {"arshift", b_arshift},+  {"band", b_and},+  {"bnot", b_not},+  {"bor", b_or},+  {"bxor", b_xor},+  {"btest", b_test},+  {"extract", b_extract},+  {"lrotate", b_lrot},+  {"lshift", b_lshift},+  {"replace", b_replace},+  {"rrotate", b_rrot},+  {"rshift", b_rshift},+  {NULL, NULL}+};++++LUAMOD_API int luaopen_bit32 (lua_State *L) {+  luaL_newlib(L, bitlib);+  return 1;+}+++#else					/* }{ */+++LUAMOD_API int luaopen_bit32 (lua_State *L) {+  return luaL_error(L, "library 'bit32' has been deprecated");+}++#endif					/* } */

@@ -0,0 +1,1203 @@+/*+** $Id: lcode.c,v 2.112.1.1 2017/04/19 17:20:42 roberto Exp $+** Code generator for Lua+** See Copyright Notice in lua.h+*/++#define lcode_c+#define LUA_CORE++#include "lprefix.h"+++#include <math.h>+#include <stdlib.h>++#include "lua.h"++#include "lcode.h"+#include "ldebug.h"+#include "ldo.h"+#include "lgc.h"+#include "llex.h"+#include "lmem.h"+#include "lobject.h"+#include "lopcodes.h"+#include "lparser.h"+#include "lstring.h"+#include "ltable.h"+#include "lvm.h"+++/* Maximum number of registers in a Lua function (must fit in 8 bits) */+#define MAXREGS		255+++#define hasjumps(e)	((e)->t != (e)->f)+++/*+** If expression is a numeric constant, fills 'v' with its value+** and returns 1. Otherwise, returns 0.+*/+static int tonumeral(const expdesc *e, TValue *v) {+  if (hasjumps(e))+    return 0;  /* not a numeral */+  switch (e->k) {+    case VKINT:+      if (v) setivalue(v, e->u.ival);+      return 1;+    case VKFLT:+      if (v) setfltvalue(v, e->u.nval);+      return 1;+    default: return 0;+  }+}+++/*+** Create a OP_LOADNIL instruction, but try to optimize: if the previous+** instruction is also OP_LOADNIL and ranges are compatible, adjust+** range of previous instruction instead of emitting a new one. (For+** instance, 'local a; local b' will generate a single opcode.)+*/+void luaK_nil (FuncState *fs, int from, int n) {+  Instruction *previous;+  int l = from + n - 1;  /* last register to set nil */+  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */+    previous = &fs->f->code[fs->pc-1];+    if (GET_OPCODE(*previous) == OP_LOADNIL) {  /* previous is LOADNIL? */+      int pfrom = GETARG_A(*previous);  /* get previous range */+      int pl = pfrom + GETARG_B(*previous);+      if ((pfrom <= from && from <= pl + 1) ||+          (from <= pfrom && pfrom <= l + 1)) {  /* can connect both? */+        if (pfrom < from) from = pfrom;  /* from = min(from, pfrom) */+        if (pl > l) l = pl;  /* l = max(l, pl) */+        SETARG_A(*previous, from);+        SETARG_B(*previous, l - from);+        return;+      }+    }  /* else go through */+  }+  luaK_codeABC(fs, OP_LOADNIL, from, n - 1, 0);  /* else no optimization */+}+++/*+** Gets the destination address of a jump instruction. Used to traverse+** a list of jumps.+*/+static int getjump (FuncState *fs, int pc) {+  int offset = GETARG_sBx(fs->f->code[pc]);+  if (offset == NO_JUMP)  /* point to itself represents end of list */+    return NO_JUMP;  /* end of list */+  else+    return (pc+1)+offset;  /* turn offset into absolute position */+}+++/*+** Fix jump instruction at position 'pc' to jump to 'dest'.+** (Jump addresses are relative in Lua)+*/+static void fixjump (FuncState *fs, int pc, int dest) {+  Instruction *jmp = &fs->f->code[pc];+  int offset = dest - (pc + 1);+  lua_assert(dest != NO_JUMP);+  if (abs(offset) > MAXARG_sBx)+    luaX_syntaxerror(fs->ls, "control structure too long");+  SETARG_sBx(*jmp, offset);+}+++/*+** Concatenate jump-list 'l2' into jump-list 'l1'+*/+void luaK_concat (FuncState *fs, int *l1, int l2) {+  if (l2 == NO_JUMP) return;  /* nothing to concatenate? */+  else if (*l1 == NO_JUMP)  /* no original list? */+    *l1 = l2;  /* 'l1' points to 'l2' */+  else {+    int list = *l1;+    int next;+    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */+      list = next;+    fixjump(fs, list, l2);  /* last element links to 'l2' */+  }+}+++/*+** Create a jump instruction and return its position, so its destination+** can be fixed later (with 'fixjump'). If there are jumps to+** this position (kept in 'jpc'), link them all together so that+** 'patchlistaux' will fix all them directly to the final destination.+*/+int luaK_jump (FuncState *fs) {+  int jpc = fs->jpc;  /* save list of jumps to here */+  int j;+  fs->jpc = NO_JUMP;  /* no more jumps to here */+  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);+  luaK_concat(fs, &j, jpc);  /* keep them on hold */+  return j;+}+++/*+** Code a 'return' instruction+*/+void luaK_ret (FuncState *fs, int first, int nret) {+  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);+}+++/*+** Code a "conditional jump", that is, a test or comparison opcode+** followed by a jump. Return jump position.+*/+static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {+  luaK_codeABC(fs, op, A, B, C);+  return luaK_jump(fs);+}+++/*+** returns current 'pc' and marks it as a jump target (to avoid wrong+** optimizations with consecutive instructions not in the same basic block).+*/+int luaK_getlabel (FuncState *fs) {+  fs->lasttarget = fs->pc;+  return fs->pc;+}+++/*+** Returns the position of the instruction "controlling" a given+** jump (that is, its condition), or the jump itself if it is+** unconditional.+*/+static Instruction *getjumpcontrol (FuncState *fs, int pc) {+  Instruction *pi = &fs->f->code[pc];+  if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1))))+    return pi-1;+  else+    return pi;+}+++/*+** Patch destination register for a TESTSET instruction.+** If instruction in position 'node' is not a TESTSET, return 0 ("fails").+** Otherwise, if 'reg' is not 'NO_REG', set it as the destination+** register. Otherwise, change instruction to a simple 'TEST' (produces+** no register value)+*/+static int patchtestreg (FuncState *fs, int node, int reg) {+  Instruction *i = getjumpcontrol(fs, node);+  if (GET_OPCODE(*i) != OP_TESTSET)+    return 0;  /* cannot patch other instructions */+  if (reg != NO_REG && reg != GETARG_B(*i))+    SETARG_A(*i, reg);+  else {+     /* no register to put value or register already has the value;+        change instruction to simple test */+    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));+  }+  return 1;+}+++/*+** Traverse a list of tests ensuring no one produces a value+*/+static void removevalues (FuncState *fs, int list) {+  for (; list != NO_JUMP; list = getjump(fs, list))+      patchtestreg(fs, list, NO_REG);+}+++/*+** Traverse a list of tests, patching their destination address and+** registers: tests producing values jump to 'vtarget' (and put their+** values in 'reg'), other tests jump to 'dtarget'.+*/+static void patchlistaux (FuncState *fs, int list, int vtarget, int reg,+                          int dtarget) {+  while (list != NO_JUMP) {+    int next = getjump(fs, list);+    if (patchtestreg(fs, list, reg))+      fixjump(fs, list, vtarget);+    else+      fixjump(fs, list, dtarget);  /* jump to default target */+    list = next;+  }+}+++/*+** Ensure all pending jumps to current position are fixed (jumping+** to current position with no values) and reset list of pending+** jumps+*/+static void dischargejpc (FuncState *fs) {+  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);+  fs->jpc = NO_JUMP;+}+++/*+** Add elements in 'list' to list of pending jumps to "here"+** (current position)+*/+void luaK_patchtohere (FuncState *fs, int list) {+  luaK_getlabel(fs);  /* mark "here" as a jump target */+  luaK_concat(fs, &fs->jpc, list);+}+++/*+** Path all jumps in 'list' to jump to 'target'.+** (The assert means that we cannot fix a jump to a forward address+** because we only know addresses once code is generated.)+*/+void luaK_patchlist (FuncState *fs, int list, int target) {+  if (target == fs->pc)  /* 'target' is current position? */+    luaK_patchtohere(fs, list);  /* add list to pending jumps */+  else {+    lua_assert(target < fs->pc);+    patchlistaux(fs, list, target, NO_REG, target);+  }+}+++/*+** Path all jumps in 'list' to close upvalues up to given 'level'+** (The assertion checks that jumps either were closing nothing+** or were closing higher levels, from inner blocks.)+*/+void luaK_patchclose (FuncState *fs, int list, int level) {+  level++;  /* argument is +1 to reserve 0 as non-op */+  for (; list != NO_JUMP; list = getjump(fs, list)) {+    lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&+                (GETARG_A(fs->f->code[list]) == 0 ||+                 GETARG_A(fs->f->code[list]) >= level));+    SETARG_A(fs->f->code[list], level);+  }+}+++/*+** Emit instruction 'i', checking for array sizes and saving also its+** line information. Return 'i' position.+*/+static int luaK_code (FuncState *fs, Instruction i) {+  Proto *f = fs->f;+  dischargejpc(fs);  /* 'pc' will change */+  /* put new instruction in code array */+  luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction,+                  MAX_INT, "opcodes");+  f->code[fs->pc] = i;+  /* save corresponding line information */+  luaM_growvector(fs->ls->L, f->lineinfo, fs->pc, f->sizelineinfo, int,+                  MAX_INT, "opcodes");+  f->lineinfo[fs->pc] = fs->ls->lastline;+  return fs->pc++;+}+++/*+** Format and emit an 'iABC' instruction. (Assertions check consistency+** of parameters versus opcode.)+*/+int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) {+  lua_assert(getOpMode(o) == iABC);+  lua_assert(getBMode(o) != OpArgN || b == 0);+  lua_assert(getCMode(o) != OpArgN || c == 0);+  lua_assert(a <= MAXARG_A && b <= MAXARG_B && c <= MAXARG_C);+  return luaK_code(fs, CREATE_ABC(o, a, b, c));+}+++/*+** Format and emit an 'iABx' instruction.+*/+int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) {+  lua_assert(getOpMode(o) == iABx || getOpMode(o) == iAsBx);+  lua_assert(getCMode(o) == OpArgN);+  lua_assert(a <= MAXARG_A && bc <= MAXARG_Bx);+  return luaK_code(fs, CREATE_ABx(o, a, bc));+}+++/*+** Emit an "extra argument" instruction (format 'iAx')+*/+static int codeextraarg (FuncState *fs, int a) {+  lua_assert(a <= MAXARG_Ax);+  return luaK_code(fs, CREATE_Ax(OP_EXTRAARG, a));+}+++/*+** Emit a "load constant" instruction, using either 'OP_LOADK'+** (if constant index 'k' fits in 18 bits) or an 'OP_LOADKX'+** instruction with "extra argument".+*/+int luaK_codek (FuncState *fs, int reg, int k) {+  if (k <= MAXARG_Bx)+    return luaK_codeABx(fs, OP_LOADK, reg, k);+  else {+    int p = luaK_codeABx(fs, OP_LOADKX, reg, 0);+    codeextraarg(fs, k);+    return p;+  }+}+++/*+** Check register-stack level, keeping track of its maximum size+** in field 'maxstacksize'+*/+void luaK_checkstack (FuncState *fs, int n) {+  int newstack = fs->freereg + n;+  if (newstack > fs->f->maxstacksize) {+    if (newstack >= MAXREGS)+      luaX_syntaxerror(fs->ls,+        "function or expression needs too many registers");+    fs->f->maxstacksize = cast_byte(newstack);+  }+}+++/*+** Reserve 'n' registers in register stack+*/+void luaK_reserveregs (FuncState *fs, int n) {+  luaK_checkstack(fs, n);+  fs->freereg += n;+}+++/*+** Free register 'reg', if it is neither a constant index nor+** a local variable.+)+*/+static void freereg (FuncState *fs, int reg) {+  if (!ISK(reg) && reg >= fs->nactvar) {+    fs->freereg--;+    lua_assert(reg == fs->freereg);+  }+}+++/*+** Free register used by expression 'e' (if any)+*/+static void freeexp (FuncState *fs, expdesc *e) {+  if (e->k == VNONRELOC)+    freereg(fs, e->u.info);+}+++/*+** Free registers used by expressions 'e1' and 'e2' (if any) in proper+** order.+*/+static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) {+  int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1;+  int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1;+  if (r1 > r2) {+    freereg(fs, r1);+    freereg(fs, r2);+  }+  else {+    freereg(fs, r2);+    freereg(fs, r1);+  }+}+++/*+** Add constant 'v' to prototype's list of constants (field 'k').+** Use scanner's table to cache position of constants in constant list+** and try to reuse constants. Because some values should not be used+** as keys (nil cannot be a key, integer keys can collapse with float+** keys), the caller must provide a useful 'key' for indexing the cache.+*/+static int addk (FuncState *fs, TValue *key, TValue *v) {+  lua_State *L = fs->ls->L;+  Proto *f = fs->f;+  TValue *idx = luaH_set(L, fs->ls->h, key);  /* index scanner table */+  int k, oldsize;+  if (ttisinteger(idx)) {  /* is there an index there? */+    k = cast_int(ivalue(idx));+    /* correct value? (warning: must distinguish floats from integers!) */+    if (k < fs->nk && ttype(&f->k[k]) == ttype(v) &&+                      luaV_rawequalobj(&f->k[k], v))+      return k;  /* reuse index */+  }+  /* constant not found; create a new entry */+  oldsize = f->sizek;+  k = fs->nk;+  /* numerical value does not need GC barrier;+     table has no metatable, so it does not need to invalidate cache */+  setivalue(idx, k);+  luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");+  while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);+  setobj(L, &f->k[k], v);+  fs->nk++;+  luaC_barrier(L, f, v);+  return k;+}+++/*+** Add a string to list of constants and return its index.+*/+int luaK_stringK (FuncState *fs, TString *s) {+  TValue o;+  setsvalue(fs->ls->L, &o, s);+  return addk(fs, &o, &o);  /* use string itself as key */+}+++/*+** Add an integer to list of constants and return its index.+** Integers use userdata as keys to avoid collision with floats with+** same value; conversion to 'void*' is used only for hashing, so there+** are no "precision" problems.+*/+int luaK_intK (FuncState *fs, lua_Integer n) {+  TValue k, o;+  setpvalue(&k, cast(void*, cast(size_t, n)));+  setivalue(&o, n);+  return addk(fs, &k, &o);+}++/*+** Add a float to list of constants and return its index.+*/+static int luaK_numberK (FuncState *fs, lua_Number r) {+  TValue o;+  setfltvalue(&o, r);+  return addk(fs, &o, &o);  /* use number itself as key */+}+++/*+** Add a boolean to list of constants and return its index.+*/+static int boolK (FuncState *fs, int b) {+  TValue o;+  setbvalue(&o, b);+  return addk(fs, &o, &o);  /* use boolean itself as key */+}+++/*+** Add nil to list of constants and return its index.+*/+static int nilK (FuncState *fs) {+  TValue k, v;+  setnilvalue(&v);+  /* cannot use nil as key; instead use table itself to represent nil */+  sethvalue(fs->ls->L, &k, fs->ls->h);+  return addk(fs, &k, &v);+}+++/*+** Fix an expression to return the number of results 'nresults'.+** Either 'e' is a multi-ret expression (function call or vararg)+** or 'nresults' is LUA_MULTRET (as any expression can satisfy that).+*/+void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {+  if (e->k == VCALL) {  /* expression is an open function call? */+    SETARG_C(getinstruction(fs, e), nresults + 1);+  }+  else if (e->k == VVARARG) {+    Instruction *pc = &getinstruction(fs, e);+    SETARG_B(*pc, nresults + 1);+    SETARG_A(*pc, fs->freereg);+    luaK_reserveregs(fs, 1);+  }+  else lua_assert(nresults == LUA_MULTRET);+}+++/*+** Fix an expression to return one result.+** If expression is not a multi-ret expression (function call or+** vararg), it already returns one result, so nothing needs to be done.+** Function calls become VNONRELOC expressions (as its result comes+** fixed in the base register of the call), while vararg expressions+** become VRELOCABLE (as OP_VARARG puts its results where it wants).+** (Calls are created returning one result, so that does not need+** to be fixed.)+*/+void luaK_setoneret (FuncState *fs, expdesc *e) {+  if (e->k == VCALL) {  /* expression is an open function call? */+    /* already returns 1 value */+    lua_assert(GETARG_C(getinstruction(fs, e)) == 2);+    e->k = VNONRELOC;  /* result has fixed position */+    e->u.info = GETARG_A(getinstruction(fs, e));+  }+  else if (e->k == VVARARG) {+    SETARG_B(getinstruction(fs, e), 2);+    e->k = VRELOCABLE;  /* can relocate its simple result */+  }+}+++/*+** Ensure that expression 'e' is not a variable.+*/+void luaK_dischargevars (FuncState *fs, expdesc *e) {+  switch (e->k) {+    case VLOCAL: {  /* already in a register */+      e->k = VNONRELOC;  /* becomes a non-relocatable value */+      break;+    }+    case VUPVAL: {  /* move value to some (pending) register */+      e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0);+      e->k = VRELOCABLE;+      break;+    }+    case VINDEXED: {+      OpCode op;+      freereg(fs, e->u.ind.idx);+      if (e->u.ind.vt == VLOCAL) {  /* is 't' in a register? */+        freereg(fs, e->u.ind.t);+        op = OP_GETTABLE;+      }+      else {+        lua_assert(e->u.ind.vt == VUPVAL);+        op = OP_GETTABUP;  /* 't' is in an upvalue */+      }+      e->u.info = luaK_codeABC(fs, op, 0, e->u.ind.t, e->u.ind.idx);+      e->k = VRELOCABLE;+      break;+    }+    case VVARARG: case VCALL: {+      luaK_setoneret(fs, e);+      break;+    }+    default: break;  /* there is one value available (somewhere) */+  }+}+++/*+** Ensures expression value is in register 'reg' (and therefore+** 'e' will become a non-relocatable expression).+*/+static void discharge2reg (FuncState *fs, expdesc *e, int reg) {+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VNIL: {+      luaK_nil(fs, reg, 1);+      break;+    }+    case VFALSE: case VTRUE: {+      luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0);+      break;+    }+    case VK: {+      luaK_codek(fs, reg, e->u.info);+      break;+    }+    case VKFLT: {+      luaK_codek(fs, reg, luaK_numberK(fs, e->u.nval));+      break;+    }+    case VKINT: {+      luaK_codek(fs, reg, luaK_intK(fs, e->u.ival));+      break;+    }+    case VRELOCABLE: {+      Instruction *pc = &getinstruction(fs, e);+      SETARG_A(*pc, reg);  /* instruction will put result in 'reg' */+      break;+    }+    case VNONRELOC: {+      if (reg != e->u.info)+        luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0);+      break;+    }+    default: {+      lua_assert(e->k == VJMP);+      return;  /* nothing to do... */+    }+  }+  e->u.info = reg;+  e->k = VNONRELOC;+}+++/*+** Ensures expression value is in any register.+*/+static void discharge2anyreg (FuncState *fs, expdesc *e) {+  if (e->k != VNONRELOC) {  /* no fixed register yet? */+    luaK_reserveregs(fs, 1);  /* get a register */+    discharge2reg(fs, e, fs->freereg-1);  /* put value there */+  }+}+++static int code_loadbool (FuncState *fs, int A, int b, int jump) {+  luaK_getlabel(fs);  /* those instructions may be jump targets */+  return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump);+}+++/*+** check whether list has any jump that do not produce a value+** or produce an inverted value+*/+static int need_value (FuncState *fs, int list) {+  for (; list != NO_JUMP; list = getjump(fs, list)) {+    Instruction i = *getjumpcontrol(fs, list);+    if (GET_OPCODE(i) != OP_TESTSET) return 1;+  }+  return 0;  /* not found */+}+++/*+** Ensures final expression result (including results from its jump+** lists) is in register 'reg'.+** If expression has jumps, need to patch these jumps either to+** its final position or to "load" instructions (for those tests+** that do not produce values).+*/+static void exp2reg (FuncState *fs, expdesc *e, int reg) {+  discharge2reg(fs, e, reg);+  if (e->k == VJMP)  /* expression itself is a test? */+    luaK_concat(fs, &e->t, e->u.info);  /* put this jump in 't' list */+  if (hasjumps(e)) {+    int final;  /* position after whole expression */+    int p_f = NO_JUMP;  /* position of an eventual LOAD false */+    int p_t = NO_JUMP;  /* position of an eventual LOAD true */+    if (need_value(fs, e->t) || need_value(fs, e->f)) {+      int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs);+      p_f = code_loadbool(fs, reg, 0, 1);+      p_t = code_loadbool(fs, reg, 1, 0);+      luaK_patchtohere(fs, fj);+    }+    final = luaK_getlabel(fs);+    patchlistaux(fs, e->f, final, reg, p_f);+    patchlistaux(fs, e->t, final, reg, p_t);+  }+  e->f = e->t = NO_JUMP;+  e->u.info = reg;+  e->k = VNONRELOC;+}+++/*+** Ensures final expression result (including results from its jump+** lists) is in next available register.+*/+void luaK_exp2nextreg (FuncState *fs, expdesc *e) {+  luaK_dischargevars(fs, e);+  freeexp(fs, e);+  luaK_reserveregs(fs, 1);+  exp2reg(fs, e, fs->freereg - 1);+}+++/*+** Ensures final expression result (including results from its jump+** lists) is in some (any) register and return that register.+*/+int luaK_exp2anyreg (FuncState *fs, expdesc *e) {+  luaK_dischargevars(fs, e);+  if (e->k == VNONRELOC) {  /* expression already has a register? */+    if (!hasjumps(e))  /* no jumps? */+      return e->u.info;  /* result is already in a register */+    if (e->u.info >= fs->nactvar) {  /* reg. is not a local? */+      exp2reg(fs, e, e->u.info);  /* put final result in it */+      return e->u.info;+    }+  }+  luaK_exp2nextreg(fs, e);  /* otherwise, use next available register */+  return e->u.info;+}+++/*+** Ensures final expression result is either in a register or in an+** upvalue.+*/+void luaK_exp2anyregup (FuncState *fs, expdesc *e) {+  if (e->k != VUPVAL || hasjumps(e))+    luaK_exp2anyreg(fs, e);+}+++/*+** Ensures final expression result is either in a register or it is+** a constant.+*/+void luaK_exp2val (FuncState *fs, expdesc *e) {+  if (hasjumps(e))+    luaK_exp2anyreg(fs, e);+  else+    luaK_dischargevars(fs, e);+}+++/*+** Ensures final expression result is in a valid R/K index+** (that is, it is either in a register or in 'k' with an index+** in the range of R/K indices).+** Returns R/K index.+*/+int luaK_exp2RK (FuncState *fs, expdesc *e) {+  luaK_exp2val(fs, e);+  switch (e->k) {  /* move constants to 'k' */+    case VTRUE: e->u.info = boolK(fs, 1); goto vk;+    case VFALSE: e->u.info = boolK(fs, 0); goto vk;+    case VNIL: e->u.info = nilK(fs); goto vk;+    case VKINT: e->u.info = luaK_intK(fs, e->u.ival); goto vk;+    case VKFLT: e->u.info = luaK_numberK(fs, e->u.nval); goto vk;+    case VK:+     vk:+      e->k = VK;+      if (e->u.info <= MAXINDEXRK)  /* constant fits in 'argC'? */+        return RKASK(e->u.info);+      else break;+    default: break;+  }+  /* not a constant in the right range: put it in a register */+  return luaK_exp2anyreg(fs, e);+}+++/*+** Generate code to store result of expression 'ex' into variable 'var'.+*/+void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {+  switch (var->k) {+    case VLOCAL: {+      freeexp(fs, ex);+      exp2reg(fs, ex, var->u.info);  /* compute 'ex' into proper place */+      return;+    }+    case VUPVAL: {+      int e = luaK_exp2anyreg(fs, ex);+      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0);+      break;+    }+    case VINDEXED: {+      OpCode op = (var->u.ind.vt == VLOCAL) ? OP_SETTABLE : OP_SETTABUP;+      int e = luaK_exp2RK(fs, ex);+      luaK_codeABC(fs, op, var->u.ind.t, var->u.ind.idx, e);+      break;+    }+    default: lua_assert(0);  /* invalid var kind to store */+  }+  freeexp(fs, ex);+}+++/*+** Emit SELF instruction (convert expression 'e' into 'e:key(e,').+*/+void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {+  int ereg;+  luaK_exp2anyreg(fs, e);+  ereg = e->u.info;  /* register where 'e' was placed */+  freeexp(fs, e);+  e->u.info = fs->freereg;  /* base register for op_self */+  e->k = VNONRELOC;  /* self expression has a fixed register */+  luaK_reserveregs(fs, 2);  /* function and 'self' produced by op_self */+  luaK_codeABC(fs, OP_SELF, e->u.info, ereg, luaK_exp2RK(fs, key));+  freeexp(fs, key);+}+++/*+** Negate condition 'e' (where 'e' is a comparison).+*/+static void negatecondition (FuncState *fs, expdesc *e) {+  Instruction *pc = getjumpcontrol(fs, e->u.info);+  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&+                                           GET_OPCODE(*pc) != OP_TEST);+  SETARG_A(*pc, !(GETARG_A(*pc)));+}+++/*+** Emit instruction to jump if 'e' is 'cond' (that is, if 'cond'+** is true, code will jump if 'e' is true.) Return jump position.+** Optimize when 'e' is 'not' something, inverting the condition+** and removing the 'not'.+*/+static int jumponcond (FuncState *fs, expdesc *e, int cond) {+  if (e->k == VRELOCABLE) {+    Instruction ie = getinstruction(fs, e);+    if (GET_OPCODE(ie) == OP_NOT) {+      fs->pc--;  /* remove previous OP_NOT */+      return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond);+    }+    /* else go through */+  }+  discharge2anyreg(fs, e);+  freeexp(fs, e);+  return condjump(fs, OP_TESTSET, NO_REG, e->u.info, cond);+}+++/*+** Emit code to go through if 'e' is true, jump otherwise.+*/+void luaK_goiftrue (FuncState *fs, expdesc *e) {+  int pc;  /* pc of new jump */+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VJMP: {  /* condition? */+      negatecondition(fs, e);  /* jump when it is false */+      pc = e->u.info;  /* save jump position */+      break;+    }+    case VK: case VKFLT: case VKINT: case VTRUE: {+      pc = NO_JUMP;  /* always true; do nothing */+      break;+    }+    default: {+      pc = jumponcond(fs, e, 0);  /* jump when false */+      break;+    }+  }+  luaK_concat(fs, &e->f, pc);  /* insert new jump in false list */+  luaK_patchtohere(fs, e->t);  /* true list jumps to here (to go through) */+  e->t = NO_JUMP;+}+++/*+** Emit code to go through if 'e' is false, jump otherwise.+*/+void luaK_goiffalse (FuncState *fs, expdesc *e) {+  int pc;  /* pc of new jump */+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VJMP: {+      pc = e->u.info;  /* already jump if true */+      break;+    }+    case VNIL: case VFALSE: {+      pc = NO_JUMP;  /* always false; do nothing */+      break;+    }+    default: {+      pc = jumponcond(fs, e, 1);  /* jump if true */+      break;+    }+  }+  luaK_concat(fs, &e->t, pc);  /* insert new jump in 't' list */+  luaK_patchtohere(fs, e->f);  /* false list jumps to here (to go through) */+  e->f = NO_JUMP;+}+++/*+** Code 'not e', doing constant folding.+*/+static void codenot (FuncState *fs, expdesc *e) {+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VNIL: case VFALSE: {+      e->k = VTRUE;  /* true == not nil == not false */+      break;+    }+    case VK: case VKFLT: case VKINT: case VTRUE: {+      e->k = VFALSE;  /* false == not "x" == not 0.5 == not 1 == not true */+      break;+    }+    case VJMP: {+      negatecondition(fs, e);+      break;+    }+    case VRELOCABLE:+    case VNONRELOC: {+      discharge2anyreg(fs, e);+      freeexp(fs, e);+      e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0);+      e->k = VRELOCABLE;+      break;+    }+    default: lua_assert(0);  /* cannot happen */+  }+  /* interchange true and false lists */+  { int temp = e->f; e->f = e->t; e->t = temp; }+  removevalues(fs, e->f);  /* values are useless when negated */+  removevalues(fs, e->t);+}+++/*+** Create expression 't[k]'. 't' must have its final result already in a+** register or upvalue.+*/+void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {+  lua_assert(!hasjumps(t) && (vkisinreg(t->k) || t->k == VUPVAL));+  t->u.ind.t = t->u.info;  /* register or upvalue index */+  t->u.ind.idx = luaK_exp2RK(fs, k);  /* R/K index for key */+  t->u.ind.vt = (t->k == VUPVAL) ? VUPVAL : VLOCAL;+  t->k = VINDEXED;+}+++/*+** Return false if folding can raise an error.+** Bitwise operations need operands convertible to integers; division+** operations cannot have 0 as divisor.+*/+static int validop (int op, TValue *v1, TValue *v2) {+  switch (op) {+    case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:+    case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: {  /* conversion errors */+      lua_Integer i;+      return (tointeger(v1, &i) && tointeger(v2, &i));+    }+    case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD:  /* division by 0 */+      return (nvalue(v2) != 0);+    default: return 1;  /* everything else is valid */+  }+}+++/*+** Try to "constant-fold" an operation; return 1 iff successful.+** (In this case, 'e1' has the final result.)+*/+static int constfolding (FuncState *fs, int op, expdesc *e1,+                                                const expdesc *e2) {+  TValue v1, v2, res;+  if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2))+    return 0;  /* non-numeric operands or not safe to fold */+  luaO_arith(fs->ls->L, op, &v1, &v2, &res);  /* does operation */+  if (ttisinteger(&res)) {+    e1->k = VKINT;+    e1->u.ival = ivalue(&res);+  }+  else {  /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */+    lua_Number n = fltvalue(&res);+    if (luai_numisnan(n) || n == 0)+      return 0;+    e1->k = VKFLT;+    e1->u.nval = n;+  }+  return 1;+}+++/*+** Emit code for unary expressions that "produce values"+** (everything but 'not').+** Expression to produce final result will be encoded in 'e'.+*/+static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) {+  int r = luaK_exp2anyreg(fs, e);  /* opcodes operate only on registers */+  freeexp(fs, e);+  e->u.info = luaK_codeABC(fs, op, 0, r, 0);  /* generate opcode */+  e->k = VRELOCABLE;  /* all those operations are relocatable */+  luaK_fixline(fs, line);+}+++/*+** Emit code for binary expressions that "produce values"+** (everything but logical operators 'and'/'or' and comparison+** operators).+** Expression to produce final result will be encoded in 'e1'.+** Because 'luaK_exp2RK' can free registers, its calls must be+** in "stack order" (that is, first on 'e2', which may have more+** recent registers to be released).+*/+static void codebinexpval (FuncState *fs, OpCode op,+                           expdesc *e1, expdesc *e2, int line) {+  int rk2 = luaK_exp2RK(fs, e2);  /* both operands are "RK" */+  int rk1 = luaK_exp2RK(fs, e1);+  freeexps(fs, e1, e2);+  e1->u.info = luaK_codeABC(fs, op, 0, rk1, rk2);  /* generate opcode */+  e1->k = VRELOCABLE;  /* all those operations are relocatable */+  luaK_fixline(fs, line);+}+++/*+** Emit code for comparisons.+** 'e1' was already put in R/K form by 'luaK_infix'.+*/+static void codecomp (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) {+  int rk1 = (e1->k == VK) ? RKASK(e1->u.info)+                          : check_exp(e1->k == VNONRELOC, e1->u.info);+  int rk2 = luaK_exp2RK(fs, e2);+  freeexps(fs, e1, e2);+  switch (opr) {+    case OPR_NE: {  /* '(a ~= b)' ==> 'not (a == b)' */+      e1->u.info = condjump(fs, OP_EQ, 0, rk1, rk2);+      break;+    }+    case OPR_GT: case OPR_GE: {+      /* '(a > b)' ==> '(b < a)';  '(a >= b)' ==> '(b <= a)' */+      OpCode op = cast(OpCode, (opr - OPR_NE) + OP_EQ);+      e1->u.info = condjump(fs, op, 1, rk2, rk1);  /* invert operands */+      break;+    }+    default: {  /* '==', '<', '<=' use their own opcodes */+      OpCode op = cast(OpCode, (opr - OPR_EQ) + OP_EQ);+      e1->u.info = condjump(fs, op, 1, rk1, rk2);+      break;+    }+  }+  e1->k = VJMP;+}+++/*+** Aplly prefix operation 'op' to expression 'e'.+*/+void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e, int line) {+  static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP};+  switch (op) {+    case OPR_MINUS: case OPR_BNOT:  /* use 'ef' as fake 2nd operand */+      if (constfolding(fs, op + LUA_OPUNM, e, &ef))+        break;+      /* FALLTHROUGH */+    case OPR_LEN:+      codeunexpval(fs, cast(OpCode, op + OP_UNM), e, line);+      break;+    case OPR_NOT: codenot(fs, e); break;+    default: lua_assert(0);+  }+}+++/*+** Process 1st operand 'v' of binary operation 'op' before reading+** 2nd operand.+*/+void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {+  switch (op) {+    case OPR_AND: {+      luaK_goiftrue(fs, v);  /* go ahead only if 'v' is true */+      break;+    }+    case OPR_OR: {+      luaK_goiffalse(fs, v);  /* go ahead only if 'v' is false */+      break;+    }+    case OPR_CONCAT: {+      luaK_exp2nextreg(fs, v);  /* operand must be on the 'stack' */+      break;+    }+    case OPR_ADD: case OPR_SUB:+    case OPR_MUL: case OPR_DIV: case OPR_IDIV:+    case OPR_MOD: case OPR_POW:+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:+    case OPR_SHL: case OPR_SHR: {+      if (!tonumeral(v, NULL))+        luaK_exp2RK(fs, v);+      /* else keep numeral, which may be folded with 2nd operand */+      break;+    }+    default: {+      luaK_exp2RK(fs, v);+      break;+    }+  }+}+++/*+** Finalize code for binary operation, after reading 2nd operand.+** For '(a .. b .. c)' (which is '(a .. (b .. c))', because+** concatenation is right associative), merge second CONCAT into first+** one.+*/+void luaK_posfix (FuncState *fs, BinOpr op,+                  expdesc *e1, expdesc *e2, int line) {+  switch (op) {+    case OPR_AND: {+      lua_assert(e1->t == NO_JUMP);  /* list closed by 'luK_infix' */+      luaK_dischargevars(fs, e2);+      luaK_concat(fs, &e2->f, e1->f);+      *e1 = *e2;+      break;+    }+    case OPR_OR: {+      lua_assert(e1->f == NO_JUMP);  /* list closed by 'luK_infix' */+      luaK_dischargevars(fs, e2);+      luaK_concat(fs, &e2->t, e1->t);+      *e1 = *e2;+      break;+    }+    case OPR_CONCAT: {+      luaK_exp2val(fs, e2);+      if (e2->k == VRELOCABLE &&+          GET_OPCODE(getinstruction(fs, e2)) == OP_CONCAT) {+        lua_assert(e1->u.info == GETARG_B(getinstruction(fs, e2))-1);+        freeexp(fs, e1);+        SETARG_B(getinstruction(fs, e2), e1->u.info);+        e1->k = VRELOCABLE; e1->u.info = e2->u.info;+      }+      else {+        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */+        codebinexpval(fs, OP_CONCAT, e1, e2, line);+      }+      break;+    }+    case OPR_ADD: case OPR_SUB: case OPR_MUL: case OPR_DIV:+    case OPR_IDIV: case OPR_MOD: case OPR_POW:+    case OPR_BAND: case OPR_BOR: case OPR_BXOR:+    case OPR_SHL: case OPR_SHR: {+      if (!constfolding(fs, op + LUA_OPADD, e1, e2))+        codebinexpval(fs, cast(OpCode, op + OP_ADD), e1, e2, line);+      break;+    }+    case OPR_EQ: case OPR_LT: case OPR_LE:+    case OPR_NE: case OPR_GT: case OPR_GE: {+      codecomp(fs, op, e1, e2);+      break;+    }+    default: lua_assert(0);+  }+}+++/*+** Change line information associated with current position.+*/+void luaK_fixline (FuncState *fs, int line) {+  fs->f->lineinfo[fs->pc - 1] = line;+}+++/*+** Emit a SETLIST instruction.+** 'base' is register that keeps table;+** 'nelems' is #table plus those to be stored now;+** 'tostore' is number of values (in registers 'base + 1',...) to add to+** table (or LUA_MULTRET to add up to stack top).+*/+void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) {+  int c =  (nelems - 1)/LFIELDS_PER_FLUSH + 1;+  int b = (tostore == LUA_MULTRET) ? 0 : tostore;+  lua_assert(tostore != 0 && tostore <= LFIELDS_PER_FLUSH);+  if (c <= MAXARG_C)+    luaK_codeABC(fs, OP_SETLIST, base, b, c);+  else if (c <= MAXARG_Ax) {+    luaK_codeABC(fs, OP_SETLIST, base, b, 0);+    codeextraarg(fs, c);+  }+  else+    luaX_syntaxerror(fs->ls, "constructor too long");+  fs->freereg = base + 1;  /* free registers with list values */+}+

@@ -0,0 +1,88 @@+/*+** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 roberto Exp $+** Code generator for Lua+** See Copyright Notice in lua.h+*/++#ifndef lcode_h+#define lcode_h++#include "llex.h"+#include "lobject.h"+#include "lopcodes.h"+#include "lparser.h"+++/*+** Marks the end of a patch list. It is an invalid value both as an absolute+** address, and as a list link (would link an element to itself).+*/+#define NO_JUMP (-1)+++/*+** grep "ORDER OPR" if you change these enums  (ORDER OP)+*/+typedef enum BinOpr {+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_MOD, OPR_POW,+  OPR_DIV,+  OPR_IDIV,+  OPR_BAND, OPR_BOR, OPR_BXOR,+  OPR_SHL, OPR_SHR,+  OPR_CONCAT,+  OPR_EQ, OPR_LT, OPR_LE,+  OPR_NE, OPR_GT, OPR_GE,+  OPR_AND, OPR_OR,+  OPR_NOBINOPR+} BinOpr;+++typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;+++/* get (pointer to) instruction of given 'expdesc' */+#define getinstruction(fs,e)	((fs)->f->code[(e)->u.info])++#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)++#define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)++#define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)++LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);+LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);+LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);+LUAI_FUNC void luaK_fixline (FuncState *fs, int line);+LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);+LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);+LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);+LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);+LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n);+LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);+LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);+LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);+LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);+LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);+LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);+LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);+LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);+LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);+LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);+LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);+LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);+LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);+LUAI_FUNC int luaK_jump (FuncState *fs);+LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);+LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);+LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);+LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);+LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);+LUAI_FUNC int luaK_getlabel (FuncState *fs);+LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);+LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);+LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,+                            expdesc *v2, int line);+LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);+++#endif

@@ -0,0 +1,168 @@+/*+** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $+** Coroutine Library+** See Copyright Notice in lua.h+*/++#define lcorolib_c+#define LUA_LIB++#include "lprefix.h"+++#include <stdlib.h>++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"+++static lua_State *getco (lua_State *L) {+  lua_State *co = lua_tothread(L, 1);+  luaL_argcheck(L, co, 1, "thread expected");+  return co;+}+++static int auxresume (lua_State *L, lua_State *co, int narg) {+  int status;+  if (!lua_checkstack(co, narg)) {+    lua_pushliteral(L, "too many arguments to resume");+    return -1;  /* error flag */+  }+  if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {+    lua_pushliteral(L, "cannot resume dead coroutine");+    return -1;  /* error flag */+  }+  lua_xmove(L, co, narg);+  status = lua_resume(co, L, narg);+  if (status == LUA_OK || status == LUA_YIELD) {+    int nres = lua_gettop(co);+    if (!lua_checkstack(L, nres + 1)) {+      lua_pop(co, nres);  /* remove results anyway */+      lua_pushliteral(L, "too many results to resume");+      return -1;  /* error flag */+    }+    lua_xmove(co, L, nres);  /* move yielded values */+    return nres;+  }+  else {+    lua_xmove(co, L, 1);  /* move error message */+    return -1;  /* error flag */+  }+}+++static int luaB_coresume (lua_State *L) {+  lua_State *co = getco(L);+  int r;+  r = auxresume(L, co, lua_gettop(L) - 1);+  if (r < 0) {+    lua_pushboolean(L, 0);+    lua_insert(L, -2);+    return 2;  /* return false + error message */+  }+  else {+    lua_pushboolean(L, 1);+    lua_insert(L, -(r + 1));+    return r + 1;  /* return true + 'resume' returns */+  }+}+++static int luaB_auxwrap (lua_State *L) {+  lua_State *co = lua_tothread(L, lua_upvalueindex(1));+  int r = auxresume(L, co, lua_gettop(L));+  if (r < 0) {+    if (lua_type(L, -1) == LUA_TSTRING) {  /* error object is a string? */+      luaL_where(L, 1);  /* add extra info */+      lua_insert(L, -2);+      lua_concat(L, 2);+    }+    return lua_error(L);  /* propagate error */+  }+  return r;+}+++static int luaB_cocreate (lua_State *L) {+  lua_State *NL;+  luaL_checktype(L, 1, LUA_TFUNCTION);+  NL = lua_newthread(L);+  lua_pushvalue(L, 1);  /* move function to top */+  lua_xmove(L, NL, 1);  /* move function from L to NL */+  return 1;+}+++static int luaB_cowrap (lua_State *L) {+  luaB_cocreate(L);+  lua_pushcclosure(L, luaB_auxwrap, 1);+  return 1;+}+++static int luaB_yield (lua_State *L) {+  return lua_yield(L, lua_gettop(L));+}+++static int luaB_costatus (lua_State *L) {+  lua_State *co = getco(L);+  if (L == co) lua_pushliteral(L, "running");+  else {+    switch (lua_status(co)) {+      case LUA_YIELD:+        lua_pushliteral(L, "suspended");+        break;+      case LUA_OK: {+        lua_Debug ar;+        if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */+          lua_pushliteral(L, "normal");  /* it is running */+        else if (lua_gettop(co) == 0)+            lua_pushliteral(L, "dead");+        else+          lua_pushliteral(L, "suspended");  /* initial state */+        break;+      }+      default:  /* some error occurred */+        lua_pushliteral(L, "dead");+        break;+    }+  }+  return 1;+}+++static int luaB_yieldable (lua_State *L) {+  lua_pushboolean(L, lua_isyieldable(L));+  return 1;+}+++static int luaB_corunning (lua_State *L) {+  int ismain = lua_pushthread(L);+  lua_pushboolean(L, ismain);+  return 2;+}+++static const luaL_Reg co_funcs[] = {+  {"create", luaB_cocreate},+  {"resume", luaB_coresume},+  {"running", luaB_corunning},+  {"status", luaB_costatus},+  {"wrap", luaB_cowrap},+  {"yield", luaB_yield},+  {"isyieldable", luaB_yieldable},+  {NULL, NULL}+};++++LUAMOD_API int luaopen_coroutine (lua_State *L) {+  luaL_newlib(L, co_funcs);+  return 1;+}+

@@ -0,0 +1,55 @@+/*+** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $+** 'ctype' functions for Lua+** See Copyright Notice in lua.h+*/++#define lctype_c+#define LUA_CORE++#include "lprefix.h"+++#include "lctype.h"++#if !LUA_USE_CTYPE	/* { */++#include <limits.h>++LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {+  0x00,  /* EOZ */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */+  0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */+  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,+  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */+  0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,+  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */+  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,+  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */+  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,+  0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */+  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,+  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */+  0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */+  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,+};++#endif			/* } */

@@ -0,0 +1,95 @@+/*+** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $+** 'ctype' functions for Lua+** See Copyright Notice in lua.h+*/++#ifndef lctype_h+#define lctype_h++#include "lua.h"+++/*+** WARNING: the functions defined here do not necessarily correspond+** to the similar functions in the standard C ctype.h. They are+** optimized for the specific needs of Lua+*/++#if !defined(LUA_USE_CTYPE)++#if 'A' == 65 && '0' == 48+/* ASCII case: can use its own tables; faster and fixed */+#define LUA_USE_CTYPE	0+#else+/* must use standard C ctype */+#define LUA_USE_CTYPE	1+#endif++#endif+++#if !LUA_USE_CTYPE	/* { */++#include <limits.h>++#include "llimits.h"+++#define ALPHABIT	0+#define DIGITBIT	1+#define PRINTBIT	2+#define SPACEBIT	3+#define XDIGITBIT	4+++#define MASK(B)		(1 << (B))+++/*+** add 1 to char to allow index -1 (EOZ)+*/+#define testprop(c,p)	(luai_ctype_[(c)+1] & (p))++/*+** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'+*/+#define lislalpha(c)	testprop(c, MASK(ALPHABIT))+#define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))+#define lisdigit(c)	testprop(c, MASK(DIGITBIT))+#define lisspace(c)	testprop(c, MASK(SPACEBIT))+#define lisprint(c)	testprop(c, MASK(PRINTBIT))+#define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))++/*+** this 'ltolower' only works for alphabetic characters+*/+#define ltolower(c)	((c) | ('A' ^ 'a'))+++/* two more entries for 0 and -1 (EOZ) */+LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];+++#else			/* }{ */++/*+** use standard C ctypes+*/++#include <ctype.h>+++#define lislalpha(c)	(isalpha(c) || (c) == '_')+#define lislalnum(c)	(isalnum(c) || (c) == '_')+#define lisdigit(c)	(isdigit(c))+#define lisspace(c)	(isspace(c))+#define lisprint(c)	(isprint(c))+#define lisxdigit(c)	(isxdigit(c))++#define ltolower(c)	(tolower(c))++#endif			/* } */++#endif+

@@ -0,0 +1,456 @@+/*+** $Id: ldblib.c,v 1.151.1.1 2017/04/19 17:20:42 roberto Exp $+** Interface from Lua to its debug API+** See Copyright Notice in lua.h+*/++#define ldblib_c+#define LUA_LIB++#include "lprefix.h"+++#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"+++/*+** The hook table at registry[&HOOKKEY] maps threads to their current+** hook function. (We only need the unique address of 'HOOKKEY'.)+*/+static const int HOOKKEY = 0;+++/*+** If L1 != L, L1 can be in any state, and therefore there are no+** guarantees about its stack space; any push in L1 must be+** checked.+*/+static void checkstack (lua_State *L, lua_State *L1, int n) {+  if (L != L1 && !lua_checkstack(L1, n))+    luaL_error(L, "stack overflow");+}+++static int db_getregistry (lua_State *L) {+  lua_pushvalue(L, LUA_REGISTRYINDEX);+  return 1;+}+++static int db_getmetatable (lua_State *L) {+  luaL_checkany(L, 1);+  if (!lua_getmetatable(L, 1)) {+    lua_pushnil(L);  /* no metatable */+  }+  return 1;+}+++static int db_setmetatable (lua_State *L) {+  int t = lua_type(L, 2);+  luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,+                    "nil or table expected");+  lua_settop(L, 2);+  lua_setmetatable(L, 1);+  return 1;  /* return 1st argument */+}+++static int db_getuservalue (lua_State *L) {+  if (lua_type(L, 1) != LUA_TUSERDATA)+    lua_pushnil(L);+  else+    lua_getuservalue(L, 1);+  return 1;+}+++static int db_setuservalue (lua_State *L) {+  luaL_checktype(L, 1, LUA_TUSERDATA);+  luaL_checkany(L, 2);+  lua_settop(L, 2);+  lua_setuservalue(L, 1);+  return 1;+}+++/*+** Auxiliary function used by several library functions: check for+** an optional thread as function's first argument and set 'arg' with+** 1 if this argument is present (so that functions can skip it to+** access their other arguments)+*/+static lua_State *getthread (lua_State *L, int *arg) {+  if (lua_isthread(L, 1)) {+    *arg = 1;+    return lua_tothread(L, 1);+  }+  else {+    *arg = 0;+    return L;  /* function will operate over current thread */+  }+}+++/*+** Variations of 'lua_settable', used by 'db_getinfo' to put results+** from 'lua_getinfo' into result table. Key is always a string;+** value can be a string, an int, or a boolean.+*/+static void settabss (lua_State *L, const char *k, const char *v) {+  lua_pushstring(L, v);+  lua_setfield(L, -2, k);+}++static void settabsi (lua_State *L, const char *k, int v) {+  lua_pushinteger(L, v);+  lua_setfield(L, -2, k);+}++static void settabsb (lua_State *L, const char *k, int v) {+  lua_pushboolean(L, v);+  lua_setfield(L, -2, k);+}+++/*+** In function 'db_getinfo', the call to 'lua_getinfo' may push+** results on the stack; later it creates the result table to put+** these objects. Function 'treatstackoption' puts the result from+** 'lua_getinfo' on top of the result table so that it can call+** 'lua_setfield'.+*/+static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {+  if (L == L1)+    lua_rotate(L, -2, 1);  /* exchange object and table */+  else+    lua_xmove(L1, L, 1);  /* move object to the "main" stack */+  lua_setfield(L, -2, fname);  /* put object into table */+}+++/*+** Calls 'lua_getinfo' and collects all results in a new table.+** L1 needs stack space for an optional input (function) plus+** two optional outputs (function and line table) from function+** 'lua_getinfo'.+*/+static int db_getinfo (lua_State *L) {+  lua_Debug ar;+  int arg;+  lua_State *L1 = getthread(L, &arg);+  const char *options = luaL_optstring(L, arg+2, "flnStu");+  checkstack(L, L1, 3);+  if (lua_isfunction(L, arg + 1)) {  /* info about a function? */+    options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */+    lua_pushvalue(L, arg + 1);  /* move function to 'L1' stack */+    lua_xmove(L, L1, 1);+  }+  else {  /* stack level */+    if (!lua_getstack(L1, (int)luaL_checkinteger(L, arg + 1), &ar)) {+      lua_pushnil(L);  /* level out of range */+      return 1;+    }+  }+  if (!lua_getinfo(L1, options, &ar))+    return luaL_argerror(L, arg+2, "invalid option");+  lua_newtable(L);  /* table to collect results */+  if (strchr(options, 'S')) {+    settabss(L, "source", ar.source);+    settabss(L, "short_src", ar.short_src);+    settabsi(L, "linedefined", ar.linedefined);+    settabsi(L, "lastlinedefined", ar.lastlinedefined);+    settabss(L, "what", ar.what);+  }+  if (strchr(options, 'l'))+    settabsi(L, "currentline", ar.currentline);+  if (strchr(options, 'u')) {+    settabsi(L, "nups", ar.nups);+    settabsi(L, "nparams", ar.nparams);+    settabsb(L, "isvararg", ar.isvararg);+  }+  if (strchr(options, 'n')) {+    settabss(L, "name", ar.name);+    settabss(L, "namewhat", ar.namewhat);+  }+  if (strchr(options, 't'))+    settabsb(L, "istailcall", ar.istailcall);+  if (strchr(options, 'L'))+    treatstackoption(L, L1, "activelines");+  if (strchr(options, 'f'))+    treatstackoption(L, L1, "func");+  return 1;  /* return table */+}+++static int db_getlocal (lua_State *L) {+  int arg;+  lua_State *L1 = getthread(L, &arg);+  lua_Debug ar;+  const char *name;+  int nvar = (int)luaL_checkinteger(L, arg + 2);  /* local-variable index */+  if (lua_isfunction(L, arg + 1)) {  /* function argument? */+    lua_pushvalue(L, arg + 1);  /* push function */+    lua_pushstring(L, lua_getlocal(L, NULL, nvar));  /* push local name */+    return 1;  /* return only name (there is no value) */+  }+  else {  /* stack-level argument */+    int level = (int)luaL_checkinteger(L, arg + 1);+    if (!lua_getstack(L1, level, &ar))  /* out of range? */+      return luaL_argerror(L, arg+1, "level out of range");+    checkstack(L, L1, 1);+    name = lua_getlocal(L1, &ar, nvar);+    if (name) {+      lua_xmove(L1, L, 1);  /* move local value */+      lua_pushstring(L, name);  /* push name */+      lua_rotate(L, -2, 1);  /* re-order */+      return 2;+    }+    else {+      lua_pushnil(L);  /* no name (nor value) */+      return 1;+    }+  }+}+++static int db_setlocal (lua_State *L) {+  int arg;+  const char *name;+  lua_State *L1 = getthread(L, &arg);+  lua_Debug ar;+  int level = (int)luaL_checkinteger(L, arg + 1);+  int nvar = (int)luaL_checkinteger(L, arg + 2);+  if (!lua_getstack(L1, level, &ar))  /* out of range? */+    return luaL_argerror(L, arg+1, "level out of range");+  luaL_checkany(L, arg+3);+  lua_settop(L, arg+3);+  checkstack(L, L1, 1);+  lua_xmove(L, L1, 1);+  name = lua_setlocal(L1, &ar, nvar);+  if (name == NULL)+    lua_pop(L1, 1);  /* pop value (if not popped by 'lua_setlocal') */+  lua_pushstring(L, name);+  return 1;+}+++/*+** get (if 'get' is true) or set an upvalue from a closure+*/+static int auxupvalue (lua_State *L, int get) {+  const char *name;+  int n = (int)luaL_checkinteger(L, 2);  /* upvalue index */+  luaL_checktype(L, 1, LUA_TFUNCTION);  /* closure */+  name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);+  if (name == NULL) return 0;+  lua_pushstring(L, name);+  lua_insert(L, -(get+1));  /* no-op if get is false */+  return get + 1;+}+++static int db_getupvalue (lua_State *L) {+  return auxupvalue(L, 1);+}+++static int db_setupvalue (lua_State *L) {+  luaL_checkany(L, 3);+  return auxupvalue(L, 0);+}+++/*+** Check whether a given upvalue from a given closure exists and+** returns its index+*/+static int checkupval (lua_State *L, int argf, int argnup) {+  int nup = (int)luaL_checkinteger(L, argnup);  /* upvalue index */+  luaL_checktype(L, argf, LUA_TFUNCTION);  /* closure */+  luaL_argcheck(L, (lua_getupvalue(L, argf, nup) != NULL), argnup,+                   "invalid upvalue index");+  return nup;+}+++static int db_upvalueid (lua_State *L) {+  int n = checkupval(L, 1, 2);+  lua_pushlightuserdata(L, lua_upvalueid(L, 1, n));+  return 1;+}+++static int db_upvaluejoin (lua_State *L) {+  int n1 = checkupval(L, 1, 2);+  int n2 = checkupval(L, 3, 4);+  luaL_argcheck(L, !lua_iscfunction(L, 1), 1, "Lua function expected");+  luaL_argcheck(L, !lua_iscfunction(L, 3), 3, "Lua function expected");+  lua_upvaluejoin(L, 1, n1, 3, n2);+  return 0;+}+++/*+** Call hook function registered at hook table for the current+** thread (if there is one)+*/+static void hookf (lua_State *L, lua_Debug *ar) {+  static const char *const hooknames[] =+    {"call", "return", "line", "count", "tail call"};+  lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);+  lua_pushthread(L);+  if (lua_rawget(L, -2) == LUA_TFUNCTION) {  /* is there a hook function? */+    lua_pushstring(L, hooknames[(int)ar->event]);  /* push event name */+    if (ar->currentline >= 0)+      lua_pushinteger(L, ar->currentline);  /* push current line */+    else lua_pushnil(L);+    lua_assert(lua_getinfo(L, "lS", ar));+    lua_call(L, 2, 0);  /* call hook function */+  }+}+++/*+** Convert a string mask (for 'sethook') into a bit mask+*/+static int makemask (const char *smask, int count) {+  int mask = 0;+  if (strchr(smask, 'c')) mask |= LUA_MASKCALL;+  if (strchr(smask, 'r')) mask |= LUA_MASKRET;+  if (strchr(smask, 'l')) mask |= LUA_MASKLINE;+  if (count > 0) mask |= LUA_MASKCOUNT;+  return mask;+}+++/*+** Convert a bit mask (for 'gethook') into a string mask+*/+static char *unmakemask (int mask, char *smask) {+  int i = 0;+  if (mask & LUA_MASKCALL) smask[i++] = 'c';+  if (mask & LUA_MASKRET) smask[i++] = 'r';+  if (mask & LUA_MASKLINE) smask[i++] = 'l';+  smask[i] = '\0';+  return smask;+}+++static int db_sethook (lua_State *L) {+  int arg, mask, count;+  lua_Hook func;+  lua_State *L1 = getthread(L, &arg);+  if (lua_isnoneornil(L, arg+1)) {  /* no hook? */+    lua_settop(L, arg+1);+    func = NULL; mask = 0; count = 0;  /* turn off hooks */+  }+  else {+    const char *smask = luaL_checkstring(L, arg+2);+    luaL_checktype(L, arg+1, LUA_TFUNCTION);+    count = (int)luaL_optinteger(L, arg + 3, 0);+    func = hookf; mask = makemask(smask, count);+  }+  if (lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY) == LUA_TNIL) {+    lua_createtable(L, 0, 2);  /* create a hook table */+    lua_pushvalue(L, -1);+    lua_rawsetp(L, LUA_REGISTRYINDEX, &HOOKKEY);  /* set it in position */+    lua_pushstring(L, "k");+    lua_setfield(L, -2, "__mode");  /** hooktable.__mode = "k" */+    lua_pushvalue(L, -1);+    lua_setmetatable(L, -2);  /* setmetatable(hooktable) = hooktable */+  }+  checkstack(L, L1, 1);+  lua_pushthread(L1); lua_xmove(L1, L, 1);  /* key (thread) */+  lua_pushvalue(L, arg + 1);  /* value (hook function) */+  lua_rawset(L, -3);  /* hooktable[L1] = new Lua hook */+  lua_sethook(L1, func, mask, count);+  return 0;+}+++static int db_gethook (lua_State *L) {+  int arg;+  lua_State *L1 = getthread(L, &arg);+  char buff[5];+  int mask = lua_gethookmask(L1);+  lua_Hook hook = lua_gethook(L1);+  if (hook == NULL)  /* no hook? */+    lua_pushnil(L);+  else if (hook != hookf)  /* external hook? */+    lua_pushliteral(L, "external hook");+  else {  /* hook table must exist */+    lua_rawgetp(L, LUA_REGISTRYINDEX, &HOOKKEY);+    checkstack(L, L1, 1);+    lua_pushthread(L1); lua_xmove(L1, L, 1);+    lua_rawget(L, -2);   /* 1st result = hooktable[L1] */+    lua_remove(L, -2);  /* remove hook table */+  }+  lua_pushstring(L, unmakemask(mask, buff));  /* 2nd result = mask */+  lua_pushinteger(L, lua_gethookcount(L1));  /* 3rd result = count */+  return 3;+}+++static int db_debug (lua_State *L) {+  for (;;) {+    char buffer[250];+    lua_writestringerror("%s", "lua_debug> ");+    if (fgets(buffer, sizeof(buffer), stdin) == 0 ||+        strcmp(buffer, "cont\n") == 0)+      return 0;+    if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||+        lua_pcall(L, 0, 0, 0))+      lua_writestringerror("%s\n", lua_tostring(L, -1));+    lua_settop(L, 0);  /* remove eventual returns */+  }+}+++static int db_traceback (lua_State *L) {+  int arg;+  lua_State *L1 = getthread(L, &arg);+  const char *msg = lua_tostring(L, arg + 1);+  if (msg == NULL && !lua_isnoneornil(L, arg + 1))  /* non-string 'msg'? */+    lua_pushvalue(L, arg + 1);  /* return it untouched */+  else {+    int level = (int)luaL_optinteger(L, arg + 2, (L == L1) ? 1 : 0);+    luaL_traceback(L, L1, msg, level);+  }+  return 1;+}+++static const luaL_Reg dblib[] = {+  {"debug", db_debug},+  {"getuservalue", db_getuservalue},+  {"gethook", db_gethook},+  {"getinfo", db_getinfo},+  {"getlocal", db_getlocal},+  {"getregistry", db_getregistry},+  {"getmetatable", db_getmetatable},+  {"getupvalue", db_getupvalue},+  {"upvaluejoin", db_upvaluejoin},+  {"upvalueid", db_upvalueid},+  {"setuservalue", db_setuservalue},+  {"sethook", db_sethook},+  {"setlocal", db_setlocal},+  {"setmetatable", db_setmetatable},+  {"setupvalue", db_setupvalue},+  {"traceback", db_traceback},+  {NULL, NULL}+};+++LUAMOD_API int luaopen_debug (lua_State *L) {+  luaL_newlib(L, dblib);+  return 1;+}+

@@ -0,0 +1,699 @@+/*+** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $+** Debug Interface+** See Copyright Notice in lua.h+*/++#define ldebug_c+#define LUA_CORE++#include "lprefix.h"+++#include <stdarg.h>+#include <stddef.h>+#include <string.h>++#include "lua.h"++#include "lapi.h"+#include "lcode.h"+#include "ldebug.h"+#include "ldo.h"+#include "lfunc.h"+#include "lobject.h"+#include "lopcodes.h"+#include "lstate.h"+#include "lstring.h"+#include "ltable.h"+#include "ltm.h"+#include "lvm.h"++++#define noLuaClosure(f)		((f) == NULL || (f)->c.tt == LUA_TCCL)+++/* Active Lua function (given call info) */+#define ci_func(ci)		(clLvalue((ci)->func))+++static const char *funcnamefromcode (lua_State *L, CallInfo *ci,+                                    const char **name);+++static int currentpc (CallInfo *ci) {+  lua_assert(isLua(ci));+  return pcRel(ci->u.l.savedpc, ci_func(ci)->p);+}+++static int currentline (CallInfo *ci) {+  return getfuncline(ci_func(ci)->p, currentpc(ci));+}+++/*+** If function yielded, its 'func' can be in the 'extra' field. The+** next function restores 'func' to its correct value for debugging+** purposes. (It exchanges 'func' and 'extra'; so, when called again,+** after debugging, it also "re-restores" ** 'func' to its altered value.+*/+static void swapextra (lua_State *L) {+  if (L->status == LUA_YIELD) {+    CallInfo *ci = L->ci;  /* get function that yielded */+    StkId temp = ci->func;  /* exchange its 'func' and 'extra' values */+    ci->func = restorestack(L, ci->extra);+    ci->extra = savestack(L, temp);+  }+}+++/*+** This function can be called asynchronously (e.g. during a signal).+** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by+** 'resethookcount') are for debug only, and it is no problem if they+** get arbitrary values (causes at most one wrong hook call). 'hookmask'+** is an atomic value. We assume that pointers are atomic too (e.g., gcc+** ensures that for all platforms where it runs). Moreover, 'hook' is+** always checked before being called (see 'luaD_hook').+*/+LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {+  if (func == NULL || mask == 0) {  /* turn off hooks? */+    mask = 0;+    func = NULL;+  }+  if (isLua(L->ci))+    L->oldpc = L->ci->u.l.savedpc;+  L->hook = func;+  L->basehookcount = count;+  resethookcount(L);+  L->hookmask = cast_byte(mask);+}+++LUA_API lua_Hook lua_gethook (lua_State *L) {+  return L->hook;+}+++LUA_API int lua_gethookmask (lua_State *L) {+  return L->hookmask;+}+++LUA_API int lua_gethookcount (lua_State *L) {+  return L->basehookcount;+}+++LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {+  int status;+  CallInfo *ci;+  if (level < 0) return 0;  /* invalid (negative) level */+  lua_lock(L);+  for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous)+    level--;+  if (level == 0 && ci != &L->base_ci) {  /* level found? */+    status = 1;+    ar->i_ci = ci;+  }+  else status = 0;  /* no such level */+  lua_unlock(L);+  return status;+}+++static const char *upvalname (Proto *p, int uv) {+  TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);+  if (s == NULL) return "?";+  else return getstr(s);+}+++static const char *findvararg (CallInfo *ci, int n, StkId *pos) {+  int nparams = clLvalue(ci->func)->p->numparams;+  if (n >= cast_int(ci->u.l.base - ci->func) - nparams)+    return NULL;  /* no such vararg */+  else {+    *pos = ci->func + nparams + n;+    return "(*vararg)";  /* generic name for any vararg */+  }+}+++static const char *findlocal (lua_State *L, CallInfo *ci, int n,+                              StkId *pos) {+  const char *name = NULL;+  StkId base;+  if (isLua(ci)) {+    if (n < 0)  /* access to vararg values? */+      return findvararg(ci, -n, pos);+    else {+      base = ci->u.l.base;+      name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));+    }+  }+  else+    base = ci->func + 1;+  if (name == NULL) {  /* no 'standard' name? */+    StkId limit = (ci == L->ci) ? L->top : ci->next->func;+    if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */+      name = "(*temporary)";  /* generic name for any valid slot */+    else+      return NULL;  /* no name */+  }+  *pos = base + (n - 1);+  return name;+}+++LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {+  const char *name;+  lua_lock(L);+  swapextra(L);+  if (ar == NULL) {  /* information about non-active function? */+    if (!isLfunction(L->top - 1))  /* not a Lua function? */+      name = NULL;+    else  /* consider live variables at function start (parameters) */+      name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0);+  }+  else {  /* active function; get information through 'ar' */+    StkId pos = NULL;  /* to avoid warnings */+    name = findlocal(L, ar->i_ci, n, &pos);+    if (name) {+      setobj2s(L, L->top, pos);+      api_incr_top(L);+    }+  }+  swapextra(L);+  lua_unlock(L);+  return name;+}+++LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {+  StkId pos = NULL;  /* to avoid warnings */+  const char *name;+  lua_lock(L);+  swapextra(L);+  name = findlocal(L, ar->i_ci, n, &pos);+  if (name) {+    setobjs2s(L, pos, L->top - 1);+    L->top--;  /* pop value */+  }+  swapextra(L);+  lua_unlock(L);+  return name;+}+++static void funcinfo (lua_Debug *ar, Closure *cl) {+  if (noLuaClosure(cl)) {+    ar->source = "=[C]";+    ar->linedefined = -1;+    ar->lastlinedefined = -1;+    ar->what = "C";+  }+  else {+    Proto *p = cl->l.p;+    ar->source = p->source ? getstr(p->source) : "=?";+    ar->linedefined = p->linedefined;+    ar->lastlinedefined = p->lastlinedefined;+    ar->what = (ar->linedefined == 0) ? "main" : "Lua";+  }+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);+}+++static void collectvalidlines (lua_State *L, Closure *f) {+  if (noLuaClosure(f)) {+    setnilvalue(L->top);+    api_incr_top(L);+  }+  else {+    int i;+    TValue v;+    int *lineinfo = f->l.p->lineinfo;+    Table *t = luaH_new(L);  /* new table to store active lines */+    sethvalue(L, L->top, t);  /* push it on stack */+    api_incr_top(L);+    setbvalue(&v, 1);  /* boolean 'true' to be the value of all indices */+    for (i = 0; i < f->l.p->sizelineinfo; i++)  /* for all lines with code */+      luaH_setint(L, t, lineinfo[i], &v);  /* table[line] = true */+  }+}+++static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {+  if (ci == NULL)  /* no 'ci'? */+    return NULL;  /* no info */+  else if (ci->callstatus & CIST_FIN) {  /* is this a finalizer? */+    *name = "__gc";+    return "metamethod";  /* report it as such */+  }+  /* calling function is a known Lua function? */+  else if (!(ci->callstatus & CIST_TAIL) && isLua(ci->previous))+    return funcnamefromcode(L, ci->previous, name);+  else return NULL;  /* no way to find a name */+}+++static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,+                       Closure *f, CallInfo *ci) {+  int status = 1;+  for (; *what; what++) {+    switch (*what) {+      case 'S': {+        funcinfo(ar, f);+        break;+      }+      case 'l': {+        ar->currentline = (ci && isLua(ci)) ? currentline(ci) : -1;+        break;+      }+      case 'u': {+        ar->nups = (f == NULL) ? 0 : f->c.nupvalues;+        if (noLuaClosure(f)) {+          ar->isvararg = 1;+          ar->nparams = 0;+        }+        else {+          ar->isvararg = f->l.p->is_vararg;+          ar->nparams = f->l.p->numparams;+        }+        break;+      }+      case 't': {+        ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0;+        break;+      }+      case 'n': {+        ar->namewhat = getfuncname(L, ci, &ar->name);+        if (ar->namewhat == NULL) {+          ar->namewhat = "";  /* not found */+          ar->name = NULL;+        }+        break;+      }+      case 'L':+      case 'f':  /* handled by lua_getinfo */+        break;+      default: status = 0;  /* invalid option */+    }+  }+  return status;+}+++LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {+  int status;+  Closure *cl;+  CallInfo *ci;+  StkId func;+  lua_lock(L);+  swapextra(L);+  if (*what == '>') {+    ci = NULL;+    func = L->top - 1;+    api_check(L, ttisfunction(func), "function expected");+    what++;  /* skip the '>' */+    L->top--;  /* pop function */+  }+  else {+    ci = ar->i_ci;+    func = ci->func;+    lua_assert(ttisfunction(ci->func));+  }+  cl = ttisclosure(func) ? clvalue(func) : NULL;+  status = auxgetinfo(L, what, ar, cl, ci);+  if (strchr(what, 'f')) {+    setobjs2s(L, L->top, func);+    api_incr_top(L);+  }+  swapextra(L);  /* correct before option 'L', which can raise a mem. error */+  if (strchr(what, 'L'))+    collectvalidlines(L, cl);+  lua_unlock(L);+  return status;+}+++/*+** {======================================================+** Symbolic Execution+** =======================================================+*/++static const char *getobjname (Proto *p, int lastpc, int reg,+                               const char **name);+++/*+** find a "name" for the RK value 'c'+*/+static void kname (Proto *p, int pc, int c, const char **name) {+  if (ISK(c)) {  /* is 'c' a constant? */+    TValue *kvalue = &p->k[INDEXK(c)];+    if (ttisstring(kvalue)) {  /* literal constant? */+      *name = svalue(kvalue);  /* it is its own name */+      return;+    }+    /* else no reasonable name found */+  }+  else {  /* 'c' is a register */+    const char *what = getobjname(p, pc, c, name); /* search for 'c' */+    if (what && *what == 'c') {  /* found a constant name? */+      return;  /* 'name' already filled */+    }+    /* else no reasonable name found */+  }+  *name = "?";  /* no reasonable name found */+}+++static int filterpc (int pc, int jmptarget) {+  if (pc < jmptarget)  /* is code conditional (inside a jump)? */+    return -1;  /* cannot know who sets that register */+  else return pc;  /* current position sets that register */+}+++/*+** try to find last instruction before 'lastpc' that modified register 'reg'+*/+static int findsetreg (Proto *p, int lastpc, int reg) {+  int pc;+  int setreg = -1;  /* keep last instruction that changed 'reg' */+  int jmptarget = 0;  /* any code before this address is conditional */+  for (pc = 0; pc < lastpc; pc++) {+    Instruction i = p->code[pc];+    OpCode op = GET_OPCODE(i);+    int a = GETARG_A(i);+    switch (op) {+      case OP_LOADNIL: {+        int b = GETARG_B(i);+        if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */+          setreg = filterpc(pc, jmptarget);+        break;+      }+      case OP_TFORCALL: {+        if (reg >= a + 2)  /* affect all regs above its base */+          setreg = filterpc(pc, jmptarget);+        break;+      }+      case OP_CALL:+      case OP_TAILCALL: {+        if (reg >= a)  /* affect all registers above base */+          setreg = filterpc(pc, jmptarget);+        break;+      }+      case OP_JMP: {+        int b = GETARG_sBx(i);+        int dest = pc + 1 + b;+        /* jump is forward and do not skip 'lastpc'? */+        if (pc < dest && dest <= lastpc) {+          if (dest > jmptarget)+            jmptarget = dest;  /* update 'jmptarget' */+        }+        break;+      }+      default:+        if (testAMode(op) && reg == a)  /* any instruction that set A */+          setreg = filterpc(pc, jmptarget);+        break;+    }+  }+  return setreg;+}+++static const char *getobjname (Proto *p, int lastpc, int reg,+                               const char **name) {+  int pc;+  *name = luaF_getlocalname(p, reg + 1, lastpc);+  if (*name)  /* is a local? */+    return "local";+  /* else try symbolic execution */+  pc = findsetreg(p, lastpc, reg);+  if (pc != -1) {  /* could find instruction? */+    Instruction i = p->code[pc];+    OpCode op = GET_OPCODE(i);+    switch (op) {+      case OP_MOVE: {+        int b = GETARG_B(i);  /* move from 'b' to 'a' */+        if (b < GETARG_A(i))+          return getobjname(p, pc, b, name);  /* get name for 'b' */+        break;+      }+      case OP_GETTABUP:+      case OP_GETTABLE: {+        int k = GETARG_C(i);  /* key index */+        int t = GETARG_B(i);  /* table index */+        const char *vn = (op == OP_GETTABLE)  /* name of indexed variable */+                         ? luaF_getlocalname(p, t + 1, pc)+                         : upvalname(p, t);+        kname(p, pc, k, name);+        return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";+      }+      case OP_GETUPVAL: {+        *name = upvalname(p, GETARG_B(i));+        return "upvalue";+      }+      case OP_LOADK:+      case OP_LOADKX: {+        int b = (op == OP_LOADK) ? GETARG_Bx(i)+                                 : GETARG_Ax(p->code[pc + 1]);+        if (ttisstring(&p->k[b])) {+          *name = svalue(&p->k[b]);+          return "constant";+        }+        break;+      }+      case OP_SELF: {+        int k = GETARG_C(i);  /* key index */+        kname(p, pc, k, name);+        return "method";+      }+      default: break;  /* go through to return NULL */+    }+  }+  return NULL;  /* could not find reasonable name */+}+++/*+** Try to find a name for a function based on the code that called it.+** (Only works when function was called by a Lua function.)+** Returns what the name is (e.g., "for iterator", "method",+** "metamethod") and sets '*name' to point to the name.+*/+static const char *funcnamefromcode (lua_State *L, CallInfo *ci,+                                     const char **name) {+  TMS tm = (TMS)0;  /* (initial value avoids warnings) */+  Proto *p = ci_func(ci)->p;  /* calling function */+  int pc = currentpc(ci);  /* calling instruction index */+  Instruction i = p->code[pc];  /* calling instruction */+  if (ci->callstatus & CIST_HOOKED) {  /* was it called inside a hook? */+    *name = "?";+    return "hook";+  }+  switch (GET_OPCODE(i)) {+    case OP_CALL:+    case OP_TAILCALL:+      return getobjname(p, pc, GETARG_A(i), name);  /* get function name */+    case OP_TFORCALL: {  /* for iterator */+      *name = "for iterator";+       return "for iterator";+    }+    /* other instructions can do calls through metamethods */+    case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:+      tm = TM_INDEX;+      break;+    case OP_SETTABUP: case OP_SETTABLE:+      tm = TM_NEWINDEX;+      break;+    case OP_ADD: case OP_SUB: case OP_MUL: case OP_MOD:+    case OP_POW: case OP_DIV: case OP_IDIV: case OP_BAND:+    case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: {+      int offset = cast_int(GET_OPCODE(i)) - cast_int(OP_ADD);  /* ORDER OP */+      tm = cast(TMS, offset + cast_int(TM_ADD));  /* ORDER TM */+      break;+    }+    case OP_UNM: tm = TM_UNM; break;+    case OP_BNOT: tm = TM_BNOT; break;+    case OP_LEN: tm = TM_LEN; break;+    case OP_CONCAT: tm = TM_CONCAT; break;+    case OP_EQ: tm = TM_EQ; break;+    case OP_LT: tm = TM_LT; break;+    case OP_LE: tm = TM_LE; break;+    default:+      return NULL;  /* cannot find a reasonable name */+  }+  *name = getstr(G(L)->tmname[tm]);+  return "metamethod";+}++/* }====================================================== */++++/*+** The subtraction of two potentially unrelated pointers is+** not ISO C, but it should not crash a program; the subsequent+** checks are ISO C and ensure a correct result.+*/+static int isinstack (CallInfo *ci, const TValue *o) {+  ptrdiff_t i = o - ci->u.l.base;+  return (0 <= i && i < (ci->top - ci->u.l.base) && ci->u.l.base + i == o);+}+++/*+** Checks whether value 'o' came from an upvalue. (That can only happen+** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on+** upvalues.)+*/+static const char *getupvalname (CallInfo *ci, const TValue *o,+                                 const char **name) {+  LClosure *c = ci_func(ci);+  int i;+  for (i = 0; i < c->nupvalues; i++) {+    if (c->upvals[i]->v == o) {+      *name = upvalname(c->p, i);+      return "upvalue";+    }+  }+  return NULL;+}+++static const char *varinfo (lua_State *L, const TValue *o) {+  const char *name = NULL;  /* to avoid warnings */+  CallInfo *ci = L->ci;+  const char *kind = NULL;+  if (isLua(ci)) {+    kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */+    if (!kind && isinstack(ci, o))  /* no? try a register */+      kind = getobjname(ci_func(ci)->p, currentpc(ci),+                        cast_int(o - ci->u.l.base), &name);+  }+  return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : "";+}+++l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) {+  const char *t = luaT_objtypename(L, o);+  luaG_runerror(L, "attempt to %s a %s value%s", op, t, varinfo(L, o));+}+++l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {+  if (ttisstring(p1) || cvt2str(p1)) p1 = p2;+  luaG_typeerror(L, p1, "concatenate");+}+++l_noret luaG_opinterror (lua_State *L, const TValue *p1,+                         const TValue *p2, const char *msg) {+  lua_Number temp;+  if (!tonumber(p1, &temp))  /* first operand is wrong? */+    p2 = p1;  /* now second is wrong */+  luaG_typeerror(L, p2, msg);+}+++/*+** Error when both values are convertible to numbers, but not to integers+*/+l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {+  lua_Integer temp;+  if (!tointeger(p1, &temp))+    p2 = p1;+  luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));+}+++l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {+  const char *t1 = luaT_objtypename(L, p1);+  const char *t2 = luaT_objtypename(L, p2);+  if (strcmp(t1, t2) == 0)+    luaG_runerror(L, "attempt to compare two %s values", t1);+  else+    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);+}+++/* add src:line information to 'msg' */+const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,+                                        int line) {+  char buff[LUA_IDSIZE];+  if (src)+    luaO_chunkid(buff, getstr(src), LUA_IDSIZE);+  else {  /* no source available; use "?" instead */+    buff[0] = '?'; buff[1] = '\0';+  }+  return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);+}+++l_noret luaG_errormsg (lua_State *L) {+  if (L->errfunc != 0) {  /* is there an error handling function? */+    StkId errfunc = restorestack(L, L->errfunc);+    setobjs2s(L, L->top, L->top - 1);  /* move argument */+    setobjs2s(L, L->top - 1, errfunc);  /* push function */+    L->top++;  /* assume EXTRA_STACK */+    luaD_callnoyield(L, L->top - 2, 1);  /* call it */+  }+  luaD_throw(L, LUA_ERRRUN);+}+++l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {+  CallInfo *ci = L->ci;+  const char *msg;+  va_list argp;+  luaC_checkGC(L);  /* error message uses memory */+  va_start(argp, fmt);+  msg = luaO_pushvfstring(L, fmt, argp);  /* format message */+  va_end(argp);+  if (isLua(ci))  /* if Lua function, add source:line information */+    luaG_addinfo(L, msg, ci_func(ci)->p->source, currentline(ci));+  luaG_errormsg(L);+}+++void luaG_traceexec (lua_State *L) {+  CallInfo *ci = L->ci;+  lu_byte mask = L->hookmask;+  int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));+  if (counthook)+    resethookcount(L);  /* reset count */+  else if (!(mask & LUA_MASKLINE))+    return;  /* no line hook and count != 0; nothing to be done */+  if (ci->callstatus & CIST_HOOKYIELD) {  /* called hook last time? */+    ci->callstatus &= ~CIST_HOOKYIELD;  /* erase mark */+    return;  /* do not call hook again (VM yielded, so it did not move) */+  }+  if (counthook)+    luaD_hook(L, LUA_HOOKCOUNT, -1);  /* call count hook */+  if (mask & LUA_MASKLINE) {+    Proto *p = ci_func(ci)->p;+    int npc = pcRel(ci->u.l.savedpc, p);+    int newline = getfuncline(p, npc);+    if (npc == 0 ||  /* call linehook when enter a new function, */+        ci->u.l.savedpc <= L->oldpc ||  /* when jump back (loop), or when */+        newline != getfuncline(p, pcRel(L->oldpc, p)))  /* enter a new line */+      luaD_hook(L, LUA_HOOKLINE, newline);  /* call line hook */+  }+  L->oldpc = ci->u.l.savedpc;+  if (L->status == LUA_YIELD) {  /* did hook yield? */+    if (counthook)+      L->hookcount = 1;  /* undo decrement to zero */+    ci->u.l.savedpc--;  /* undo increment (resume will increment it again) */+    ci->callstatus |= CIST_HOOKYIELD;  /* mark that it yielded */+    ci->func = L->top - 1;  /* protect stack below results */+    luaD_throw(L, LUA_YIELD);+  }+}+