hslua 1.3.0.2 → 2.0.0

raw patch · 118 files changed

+541/−31094 lines, 118 filesdep +hslua-classesdep +hslua-coredep +hslua-marshallingdep −QuickCheckdep −base-compatdep −faildep ~bytestringdep ~containerssetup-changedPVP ok

version bump matches the API change (PVP)

Dependencies added: hslua-classes, hslua-core, hslua-marshalling, hslua-objectorientation, hslua-packaging, tasty-hslua

Dependencies removed: QuickCheck, base-compat, fail, quickcheck-instances, semigroups, tasty-quickcheck

Dependency ranges changed: bytestring, containers

API changes (from Hackage documentation)

Files

• CHANGELOG.md +63/−3
• LICENSE +4/−4
• README.md +7/−43
• Setup.hs +0/−2
• cbits/hslua/hslcall.c +0/−102
• cbits/hslua/hslcall.h +0/−12
• cbits/hslua/hslua-export.h +0/−8
• cbits/hslua/hslua.c +0/−205
• cbits/hslua/hslua.h +0/−33
• cbits/hslua/hsludata.c +0/−41
• cbits/hslua/hsludata.h +0/−11
• cbits/lua-5.3.6/lapi.c +0/−1299
• cbits/lua-5.3.6/lapi.h +0/−24
• cbits/lua-5.3.6/lauxlib.c +0/−1048
• cbits/lua-5.3.6/lauxlib.h +0/−264
• cbits/lua-5.3.6/lbaselib.c +0/−498
• cbits/lua-5.3.6/lbitlib.c +0/−233
• cbits/lua-5.3.6/lcode.c +0/−1203
• cbits/lua-5.3.6/lcode.h +0/−88
• cbits/lua-5.3.6/lcorolib.c +0/−168
• cbits/lua-5.3.6/lctype.c +0/−55
• cbits/lua-5.3.6/lctype.h +0/−95
• cbits/lua-5.3.6/ldblib.c +0/−456
• cbits/lua-5.3.6/ldebug.c +0/−700
• cbits/lua-5.3.6/ldebug.h +0/−39
• cbits/lua-5.3.6/ldo.c +0/−802
• cbits/lua-5.3.6/ldo.h +0/−58
• cbits/lua-5.3.6/ldump.c +0/−215
• cbits/lua-5.3.6/lfunc.c +0/−151
• cbits/lua-5.3.6/lfunc.h +0/−61
• cbits/lua-5.3.6/lgc.c +0/−1179
• cbits/lua-5.3.6/lgc.h +0/−147
• cbits/lua-5.3.6/linit.c +0/−68
• cbits/lua-5.3.6/liolib.c +0/−778
• cbits/lua-5.3.6/llex.c +0/−568
• cbits/lua-5.3.6/llex.h +0/−85
• cbits/lua-5.3.6/llimits.h +0/−323
• cbits/lua-5.3.6/lmathlib.c +0/−410
• cbits/lua-5.3.6/lmem.c +0/−100
• cbits/lua-5.3.6/lmem.h +0/−69
• cbits/lua-5.3.6/loadlib.c +0/−790
• cbits/lua-5.3.6/lobject.c +0/−522
• cbits/lua-5.3.6/lobject.h +0/−549
• cbits/lua-5.3.6/lopcodes.c +0/−124
• cbits/lua-5.3.6/lopcodes.h +0/−297
• cbits/lua-5.3.6/loslib.c +0/−409
• cbits/lua-5.3.6/lparser.c +0/−1653
• cbits/lua-5.3.6/lparser.h +0/−133
• cbits/lua-5.3.6/lprefix.h +0/−45
• cbits/lua-5.3.6/lstate.c +0/−347
• cbits/lua-5.3.6/lstate.h +0/−253
• cbits/lua-5.3.6/lstring.c +0/−248
• cbits/lua-5.3.6/lstring.h +0/−49
• cbits/lua-5.3.6/lstrlib.c +0/−1584
• cbits/lua-5.3.6/ltable.c +0/−688
• cbits/lua-5.3.6/ltable.h +0/−66
• cbits/lua-5.3.6/ltablib.c +0/−450
• cbits/lua-5.3.6/ltm.c +0/−165
• cbits/lua-5.3.6/ltm.h +0/−76
• cbits/lua-5.3.6/lua.h +0/−485
• cbits/lua-5.3.6/luaconf.h +0/−790
• cbits/lua-5.3.6/lualib.h +0/−61
• cbits/lua-5.3.6/lundump.c +0/−287
• cbits/lua-5.3.6/lundump.h +0/−32
• cbits/lua-5.3.6/lutf8lib.c +0/−256
• cbits/lua-5.3.6/lvm.c +0/−1322
• cbits/lua-5.3.6/lvm.h +0/−113
• cbits/lua-5.3.6/lzio.c +0/−68
• cbits/lua-5.3.6/lzio.h +0/−66
• hslua.cabal +54/−229
• prelude/Prelude.hs +0/−8
• src/Foreign/Lua.hs +0/−90
• src/Foreign/Lua/Call.hs +0/−301
• src/Foreign/Lua/Core.hs +0/−196
• src/Foreign/Lua/Core/Auxiliary.hs +0/−259
• src/Foreign/Lua/Core/Constants.hs +0/−22
• src/Foreign/Lua/Core/Error.hs +0/−126
• src/Foreign/Lua/Core/Functions.hs +0/−946
• src/Foreign/Lua/Core/RawBindings.hs +0/−21
• src/Foreign/Lua/Core/Types.hs +0/−178
• src/Foreign/Lua/FunctionCalling.hsc +0/−158
• src/Foreign/Lua/Module.hs +0/−183
• src/Foreign/Lua/Peek.hs +0/−270
• src/Foreign/Lua/Push.hs +0/−112
• src/Foreign/Lua/Raw/Auxiliary.hs +0/−133
• src/Foreign/Lua/Raw/Call.hs +0/−65
• src/Foreign/Lua/Raw/Constants.hs +0/−39
• src/Foreign/Lua/Raw/Error.hs +0/−40
• src/Foreign/Lua/Raw/Functions.hs +0/−393
• src/Foreign/Lua/Raw/Types.hsc +0/−281
• src/Foreign/Lua/Raw/Userdata.hs +0/−65
• src/Foreign/Lua/Types.hs +0/−17
• src/Foreign/Lua/Types/Peekable.hs +0/−238
• src/Foreign/Lua/Types/Pushable.hs +0/−179
• src/Foreign/Lua/Userdata.hs +0/−116
• src/Foreign/Lua/Utf8.hs +0/−45
• src/Foreign/Lua/Util.hs +0/−168
• src/HsLua.hs +49/−0
• src/HsLua/Util.hs +67/−0
• test/Foreign/Lua/CallTests.hs +0/−170
• test/Foreign/Lua/Core/AuxiliaryTests.hs +0/−74
• test/Foreign/Lua/Core/ErrorTests.hs +0/−25
• test/Foreign/Lua/CoreTests.hs +0/−478
• test/Foreign/Lua/FunctionCallingTests.hs +0/−122
• test/Foreign/Lua/ModuleTests.hs +0/−152
• test/Foreign/Lua/PeekTests.hs +0/−304
• test/Foreign/Lua/PushTests.hs +0/−229
• test/Foreign/Lua/Types/PeekableTests.hs +0/−139
• test/Foreign/Lua/Types/PushableTests.hs +0/−115
• test/Foreign/Lua/TypesTests.hs +0/−173
• test/Foreign/Lua/UserdataTests.hs +0/−103
• test/Foreign/Lua/UtilTests.hs +0/−111
• test/Foreign/LuaTests.hs +0/−276
• test/HsLua/UtilTests.hs +74/−0
• test/HsLuaTests.hs +210/−0
• test/Test/HsLua/Arbitrary.hs +0/−38
• test/Test/HsLua/Util.hs +0/−83
• test/test-hslua.hs +13/−48

@@ -1,10 +1,70 @@ ## Changelog -### 1.3.0.2+### 2.0.0 -Released 2021-10-14.+Release pending. -- Bumped upper package version bound, allowing bytestring 0.11.+- Move module hierarchy from Foreign.Lua to HsLua.++- Error handling has been reworked completely. The type of+  exceptions used and handled by HsLua is now exposed to the type+  system. The type `Lua` makes use of a default error type. Custom+  error handling can be implemented by using the `LuaE` type with+  an exception type that is an instance of class `LuaError`.++- Renamed stack index helpers to `nth`, `nthTop`, `nthBottom`,+  `top`. The following have been *removed*: `stackTop`,+  `nthFromTop`, `nthFromBottom`.++- Extracted raw Lua bindings into new package *lua*. This means+  that all cabal flags have been moved to package *lua* as well.+  Version lua-1.0.0 contained the `Foreign.Lua.Raw` hierarchy as+  present in hslua-1.3.0. See that package's changelog for+  info on the additional modifications since then.++- The module Foreign.Lua.Raw.Error was merged into the+  HsLua.Core.Error module.++- The functions `getglobal` and `gettable` now return the Lua+  `Type` of the pushed value.++- Extracted new packages:++    + *hslua-core*: the package contains all modules from the+      *Core* sub-hierarchy.++    * *hslua-classes*: typclasses *Peekable* and *Pushable* for+      pushing and pulling, as well as function calling.++    + *tasty-hslua*: makes testing helpers available for reuse.++- Moved *run* functions from Util to Core.Run.++- Moved module Utf8 from the base level into Core.++- Refactored code to expose Haskell functions to Lua:++    + Removed functions `newCFunction`, `freeCFunction`. Use+      `pushHaskellFunction` instead, it takes care of garbage+      collection.++    + Renamed typeclass `ToHaskellFunction` to `Exposable`,+      function `callFunc` to `invoke`. All these have been moved+      to *hslua-classes*.++    + The type PreCFunction is now defined in package lua;+      HaskellFunction is defined in hslua-core.++    + Changed `pushHaskellFunction` to only accept HaskellFunction+      arguments, move it to hslua-core.++    + Removed helper functions `addfunction` and `addfield` from+      *Module*. Use documented functions and fields instead.++- Added support for a "since" tag on documented functions; allows+  to mark the library version when a function was introduced in+  its present form.+  ### 1.3.0.1 

@@ -1,7 +1,7 @@-Copyright (C) 1994-2020 Lua.org, PUC-Rio.-Copyright (C) 2007-2012 Gracjan Polak-Copyright (C) 2012-2015 Ömer Sinan Ağacan-Copyright (C) 2016-2019 Albert Krewinkel+Copyright © 1994-2020 Lua.org, PUC-Rio.+Copyright © 2007-2012 Gracjan Polak+Copyright © 2012-2015 Ömer Sinan Ağacan+Copyright © 2016-2021 Albert Krewinkel  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the

@@ -12,7 +12,13 @@ [AppVeyor Status]: https://ci.appveyor.com/api/projects/status/ldutrilgxhpcau94/branch/main?svg=true [Hackage]: https://img.shields.io/hackage/v/hslua.svg +This package is part of [HsLua], a Haskell framework built around+the embeddable scripting language [Lua]. +[HsLua]: https://hslua.org/+[Lua]: https://lua.org/++ Overview -------- @@ -53,7 +59,7 @@ pushing the function onto the stack, followed by the function arguments in the order they should be passed to the function. The API function `call` then invokes the function with given numbers of arguments, pops the function and-parameters of the stack, and pushes the results.+parameters off the stack, and pushes the results.      ,----------.     |  arg 3   |@@ -103,48 +109,6 @@ 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.Core` (also exported in `Foreign.Lua`).---Build flags--------------The following cabal build flags are supported:--- `system-lua`: Use the locally installed Lua version instead of the version-  shipped as part of HsLua.--- `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-  is *enabled* per default, as this is rarely a problem in practice.--- `apicheck`: Compile Lua with its API checks enabled.--- `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 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"-```--or with stack:--``` sh-stack install pandoc --flag=hslua:system-lua-```   Q&A

@@ -1,2 +0,0 @@-import Distribution.Simple
-main = defaultMain

@@ -1,102 +0,0 @@-#include <HsFFI.h>-#include <lua.h>-#include <lauxlib.h>-#include "hslua-export.h"-#include "hslcall.h"-#include "hsludata.h"--/* ***************************************************************- * Transforming Haskell errors to Lua errors- * ***************************************************************/-void hslua_pushhaskellerr(lua_State *L)-{-  lua_getfield(L, LUA_REGISTRYINDEX, HSLUA_ERR);-}--/*-** Marks the occurence of an error; the returned value should be-** used as the error message.-*/-int hslua_error(lua_State *L)-{-  hslua_pushhaskellerr(L);-  lua_insert(L, -2);-  return 2;-}--/*-** Checks whether the object at the given index is a Haskell error.-*/-int hslua_is_haskell_error(lua_State *L, int idx)-{-  int erridx = lua_absindex(L, idx);-  hslua_pushhaskellerr(L);-  int is_err = lua_rawequal(L, erridx, -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 HSLUA_ERR 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 HaskellFunction 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;-}--/*-** Retrieves a HsStablePtr to a Haskell function from a-** function-wrapping userdata when it's been called and removes-** the userdata from the stack.-*/-void *hslua_hs_fun_ptr(lua_State *L)-{-  void *fn = luaL_testudata(L, 1, HSLUA_HSFUN_NAME);-  lua_remove(L, 1);-  return fn;-}--/*-** Pushes a metatable for Haskell function wrapping userdata to-** the stack.-*/-void hslua_registerhsfunmetatable(lua_State *L)-{-  hslua_newudmetatable(L, HSLUA_HSFUN_NAME);-  lua_pushcfunction(L, &hslua_call_wrapped_hs_fun);-  lua_setfield(L, -2, "__call");-  lua_pop(L, 1);-}--/*-** Creates a new C function from a Haskell function.-*/-void hslua_newhsfunction(lua_State *L, HsStablePtr fn)-{-  HsStablePtr *ud = lua_newuserdata(L, sizeof fn);-  *ud = fn;-  luaL_setmetatable(L, HSLUA_HSFUN_NAME);-  lua_pushcclosure(L, &hslua_call_hs, 1);-}

@@ -1,12 +0,0 @@-#ifndef hslcall_h-#define hslcall_h--#define HSLUA_ERR "HSLUA_ERR"-#define HSLUA_HSFUN_NAME "HsLuaFunction"-#include <lua.h>-#include <HsFFI.h>--/*  register metatable for HaskellFunction userdata wrappers */-void hslua_registerhsfunmetatable(lua_State *L);--#endif

@@ -1,8 +0,0 @@-/* ***************************************************************- * Functions exported from Haskell- * ***************************************************************/--#include <lua.h>--/*  exported from Foreign.Lua.Raw.Call */-int hslua_call_wrapped_hs_fun(lua_State *L);

@@ -1,205 +0,0 @@-#include <stdio.h>-#include <string.h>-#include <HsFFI.h>-#include "hslua.h"-#include "hslcall.h"--/* ***************************************************************- * 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, int *status)-{-  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);-  *status = lua_pcall(L, 3, 1, 0);-  if (*status != LUA_OK) {-    return 0;-  }-  int result = lua_tointeger(L, -1);-  lua_pop(L, 1);-  return result;-}---/*-** concat-*/-int hslua__concat(lua_State *L)-{-  lua_concat(L, lua_gettop(L));-  return 1;-}--void hslua_concat(lua_State *L, int n, int *status)-{-  lua_pushcfunction(L, hslua__concat);-  lua_insert(L, -n - 1);-  *status = lua_pcall(L, n, 1, 0);-}---/*-** getglobal-*/-int hslua__getglobal(lua_State *L)-{-  lua_gettable(L, 1);-  return 1;-}--void hslua_getglobal(lua_State *L, const char *name, size_t len, int *status)-{-  lua_pushcfunction(L, hslua__getglobal);-  lua_pushglobaltable(L);-  lua_pushlstring(L, name, len);-  *status = lua_pcall(L, 2, 1, 0);-}---/*-** gettable-*/-int hslua__gettable(lua_State *L)-{-  lua_pushvalue(L, 1);-  lua_gettable(L, 2);-  return 1;-}--void hslua_gettable(lua_State *L, int index, int *status)-{-  lua_pushvalue(L, index);-  lua_pushcfunction(L, hslua__gettable);-  lua_insert(L, -3);-  *status = 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;-}--void hslua_setglobal(lua_State *L, const char *name, size_t len, int *status)-{-  /* 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);-  *status = 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;-}--void hslua_settable(lua_State *L, int index, int *status)-{-  lua_pushvalue(L, index);-  lua_pushcfunction(L, hslua__settable);-  lua_insert(L, -4);-  *status = 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 *status)-{-  int oldsize = lua_gettop(L);-  lua_pushvalue(L, index);-  lua_pushcfunction(L, hslua__next);-  lua_insert(L, -3);-  *status = lua_pcall(L, 2, LUA_MULTRET, 0);-  if (*status != 0) {-    /* error */-    return 0;-  }-  /* success */-  return (lua_gettop(L) - oldsize + 1); /* correct for popped value */-}---/*-** Auxiliary Library-*/--/*-** newstate-*/-lua_State *hsluaL_newstate()-{-  lua_State *L = luaL_newstate();--  /* add error value */-  lua_createtable(L, 0, 0);-  lua_setfield(L, LUA_REGISTRYINDEX, HSLUA_ERR);--  /* register HaskellFunction userdata metatable */-  hslua_registerhsfunmetatable(L);--  return L;-}---/*-** 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);-}

@@ -1,33 +0,0 @@-#include "lua.h"-#include "lauxlib.h"--int hslua_error(lua_State *L);--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 *status);--void hslua_concat(lua_State *L, int n, int *status);--void hslua_getglobal(lua_State *L, const char *name, size_t len, int *status);--void hslua_gettable(lua_State *L, int index, int *status);--void hslua_setglobal(lua_State *L, const char *k, size_t len, int *status);--void hslua_settable(lua_State *L, int index, int *status);--int hslua_next(lua_State *L, int index, int *status);---/* auxiliary library */-const char *hsluaL_tolstring(lua_State *L, int index, size_t *len);--/*-** function calling-*/--/* Wraps a Haskell function with an userdata object.  */-void hslua_newhsfunwrapper(lua_State *L, HsStablePtr fn);

@@ -1,41 +0,0 @@-#include <HsFFI.h>-#include "hslua.h"-#include "hsludata.h"--/* ***************************************************************- * Userdata Creation and Garbage Collection- * ***************************************************************/--/*-** Free stable Haskell pointer in userdata.-**-** The userdata whose contents is garbage collected must be on-** stack index 1 (i.e., the first argument).-*/-int hslua_userdata_gc(lua_State *L)-{-  HsStablePtr *userdata = lua_touserdata(L, 1);-  if (userdata) {-    hs_free_stable_ptr(*userdata);-  }-  return 0;-}--/*-** Creates a new userdata metatable for Haskell objects, or gets-** is from the registry if possible.-*/-int hslua_newudmetatable(lua_State *L, const char *tname)-{-  int created = luaL_newmetatable(L, tname);-  if (created) {-    /* Prevent accessing or changing the metatable with-     * getmetatable/setmetatable. */-    lua_pushboolean(L, 1);-    lua_setfield(L, -2, "__metatable");-    /* Mark objects for finalization when collecting garbage. */-    lua_pushcfunction(L, &hslua_userdata_gc);-    lua_setfield(L, -2, "__gc");-  }-  return created;-}

@@ -1,11 +0,0 @@-#include <HsFFI.h>-#include <lua.h>--/* ***************************************************************- * Userdata for Haskell values- * ***************************************************************/--/*-** Creates a new userdata metatable for Haskell objects.-*/-int hslua_newudmetatable(lua_State *L, const char *tname);

@@ -1,1299 +0,0 @@-/*-** $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 *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");-  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);-    }-    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) {-  UpVal **up1 = getupvalref(L, fidx1, n1);-  UpVal **up2 = getupvalref(L, fidx2, n2);-  if (*up1 == *up2)-    return;-  luaC_upvdeccount(L, *up1);-  *up1 = *up2;-  (*up1)->refcount++;-  if (upisopen(*up1)) (*up1)->u.open.touched = 1;-  luaC_upvalbarrier(L, *up1);-}--

@@ -1,24 +0,0 @@-/*-** $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

@@ -1,1048 +0,0 @@-/*-** $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 {  /* cannot fail when shrinking a block */-    void *newptr = realloc(ptr, nsize);-    if (newptr == NULL && ptr != NULL && nsize <= osize)-      return ptr;  /* keep the original block */-    else  /* no fail or not shrinking */-     return newptr;  /* use the new block */-  }-}---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);-}-

@@ -1,264 +0,0 @@-/*-** $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--

@@ -1,498 +0,0 @@-/*-** $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;-}-

@@ -1,233 +0,0 @@-/*-** $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					/* } */

@@ -1,1203 +0,0 @@-/*-** $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;-}---/*-** Apply 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 */-}-

@@ -1,88 +0,0 @@-/*-** $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

@@ -1,168 +0,0 @@-/*-** $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;-}-

@@ -1,55 +0,0 @@-/*-** $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			/* } */

@@ -1,95 +0,0 @@-/*-** $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-

@@ -1,456 +0,0 @@-/*-** $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;-}-

@@ -1,700 +0,0 @@-/*-** $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;-  int nvararg = cast_int(ci->u.l.base - ci->func) - nparams;-  if (n <= -nvararg)-    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);-  }-}-

@@ -1,39 +0,0 @@-/*-** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 roberto Exp $-** Auxiliary functions from Debug Interface module-** See Copyright Notice in lua.h-*/--#ifndef ldebug_h-#define ldebug_h---#include "lstate.h"---#define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)--#define getfuncline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : -1)--#define resethookcount(L)	(L->hookcount = L->basehookcount)---LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,-                                                const char *opname);-LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,-                                                  const TValue *p2);-LUAI_FUNC l_noret luaG_opinterror (lua_State *L, const TValue *p1,-                                                 const TValue *p2,-                                                 const char *msg);-LUAI_FUNC l_noret luaG_tointerror (lua_State *L, const TValue *p1,-                                                 const TValue *p2);-LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,-                                                 const TValue *p2);-LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);-LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,-                                                  TString *src, int line);-LUAI_FUNC l_noret luaG_errormsg (lua_State *L);-LUAI_FUNC void luaG_traceexec (lua_State *L);---#endif