hslua 0.3.13 → 0.4.0

raw patch · 119 files changed

+17161/−17169 lines, 119 filesdep +HUnitdep +bytestringdep +hspecdep −mtldep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: HUnit, bytestring, hspec, hspec-contrib, text

Dependencies removed: mtl

Dependency ranges changed: base

API changes (from Hackage documentation)

Files

• CHANGELOG.md +21/−0
• COPYRIGHT +3/−2
• cbits/ntrljmp.c +0/−22
• examples/callbacks/callbacks.hs +99/−0
• examples/callbacks/callbacks.lua +36/−0
• examples/err_prop/err_prop.hs +86/−0
• examples/err_prop/err_prop.lua +15/−0
• examples/haskellfun/haskellfun.hs +31/−0
• examples/haskellfun/haskellfun.lua +15/−0
• hslua.cabal +95/−42
• lua-5.1.5/lapi.c +1087/−0
• lua-5.1.5/lapi.h +16/−0
• lua-5.1.5/lauxlib.c +652/−0
• lua-5.1.5/lauxlib.h +174/−0
• lua-5.1.5/lbaselib.c +653/−0
• lua-5.1.5/lcode.c +831/−0
• lua-5.1.5/lcode.h +76/−0
• lua-5.1.5/ldblib.c +398/−0
• lua-5.1.5/ldebug.c +638/−0
• lua-5.1.5/ldebug.h +33/−0
• lua-5.1.5/ldo.c +519/−0
• lua-5.1.5/ldo.h +57/−0
• lua-5.1.5/ldump.c +164/−0
• lua-5.1.5/lfunc.c +174/−0
• lua-5.1.5/lfunc.h +34/−0
• lua-5.1.5/lgc.c +710/−0
• lua-5.1.5/lgc.h +110/−0
• lua-5.1.5/linit.c +38/−0
• lua-5.1.5/liolib.c +556/−0
• lua-5.1.5/llex.c +463/−0
• lua-5.1.5/llex.h +81/−0
• lua-5.1.5/llimits.h +128/−0
• lua-5.1.5/lmathlib.c +263/−0
• lua-5.1.5/lmem.c +86/−0
• lua-5.1.5/lmem.h +49/−0
• lua-5.1.5/loadlib.c +666/−0
• lua-5.1.5/lobject.c +214/−0
• lua-5.1.5/lobject.h +381/−0
• lua-5.1.5/lopcodes.c +102/−0
• lua-5.1.5/lopcodes.h +268/−0
• lua-5.1.5/loslib.c +243/−0
• lua-5.1.5/lparser.c +1339/−0
• lua-5.1.5/lparser.h +82/−0
• lua-5.1.5/lstate.c +214/−0
• lua-5.1.5/lstate.h +169/−0
• lua-5.1.5/lstring.c +111/−0
• lua-5.1.5/lstring.h +31/−0
• lua-5.1.5/lstrlib.c +871/−0
• lua-5.1.5/ltable.c +588/−0
• lua-5.1.5/ltable.h +40/−0
• lua-5.1.5/ltablib.c +287/−0
• lua-5.1.5/ltm.c +75/−0
• lua-5.1.5/ltm.h +54/−0
• lua-5.1.5/lua.h +388/−0
• lua-5.1.5/luaconf.h +763/−0
• lua-5.1.5/lualib.h +53/−0
• lua-5.1.5/lundump.c +227/−0
• lua-5.1.5/lundump.h +36/−0
• lua-5.1.5/lvm.c +767/−0
• lua-5.1.5/lvm.h +36/−0
• lua-5.1.5/lzio.c +82/−0
• lua-5.1.5/lzio.h +67/−0
• src/Scripting/Lua.hsc +303/−536
• src/Scripting/Lua/ConfigFile.hs +0/−423
• src/Scripting/Lua/Raw.hsc +301/−0
• src/lapi.c +0/−1087
• src/lapi.h +0/−16
• src/lauxlib.c +0/−652
• src/lauxlib.h +0/−174
• src/lbaselib.c +0/−653
• src/lcode.c +0/−839
• src/lcode.h +0/−76
• src/ldblib.c +0/−397
• src/ldebug.c +0/−638
• src/ldebug.h +0/−33
• src/ldo.c +0/−518
• src/ldo.h +0/−57
• src/ldump.c +0/−164
• src/lfunc.c +0/−174
• src/lfunc.h +0/−34
• src/lgc.c +0/−711
• src/lgc.h +0/−110
• src/linit.c +0/−38
• src/liolib.c +0/−553
• src/llex.c +0/−461
• src/llex.h +0/−81
• src/llimits.h +0/−128
• src/lmathlib.c +0/−263
• src/lmem.c +0/−86
• src/lmem.h +0/−49
• src/loadlib.c +0/−666
• src/lobject.c +0/−214
• src/lobject.h +0/−381
• src/lopcodes.c +0/−102
• src/lopcodes.h +0/−268
• src/loslib.c +0/−243
• src/lparser.c +0/−1339
• src/lparser.h +0/−82
• src/lstate.c +0/−214
• src/lstate.h +0/−169
• src/lstring.c +0/−111
• src/lstring.h +0/−31
• src/lstrlib.c +0/−869
• src/ltable.c +0/−588
• src/ltable.h +0/−40
• src/ltablib.c +0/−287
• src/ltm.c +0/−75
• src/ltm.h +0/−54
• src/lua.h +0/−388
• src/luaconf.h +0/−763
• src/lualib.h +0/−53
• src/lundump.c +0/−227
• src/lundump.h +0/−36
• src/lvm.c +0/−763
• src/lvm.h +0/−36
• src/lzio.c +0/−82
• src/lzio.h +0/−67
• test/Spec.hs +1/−0
• test/simple-test.hs +11/−4

@@ -1,5 +1,26 @@ ## Changelog +### 0.4.0++* `pushstring` and `tostring` now uses `ByteString` instead of `[Char]`.+* `StackValue [Char]` instance is removed, `StackValue ByteString` is added.+* `StackValue a => StackValue [a]` instance is added. It pushes a Lua array to+  the stack. `pushlist`, `islist` and `tolist` functions are added.+* Type errors in Haskell functions now propagated differently. See the+  `Scripting.Lua` documentation for detailed explanation. This should fix+  segfaults reported several times.+* `lua_error` function is removed, it's never safe to call in Haskell.++Related issues and pull requests: #12, #26, #24, #23, #18.++### 0.3.14++* Pkgconf-based setup removed. Cabal is now using `extra-libraries` to link with Lua.+* `luajit` flag is added to link hslua with LuaJIT.++### 0.3.13++* Small bugfix related with GHCi running under Windows.  ### 0.3.12 

@@ -9,8 +9,9 @@  =============================================================================== -Copyright (C) 1994-2007 Lua.org, PUC-Rio.-Copyright (C) 2007 Gracjan Polak+Copyright (C) 1994-2012 Lua.org, PUC-Rio.+Copyright (C) 2007-2012 Gracjan Polak+Copyright (C) 2012-2015 Ömer Sinan Ağacan  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal

@@ -1,22 +0,0 @@-/*-** See Copyright Notice in lua.h-*/--#include <ctype.h>-#include <stdio.h>--#define luac_c-#define LUA_CORE--#include "lua.h"--extern int hsmethod__call( lua_State *state );--LUAI_FUNC int lua_neutralize_longjmp( lua_State *state )-{-    int result;-    result = hsmethod__call(state);-    if( result <0 )-        return lua_error(state);-    return result;-}

@@ -0,0 +1,99 @@+{-# LANGUAGE OverloadedStrings #-}++-- An example hslua program that demonstrates providing Haskell callbacks+-- to Lua and getting Lua callbacks from Haskell.++import qualified Data.ByteString.Char8 as BC+import Data.IORef+import Foreign.C.Types (CInt)+import Scripting.Lua as Lua++main :: IO ()+main = do+    callbacks <- newIORef []+    l <- newstate+    openlibs l+    registerrawhsfunction l "addLuaCallbacks" (addLuaCallbacks callbacks)+    registerrawhsfunction l "callLuaCallbacks" (callLuaCallbacks callbacks)+    registerrawhsfunction l "resetLuaCallbacks" (resetLuaCallbacks callbacks)+    loadfile l "examples/callbacks/callbacks.lua"+    call l 0 0+    close l++type LuaFunRef = Int++-- | Get Lua callbacks as argument to later call them in order.+-- Successive calls to this function without calling `resetLuaCallbacks`+-- adds more callbacks to the queue.+-- (I know lists are not the best functional queue implementations ...)+addLuaCallbacks :: IORef [LuaFunRef] -> LuaState -> IO CInt+addLuaCallbacks cs l = do+    -- number of arguments passed to this function+    args <- gettop l+    -- make sure arguments are functions+    as <- checkArgs args+    case as of+      Nothing -> do+        -- arguments are functions, add them to callback queue and return+        -- nothing+        addCallbacks 1 args+        return 0+      Just errArg -> do+        -- error: argument at `errArg` is not a function, return error+        -- string+        pushstring l $ BC.pack $+          "argument " ++ show errArg ++ " is not a function"+        return 1+  where+    -- | Check if all arguments are functions, return `Just argIdx` if+    -- argument at `argIdx` is not a function and `Nothing` otherwise.+    checkArgs :: Int -> IO (Maybe Int)+    checkArgs 0 = return Nothing+    checkArgs n = do+      ty <- ltype l n+      if ty == TFUNCTION+        then checkArgs (n-1)+        else return $ Just n++    addCallbacks n max+      | n > max = return ()+      | otherwise = do+          -- move nth argument to top of the stack+          pushvalue l n+          -- add function reference to registry+          refId <- ref l registryindex+          -- add registry index to IORef+          modifyIORef cs (++ [refId])+          -- continue adding other arguments+          addCallbacks (n+1) max++-- | Call Lua callbacks collected with `addLuaCallbacks`.+callLuaCallbacks :: IORef [LuaFunRef] -> LuaState -> IO CInt+callLuaCallbacks cs l = do+    cs' <- readIORef cs+    -- push new array to the stack+    createtable l (length cs') 0+    -- call callbacks and fill array with return values+    iter cs'+    return 1+  where+    iter [] = return ()+    iter (c : rest) = do+      getglobal2 l "table.insert"+      pushvalue l (-2)+      pushinteger l (fromIntegral c)+      gettable l registryindex+      -- call the callback+      pcall l 0 1 0+      -- call table.insert+      pcall l 2 0 0+      iter rest++-- | Reset callback queue and remove Lua functions from registry to enable+-- garbage collection.+resetLuaCallbacks :: IORef [LuaFunRef] -> LuaState -> IO CInt+resetLuaCallbacks cs l = do+    cs' <- readIORef cs+    mapM_ (unref l registryindex) cs'+    writeIORef cs []+    return 0

@@ -0,0 +1,36 @@+local function c1()+  print("callback 1")+  return "callback 1 return value"+end++local function c2()+  print("callback 2")+  return false+end++local function c3()+  print("callback 3")+  return 3+end++local function c_fails()+  print("Failing from Lua")+  error("failed")+end++print("begin")+addLuaCallbacks(c1, c2)+callLuaCallbacks()+print("reset callbacks")+resetLuaCallbacks()+callLuaCallbacks()+print("add callbacks in reverse order")+addLuaCallbacks(c3)+addLuaCallbacks(c2)+addLuaCallbacks(c1)+addLuaCallbacks(c_fails)+local callbackrets = callLuaCallbacks()+for _, v in ipairs(callbackrets) do+  print(v)+end+print("end")

@@ -0,0 +1,86 @@+{-# LANGUAGE OverloadedStrings #-}++-- An example program that demonstrates error propagation between Haskell and+-- Lua. It creates a function call stack with 10 functions, like this:+--+--   Lua function+--   ...+--   Haskell function+--   Lua function+--   Program+--+-- And then the function at the top throws an error, according to the error+-- conventions described in the docs. Error is propagated to the program at the+-- bottom.+--+-- Then same thing happens, starting with Haskell function:+--+--   Haskell function+--   ...+--   Lua function+--   Haskell function+--   Program++import qualified Data.ByteString.Char8 as BC+import Foreign.C.Types (CInt)+import Scripting.Lua as Lua++main :: IO ()+main = do+    l <- newstate+    openlibs l+    registerrawhsfunction l "fail_when_zero_haskell" failWhenZero++    -- Define the Lua function+    loadfile l "examples/err_prop/err_prop.lua"+    call l 0 0++    -- Start the loop by calling Lua function with argument 10+    getfield l globalsindex "fail_when_zero"+    pushinteger l 10+    -- Since Lua function will be the one that propagates error to the program,+    -- we need to catch it using `pcall`+    ret <- pcall l 1 1 0+    errMsg <- tostring l 1+    putStrLn $ "ret: " ++ show ret -- TODO: Implement pcall return values as a type+    putStrLn $ "errMsg: " ++ BC.unpack errMsg++    top <- gettop l+    putStrLn $ "top: " ++ show top+    pop l 1++    -- start the loop by calling Haskell function with argument 10+    getfield l globalsindex "fail_when_zero_haskell"+    pushinteger l 10+    -- Our convention is that Haskell functions never use `lua_error` because+    -- it's never safe(it's not even exported by the library for this reason).+    -- So if we're calling a Haskell function that `pcall` and `call` does the+    -- same thing.+    call l 1 2+    -- We know it failed, so just read the error message without checking first+    -- argument+    errMsg <- tostring l 2+    putStrLn $ "errMsg: " ++ BC.unpack errMsg+    pop l 2++    close l++failWhenZero :: LuaState -> IO CInt+failWhenZero l = do+    i <- tointeger l 1+    putStrLn $ "Haskell: " ++ show i+    if i == 0+      then pushstring l "Failing from Haskell" >> fmap fromIntegral (lerror l)+      else do+        getfield l globalsindex "fail_when_zero"+        pushinteger l (i - 1)+        ret <- pcall l 1 1 0+        if ret /= 0+          then+            -- propagate the error. no need to push error message since it's+            -- already at the top of the stack at this point. (because of how+            -- `pcall` works)+            fmap fromIntegral (lerror l)+          else+            -- Lua function's return value is on the stack, return it+            return 1

@@ -0,0 +1,15 @@+local function catch_haskell(ret, err_msg)+    if ret == _HASKELLERR then+      -- `error` call adds a prefix to error message+      error(err_msg)+    end+    return ret+end++function fail_when_zero(n)+  print("Lua: " .. tostring(n))+  if n == 0 then+    error("Failing from Lua")+  end+  return catch_haskell(fail_when_zero_haskell(n - 1))+end

@@ -0,0 +1,31 @@+{-# LANGUAGE OverloadedStrings #-}++-- An example with higher-level Haskell functions. Haskell functions are+-- wrapped by hslua automatically for ensuring argument types and nubmers+-- and passing arguments from Lua stack to Haskell functions. Return values+-- are also handled by hslua automatically(so you don't put return value to+-- stack manually).++import qualified Data.ByteString as B+import Data.Monoid+import Scripting.Lua as Lua++main :: IO ()+main = do+    l <- newstate+    openlibs l+    registerhsfunction l "concat" concat'+    registerhsfunction l "pow" pow+    registerhsfunction l "helloWorld" helloWorld+    loadfile l "examples/haskellfun/haskellfun.lua"+    call l 0 0+    close l++concat' :: B.ByteString -> B.ByteString -> IO B.ByteString+concat' s1 s2 = return $ s1 <> s2++pow :: Double -> Double -> IO Double+pow d1 d2 = return $ d1 ** d2++helloWorld :: IO B.ByteString+helloWorld = return "Hello, World!"

@@ -0,0 +1,15 @@+_HASKELLERR = {}++function catch_haskell(ret, err_msg)+    if ret == _HASKELLERR then+      print("Error caught from Haskell land: " .. err_msg)+      return+    end+    return ret+end++print(concat("hello", " world!"))+print(catch_haskell(pow(3.2, 5)))+print(catch_haskell(helloWorld()))+print(catch_haskell(pow("wrong")))+print(catch_haskell(pow(3)))

@@ -1,71 +1,124 @@-Name:                   hslua-Version:                0.3.13-Stability:              beta-Cabal-version:          >= 1.8-License:                MIT-Build-type:             Simple-License-File:           COPYRIGHT-Copyright:              2007-2012, Gracjan Polak-Author:                 Gracjan Polak, Ömer Sinan Ağacan-Maintainer:             omeragacan@gmail.com-Synopsis:               A Lua language interpreter embedding in Haskell-Description:            The Scripting.Lua module is a wrapper of Lua language interpreter-                        as described in www.lua.org.+name:                   hslua+version:                0.4.0+stability:              beta+cabal-version:          >= 1.8+license:                MIT+build-type:             Simple+license-File:           COPYRIGHT+copyright:              Gracjan Polak 2007-2012, Ömer Sinan Ağacan 2012-2015+author:                 Gracjan Polak, Ömer Sinan Ağacan+maintainer:             omeragacan@gmail.com+synopsis:               A Lua language interpreter embedding in Haskell+description:            The Scripting.Lua module is a wrapper of Lua language interpreter+                        as described in [lua.org](http://www.lua.org/).                         .-                        This package contains full Lua interpreter version 5.1.4.-                        If you want to link it with system-wide Lua installation, use system-lua flag.-Category:               Scripting-Extra-source-files:     src/*.h+                        This package contains full Lua interpreter version 5.1.5.+                        If you want to link it with system-wide Lua installation, use @system-lua@ flag.+                        .+                        [Example programs](https://github.com/osa1/hslua/tree/master/examples)+category:               Scripting+extra-source-files:     lua-5.1.5/*.h                         CHANGELOG.md                         COPYRIGHT+                        examples/callbacks/callbacks.lua+                        examples/haskellfun/haskellfun.lua+                        examples/err_prop/err_prop.lua  source-repository head   type:                 git   location:             https://github.com/osa1/hslua.git  flag system-lua-  description:          Use the system-wide lua instead of the bundled copy+  description:          Use the system-wide Lua instead of the bundled copy   default:              False  flag apicheck   description:          Compile Lua with -DLUA_USE_APICHECK.   default:              False -Library-  Build-depends:        base==4.*, mtl >= 2.1-  Exposed-modules:      Scripting.Lua, Scripting.Lua.ConfigFile-  Hs-source-dirs:       src+flag luajit+  description:          Link with LuaJIT (should be used with -fsystem-lua)+  default:              False++library+  build-depends:        base == 4.*, bytestring >= 0.10 && < 0.11+  exposed-modules:      Scripting.Lua, Scripting.Lua.Raw+  hs-source-dirs:       src+  ghc-options:          -Wall -O2   if flag(system-lua)-    Pkgconfig-depends:  lua-    C-sources:          cbits/ntrljmp.c-    Include-dirs:       cbits+    if flag(luajit)+      Extra-libraries:  luajit-5.1+    else+      Extra-libraries:  lua+    includes:           lua.h   else-    C-sources:          src/lapi.c, src/lauxlib.c, src/lbaselib.c, src/lcode.c,-                        src/ldblib.c, src/ldebug.c, src/ldo.c, src/ldump.c, src/lfunc.c,-                        src/lgc.c, src/linit.c, src/liolib.c, src/llex.c, src/lmathlib.c,-                        src/lmem.c, src/loadlib.c, src/lobject.c, src/lopcodes.c,-                        src/loslib.c, src/lparser.c, src/lstate.c, src/lstring.c,-                        src/lstrlib.c, src/ltable.c, src/ltablib.c, src/ltm.c,-                        src/lundump.c, src/lvm.c, src/lzio.c, cbits/ntrljmp.c-    Include-dirs:       src, cbits+    c-sources:          lua-5.1.5/lobject.c, lua-5.1.5/ltm.c, lua-5.1.5/ldblib.c,+                        lua-5.1.5/ldo.c, lua-5.1.5/lvm.c, lua-5.1.5/ltable.c,+                        lua-5.1.5/lstrlib.c, lua-5.1.5/lfunc.c,+                        lua-5.1.5/lstate.c, lua-5.1.5/lmathlib.c, lua-5.1.5/lmem.c,+                        lua-5.1.5/ltablib.c, lua-5.1.5/lzio.c, lua-5.1.5/lstring.c,+                        lua-5.1.5/ldump.c, lua-5.1.5/linit.c, lua-5.1.5/lbaselib.c,+                        lua-5.1.5/lauxlib.c, lua-5.1.5/lopcodes.c, lua-5.1.5/lgc.c,+                        lua-5.1.5/lcode.c, lua-5.1.5/loadlib.c, lua-5.1.5/lapi.c,+                        lua-5.1.5/lundump.c, lua-5.1.5/loslib.c, lua-5.1.5/lparser.c,+                        lua-5.1.5/ldebug.c, lua-5.1.5/liolib.c,+                        lua-5.1.5/llex.c +    include-dirs:       lua-5.1.5+   if os(linux)-    CC-Options:         "-DLUA_USE_LINUX"+    cc-options:         "-DLUA_USE_LINUX"    if os(darwin)-    CC-Options:         "-DLUA_USE_MACOSX"+    cc-options:         "-DLUA_USE_MACOSX"    if os(freebsd)-    CC-Options:         "-DLUA_USE_POSIX"+    cc-options:         "-DLUA_USE_POSIX"    if os(windows)-     CC-options:        "-D__NO_ISOCEXT"-    +     cc-options:        "-D__NO_ISOCEXT"+   if flag(apicheck)-    CC-Options:         "-DLUA_USE_APICHECK"+    cc-Options:         "-DLUA_USE_APICHECK" -Test-Suite simple-test+-- This is not necessary because we have a test suite now. Still keeping here as+-- a very simple test. Originally added with 799a4c2 to test if linking with+-- system-wide Lua is really working.+test-suite simple-test   type:                 exitcode-stdio-1.0-  Hs-source-dirs:       test   main-is:              simple-test.hs-  Build-depends:        base, hslua+  hs-source-dirs:       test+  build-depends:        base, hslua++test-suite callbacks+  type:                 exitcode-stdio-1.0+  main-is:              callbacks.hs+  hs-source-dirs:       examples/callbacks+  build-depends:        base, bytestring, hslua++test-suite haskellfun+  type:                 exitcode-stdio-1.0+  main-is:              haskellfun.hs+  hs-source-dirs:       examples/haskellfun+  build-depends:        base, bytestring, hslua++test-suite err_prop+  type:                 exitcode-stdio-1.0+  main-is:              err_prop.hs+  hs-source-dirs:       examples/err_prop+  build-depends:        base, bytestring, hslua++test-suite test+  type:                 exitcode-stdio-1.0+  main-is:              Spec.hs+  hs-source-dirs:       test+  ghc-options:          -Wall -threaded++  build-depends:+    base,+    bytestring,+    hslua,+    hspec,+    hspec-contrib,+    HUnit,+    text

@@ -0,0 +1,1087 @@+/*+** $Id: lapi.c,v 2.55.1.5 2008/07/04 18:41:18 roberto Exp $+** Lua API+** See Copyright Notice in lua.h+*/+++#include <assert.h>+#include <math.h>+#include <stdarg.h>+#include <string.h>++#define lapi_c+#define LUA_CORE++#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[] =+  "$Lua: " LUA_RELEASE " " LUA_COPYRIGHT " $\n"+  "$Authors: " LUA_AUTHORS " $\n"+  "$URL: www.lua.org $\n";++++#define api_checknelems(L, n)	api_check(L, (n) <= (L->top - L->base))++#define api_checkvalidindex(L, i)	api_check(L, (i) != luaO_nilobject)++#define api_incr_top(L)   {api_check(L, L->top < L->ci->top); L->top++;}++++static TValue *index2adr (lua_State *L, int idx) {+  if (idx > 0) {+    TValue *o = L->base + (idx - 1);+    api_check(L, idx <= L->ci->top - L->base);+    if (o >= L->top) return cast(TValue *, luaO_nilobject);+    else return o;+  }+  else if (idx > LUA_REGISTRYINDEX) {+    api_check(L, idx != 0 && -idx <= L->top - L->base);+    return L->top + idx;+  }+  else switch (idx) {  /* pseudo-indices */+    case LUA_REGISTRYINDEX: return registry(L);+    case LUA_ENVIRONINDEX: {+      Closure *func = curr_func(L);+      sethvalue(L, &L->env, func->c.env);+      return &L->env;+    }+    case LUA_GLOBALSINDEX: return gt(L);+    default: {+      Closure *func = curr_func(L);+      idx = LUA_GLOBALSINDEX - idx;+      return (idx <= func->c.nupvalues)+                ? &func->c.upvalue[idx-1]+                : cast(TValue *, luaO_nilobject);+    }+  }+}+++static Table *getcurrenv (lua_State *L) {+  if (L->ci == L->base_ci)  /* no enclosing function? */+    return hvalue(gt(L));  /* use global table as environment */+  else {+    Closure *func = curr_func(L);+    return func->c.env;+  }+}+++void luaA_pushobject (lua_State *L, const TValue *o) {+  setobj2s(L, L->top, o);+  api_incr_top(L);+}+++LUA_API int lua_checkstack (lua_State *L, int size) {+  int res = 1;+  lua_lock(L);+  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)+    res = 0;  /* stack overflow */+  else if (size > 0) {+    luaD_checkstack(L, size);+    if (L->ci->top < L->top + size)+      L->ci->top = L->top + size;+  }+  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));+  api_check(from, to->ci->top - to->top >= n);+  from->top -= n;+  for (i = 0; i < n; i++) {+    setobj2s(to, to->top++, from->top + i);+  }+  lua_unlock(to);+}+++LUA_API void lua_setlevel (lua_State *from, lua_State *to) {+  to->nCcalls = from->nCcalls;+}+++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 lua_State *lua_newthread (lua_State *L) {+  lua_State *L1;+  lua_lock(L);+  luaC_checkGC(L);+  L1 = luaE_newthread(L);+  setthvalue(L, L->top, L1);+  api_incr_top(L);+  lua_unlock(L);+  luai_userstatethread(L, L1);+  return L1;+}++++/*+** basic stack manipulation+*/+++LUA_API int lua_gettop (lua_State *L) {+  return cast_int(L->top - L->base);+}+++LUA_API void lua_settop (lua_State *L, int idx) {+  lua_lock(L);+  if (idx >= 0) {+    api_check(L, idx <= L->stack_last - L->base);+    while (L->top < L->base + idx)+      setnilvalue(L->top++);+    L->top = L->base + idx;+  }+  else {+    api_check(L, -(idx+1) <= (L->top - L->base));+    L->top += idx+1;  /* `subtract' index (index is negative) */+  }+  lua_unlock(L);+}+++LUA_API void lua_remove (lua_State *L, int idx) {+  StkId p;+  lua_lock(L);+  p = index2adr(L, idx);+  api_checkvalidindex(L, p);+  while (++p < L->top) setobjs2s(L, p-1, p);+  L->top--;+  lua_unlock(L);+}+++LUA_API void lua_insert (lua_State *L, int idx) {+  StkId p;+  StkId q;+  lua_lock(L);+  p = index2adr(L, idx);+  api_checkvalidindex(L, p);+  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);+  setobjs2s(L, p, L->top);+  lua_unlock(L);+}+++LUA_API void lua_replace (lua_State *L, int idx) {+  StkId o;+  lua_lock(L);+  /* explicit test for incompatible code */+  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)+    luaG_runerror(L, "no calling environment");+  api_checknelems(L, 1);+  o = index2adr(L, idx);+  api_checkvalidindex(L, o);+  if (idx == LUA_ENVIRONINDEX) {+    Closure *func = curr_func(L);+    api_check(L, ttistable(L->top - 1)); +    func->c.env = hvalue(L->top - 1);+    luaC_barrier(L, func, L->top - 1);+  }+  else {+    setobj(L, o, L->top - 1);+    if (idx < LUA_GLOBALSINDEX)  /* function upvalue? */+      luaC_barrier(L, curr_func(L), L->top - 1);+  }+  L->top--;+  lua_unlock(L);+}+++LUA_API void lua_pushvalue (lua_State *L, int idx) {+  lua_lock(L);+  setobj2s(L, L->top, index2adr(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 = index2adr(L, idx);+  return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);+}+++LUA_API const char *lua_typename (lua_State *L, int t) {+  UNUSED(L);+  return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];+}+++LUA_API int lua_iscfunction (lua_State *L, int idx) {+  StkId o = index2adr(L, idx);+  return iscfunction(o);+}+++LUA_API int lua_isnumber (lua_State *L, int idx) {+  TValue n;+  const TValue *o = index2adr(L, idx);+  return tonumber(o, &n);+}+++LUA_API int lua_isstring (lua_State *L, int idx) {+  int t = lua_type(L, idx);+  return (t == LUA_TSTRING || t == LUA_TNUMBER);+}+++LUA_API int lua_isuserdata (lua_State *L, int idx) {+  const TValue *o = index2adr(L, idx);+  return (ttisuserdata(o) || ttislightuserdata(o));+}+++LUA_API int lua_rawequal (lua_State *L, int index1, int index2) {+  StkId o1 = index2adr(L, index1);+  StkId o2 = index2adr(L, index2);+  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0+         : luaO_rawequalObj(o1, o2);+}+++LUA_API int lua_equal (lua_State *L, int index1, int index2) {+  StkId o1, o2;+  int i;+  lua_lock(L);  /* may call tag method */+  o1 = index2adr(L, index1);+  o2 = index2adr(L, index2);+  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);+  lua_unlock(L);+  return i;+}+++LUA_API int lua_lessthan (lua_State *L, int index1, int index2) {+  StkId o1, o2;+  int i;+  lua_lock(L);  /* may call tag method */+  o1 = index2adr(L, index1);+  o2 = index2adr(L, index2);+  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0+       : luaV_lessthan(L, o1, o2);+  lua_unlock(L);+  return i;+}++++LUA_API lua_Number lua_tonumber (lua_State *L, int idx) {+  TValue n;+  const TValue *o = index2adr(L, idx);+  if (tonumber(o, &n))+    return nvalue(o);+  else+    return 0;+}+++LUA_API lua_Integer lua_tointeger (lua_State *L, int idx) {+  TValue n;+  const TValue *o = index2adr(L, idx);+  if (tonumber(o, &n)) {+    lua_Integer res;+    lua_Number num = nvalue(o);+    lua_number2integer(res, num);+    return res;+  }+  else+    return 0;+}+++LUA_API int lua_toboolean (lua_State *L, int idx) {+  const TValue *o = index2adr(L, idx);+  return !l_isfalse(o);+}+++LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) {+  StkId o = index2adr(L, idx);+  if (!ttisstring(o)) {+    lua_lock(L);  /* `luaV_tostring' may create a new string */+    if (!luaV_tostring(L, o)) {  /* conversion failed? */+      if (len != NULL) *len = 0;+      lua_unlock(L);+      return NULL;+    }+    luaC_checkGC(L);+    o = index2adr(L, idx);  /* previous call may reallocate the stack */+    lua_unlock(L);+  }+  if (len != NULL) *len = tsvalue(o)->len;+  return svalue(o);+}+++LUA_API size_t lua_objlen (lua_State *L, int idx) {+  StkId o = index2adr(L, idx);+  switch (ttype(o)) {+    case LUA_TSTRING: return tsvalue(o)->len;+    case LUA_TUSERDATA: return uvalue(o)->len;+    case LUA_TTABLE: return luaH_getn(hvalue(o));+    case LUA_TNUMBER: {+      size_t l;+      lua_lock(L);  /* `luaV_tostring' may create a new string */+      l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);+      lua_unlock(L);+      return l;+    }+    default: return 0;+  }+}+++LUA_API lua_CFunction lua_tocfunction (lua_State *L, int idx) {+  StkId o = index2adr(L, idx);+  return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;+}+++LUA_API void *lua_touserdata (lua_State *L, int idx) {+  StkId o = index2adr(L, idx);+  switch (ttype(o)) {+    case LUA_TUSERDATA: return (rawuvalue(o) + 1);+    case LUA_TLIGHTUSERDATA: return pvalue(o);+    default: return NULL;+  }+}+++LUA_API lua_State *lua_tothread (lua_State *L, int idx) {+  StkId o = index2adr(L, idx);+  return (!ttisthread(o)) ? NULL : thvalue(o);+}+++LUA_API const void *lua_topointer (lua_State *L, int idx) {+  StkId o = index2adr(L, idx);+  switch (ttype(o)) {+    case LUA_TTABLE: return hvalue(o);+    case LUA_TFUNCTION: return clvalue(o);+    case LUA_TTHREAD: return thvalue(o);+    case LUA_TUSERDATA:+    case LUA_TLIGHTUSERDATA:+      return lua_touserdata(L, idx);+    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);+  setnvalue(L->top, n);+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {+  lua_lock(L);+  setnvalue(L->top, cast_num(n));+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_pushlstring (lua_State *L, const char *s, size_t len) {+  lua_lock(L);+  luaC_checkGC(L);+  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_pushstring (lua_State *L, const char *s) {+  if (s == NULL)+    lua_pushnil(L);+  else+    lua_pushlstring(L, s, strlen(s));+}+++LUA_API const char *lua_pushvfstring (lua_State *L, const char *fmt,+                                      va_list argp) {+  const char *ret;+  lua_lock(L);+  luaC_checkGC(L);+  ret = luaO_pushvfstring(L, fmt, argp);+  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);+  luaC_checkGC(L);+  va_start(argp, fmt);+  ret = luaO_pushvfstring(L, fmt, argp);+  va_end(argp);+  lua_unlock(L);+  return ret;+}+++LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {+  Closure *cl;+  lua_lock(L);+  luaC_checkGC(L);+  api_checknelems(L, n);+  cl = luaF_newCclosure(L, n, getcurrenv(L));+  cl->c.f = fn;+  L->top -= n;+  while (n--)+    setobj2n(L, &cl->c.upvalue[n], L->top+n);+  setclvalue(L, L->top, cl);+  lua_assert(iswhite(obj2gco(cl)));+  api_incr_top(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)+*/+++LUA_API void lua_gettable (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  t = index2adr(L, idx);+  api_checkvalidindex(L, t);+  luaV_gettable(L, t, L->top - 1, L->top - 1);+  lua_unlock(L);+}+++LUA_API void lua_getfield (lua_State *L, int idx, const char *k) {+  StkId t;+  TValue key;+  lua_lock(L);+  t = index2adr(L, idx);+  api_checkvalidindex(L, t);+  setsvalue(L, &key, luaS_new(L, k));+  luaV_gettable(L, t, &key, L->top);+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_rawget (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  t = index2adr(L, idx);+  api_check(L, ttistable(t));+  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));+  lua_unlock(L);+}+++LUA_API void lua_rawgeti (lua_State *L, int idx, int n) {+  StkId o;+  lua_lock(L);+  o = index2adr(L, idx);+  api_check(L, ttistable(o));+  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API void lua_createtable (lua_State *L, int narray, int nrec) {+  lua_lock(L);+  luaC_checkGC(L);+  sethvalue(L, L->top, luaH_new(L, narray, nrec));+  api_incr_top(L);+  lua_unlock(L);+}+++LUA_API int lua_getmetatable (lua_State *L, int objindex) {+  const TValue *obj;+  Table *mt = NULL;+  int res;+  lua_lock(L);+  obj = index2adr(L, objindex);+  switch (ttype(obj)) {+    case LUA_TTABLE:+      mt = hvalue(obj)->metatable;+      break;+    case LUA_TUSERDATA:+      mt = uvalue(obj)->metatable;+      break;+    default:+      mt = G(L)->mt[ttype(obj)];+      break;+  }+  if (mt == NULL)+    res = 0;+  else {+    sethvalue(L, L->top, mt);+    api_incr_top(L);+    res = 1;+  }+  lua_unlock(L);+  return res;+}+++LUA_API void lua_getfenv (lua_State *L, int idx) {+  StkId o;+  lua_lock(L);+  o = index2adr(L, idx);+  api_checkvalidindex(L, o);+  switch (ttype(o)) {+    case LUA_TFUNCTION:+      sethvalue(L, L->top, clvalue(o)->c.env);+      break;+    case LUA_TUSERDATA:+      sethvalue(L, L->top, uvalue(o)->env);+      break;+    case LUA_TTHREAD:+      setobj2s(L, L->top,  gt(thvalue(o)));+      break;+    default:+      setnilvalue(L->top);+      break;+  }+  api_incr_top(L);+  lua_unlock(L);+}+++/*+** set functions (stack -> Lua)+*/+++LUA_API void lua_settable (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  api_checknelems(L, 2);+  t = index2adr(L, idx);+  api_checkvalidindex(L, t);+  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) {+  StkId t;+  TValue key;+  lua_lock(L);+  api_checknelems(L, 1);+  t = index2adr(L, idx);+  api_checkvalidindex(L, t);+  setsvalue(L, &key, luaS_new(L, k));+  luaV_settable(L, t, &key, L->top - 1);+  L->top--;  /* pop value */+  lua_unlock(L);+}+++LUA_API void lua_rawset (lua_State *L, int idx) {+  StkId t;+  lua_lock(L);+  api_checknelems(L, 2);+  t = index2adr(L, idx);+  api_check(L, ttistable(t));+  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);+  luaC_barriert(L, hvalue(t), L->top-1);+  L->top -= 2;+  lua_unlock(L);+}+++LUA_API void lua_rawseti (lua_State *L, int idx, int n) {+  StkId o;+  lua_lock(L);+  api_checknelems(L, 1);+  o = index2adr(L, idx);+  api_check(L, ttistable(o));+  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);+  luaC_barriert(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 = index2adr(L, objindex);+  api_checkvalidindex(L, obj);+  if (ttisnil(L->top - 1))+    mt = NULL;+  else {+    api_check(L, ttistable(L->top - 1));+    mt = hvalue(L->top - 1);+  }+  switch (ttype(obj)) {+    case LUA_TTABLE: {+      hvalue(obj)->metatable = mt;+      if (mt)+        luaC_objbarriert(L, hvalue(obj), mt);+      break;+    }+    case LUA_TUSERDATA: {+      uvalue(obj)->metatable = mt;+      if (mt)+        luaC_objbarrier(L, rawuvalue(obj), mt);+      break;+    }+    default: {+      G(L)->mt[ttype(obj)] = mt;+      break;+    }+  }+  L->top--;+  lua_unlock(L);+  return 1;+}+++LUA_API int lua_setfenv (lua_State *L, int idx) {+  StkId o;+  int res = 1;+  lua_lock(L);+  api_checknelems(L, 1);+  o = index2adr(L, idx);+  api_checkvalidindex(L, o);+  api_check(L, ttistable(L->top - 1));+  switch (ttype(o)) {+    case LUA_TFUNCTION:+      clvalue(o)->c.env = hvalue(L->top - 1);+      break;+    case LUA_TUSERDATA:+      uvalue(o)->env = hvalue(L->top - 1);+      break;+    case LUA_TTHREAD:+      sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));+      break;+    default:+      res = 0;+      break;+  }+  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));+  L->top--;+  lua_unlock(L);+  return res;+}+++/*+** `load' and `call' functions (run Lua code)+*/+++#define adjustresults(L,nres) \+    { if (nres == LUA_MULTRET && L->top >= L->ci->top) L->ci->top = L->top; }+++#define checkresults(L,na,nr) \+     api_check(L, (nr) == LUA_MULTRET || (L->ci->top - L->top >= (nr) - (na)))+	++LUA_API void lua_call (lua_State *L, int nargs, int nresults) {+  StkId func;+  lua_lock(L);+  api_checknelems(L, nargs+1);+  checkresults(L, nargs, nresults);+  func = L->top - (nargs+1);+  luaD_call(L, func, nresults);+  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_call(L, c->func, c->nresults);+}++++LUA_API int lua_pcall (lua_State *L, int nargs, int nresults, int errfunc) {+  struct CallS c;+  int status;+  ptrdiff_t func;+  lua_lock(L);+  api_checknelems(L, nargs+1);+  checkresults(L, nargs, nresults);+  if (errfunc == 0)+    func = 0;+  else {+    StkId o = index2adr(L, errfunc);+    api_checkvalidindex(L, o);+    func = savestack(L, o);+  }+  c.func = L->top - (nargs+1);  /* function to be called */+  c.nresults = nresults;+  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);+  adjustresults(L, nresults);+  lua_unlock(L);+  return status;+}+++/*+** Execute a protected C call.+*/+struct CCallS {  /* data to `f_Ccall' */+  lua_CFunction func;+  void *ud;+};+++static void f_Ccall (lua_State *L, void *ud) {+  struct CCallS *c = cast(struct CCallS *, ud);+  Closure *cl;+  cl = luaF_newCclosure(L, 0, getcurrenv(L));+  cl->c.f = c->func;+  setclvalue(L, L->top, cl);  /* push function */+  api_incr_top(L);+  setpvalue(L->top, c->ud);  /* push only argument */+  api_incr_top(L);+  luaD_call(L, L->top - 2, 0);+}+++LUA_API int lua_cpcall (lua_State *L, lua_CFunction func, void *ud) {+  struct CCallS c;+  int status;+  lua_lock(L);+  c.func = func;+  c.ud = ud;+  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);+  lua_unlock(L);+  return status;+}+++LUA_API int lua_load (lua_State *L, lua_Reader reader, void *data,+                      const char *chunkname) {+  ZIO z;+  int status;+  lua_lock(L);+  if (!chunkname) chunkname = "?";+  luaZ_init(L, &z, reader, data);+  status = luaD_protectedparser(L, &z, chunkname);+  lua_unlock(L);+  return status;+}+++LUA_API int lua_dump (lua_State *L, lua_Writer writer, void *data) {+  int status;+  TValue *o;+  lua_lock(L);+  api_checknelems(L, 1);+  o = L->top - 1;+  if (isLfunction(o))+    status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);+  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->GCthreshold = MAX_LUMEM;+      break;+    }+    case LUA_GCRESTART: {+      g->GCthreshold = g->totalbytes;+      break;+    }+    case LUA_GCCOLLECT: {+      luaC_fullgc(L);+      break;+    }+    case LUA_GCCOUNT: {+      /* GC values are expressed in Kbytes: #bytes/2^10 */+      res = cast_int(g->totalbytes >> 10);+      break;+    }+    case LUA_GCCOUNTB: {+      res = cast_int(g->totalbytes & 0x3ff);+      break;+    }+    case LUA_GCSTEP: {+      lu_mem a = (cast(lu_mem, data) << 10);+      if (a <= g->totalbytes)+        g->GCthreshold = g->totalbytes - a;+      else+        g->GCthreshold = 0;+      while (g->GCthreshold <= g->totalbytes) {+        luaC_step(L);+        if (g->gcstate == GCSpause) {  /* end of cycle? */+          res = 1;  /* signal it */+          break;+        }+      }+      break;+    }+    case LUA_GCSETPAUSE: {+      res = g->gcpause;+      g->gcpause = data;+      break;+    }+    case LUA_GCSETSTEPMUL: {+      res = g->gcstepmul;+      g->gcstepmul = data;+      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);+  lua_unlock(L);+  return 0;  /* to avoid warnings */+}+++LUA_API int lua_next (lua_State *L, int idx) {+  StkId t;+  int more;+  lua_lock(L);+  t = index2adr(L, idx);+  api_check(L, ttistable(t));+  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) {+    luaC_checkGC(L);+    luaV_concat(L, n, cast_int(L->top - L->base) - 1);+    L->top -= (n-1);+  }+  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 */+  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);+  luaC_checkGC(L);+  u = luaS_newudata(L, size, getcurrenv(L));+  setuvalue(L, L->top, u);+  api_incr_top(L);+  lua_unlock(L);+  return u + 1;+}+++++static const char *aux_upvalue (StkId fi, int n, TValue **val) {+  Closure *f;+  if (!ttisfunction(fi)) return NULL;+  f = clvalue(fi);+  if (f->c.isC) {+    if (!(1 <= n && n <= f->c.nupvalues)) return NULL;+    *val = &f->c.upvalue[n-1];+    return "";+  }+  else {+    Proto *p = f->l.p;+    if (!(1 <= n && n <= p->sizeupvalues)) return NULL;+    *val = f->l.upvals[n-1]->v;+    return getstr(p->upvalues[n-1]);+  }+}+++LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n) {+  const char *name;+  TValue *val;+  lua_lock(L);+  name = aux_upvalue(index2adr(L, funcindex), n, &val);+  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;+  StkId fi;+  lua_lock(L);+  fi = index2adr(L, funcindex);+  api_checknelems(L, 1);+  name = aux_upvalue(fi, n, &val);+  if (name) {+    L->top--;+    setobj(L, val, L->top);+    luaC_barrier(L, clvalue(fi), L->top);+  }+  lua_unlock(L);+  return name;+}+

@@ -0,0 +1,16 @@+/*+** $Id: lapi.h,v 2.2.1.1 2007/12/27 13:02:25 roberto Exp $+** Auxiliary functions from Lua API+** See Copyright Notice in lua.h+*/++#ifndef lapi_h+#define lapi_h+++#include "lobject.h"+++LUAI_FUNC void luaA_pushobject (lua_State *L, const TValue *o);++#endif

@@ -0,0 +1,652 @@+/*+** $Id: lauxlib.c,v 1.159.1.3 2008/01/21 13:20:51 roberto Exp $+** Auxiliary functions for building Lua libraries+** See Copyright Notice in lua.h+*/+++#include <ctype.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.+*/++#define lauxlib_c+#define LUA_LIB++#include "lua.h"++#include "lauxlib.h"+++#define FREELIST_REF	0	/* free list of references */+++/* convert a stack index to positive */+#define abs_index(L, i)		((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : \+					lua_gettop(L) + (i) + 1)+++/*+** {======================================================+** Error-report functions+** =======================================================+*/+++LUALIB_API int luaL_argerror (lua_State *L, int narg, const char *extramsg) {+  lua_Debug ar;+  if (!lua_getstack(L, 0, &ar))  /* no stack frame? */+    return luaL_error(L, "bad argument #%d (%s)", narg, extramsg);+  lua_getinfo(L, "n", &ar);+  if (strcmp(ar.namewhat, "method") == 0) {+    narg--;  /* do not count `self' */+    if (narg == 0)  /* error is in the self argument itself? */+      return luaL_error(L, "calling " LUA_QS " on bad self (%s)",+                           ar.name, extramsg);+  }+  if (ar.name == NULL)+    ar.name = "?";+  return luaL_error(L, "bad argument #%d to " LUA_QS " (%s)",+                        narg, ar.name, extramsg);+}+++LUALIB_API int luaL_typerror (lua_State *L, int narg, const char *tname) {+  const char *msg = lua_pushfstring(L, "%s expected, got %s",+                                    tname, luaL_typename(L, narg));+  return luaL_argerror(L, narg, msg);+}+++static void tag_error (lua_State *L, int narg, int tag) {+  luaL_typerror(L, narg, lua_typename(L, tag));+}+++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_pushliteral(L, "");  /* else, no information available... */+}+++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_checkoption (lua_State *L, int narg, const char *def,+                                 const char *const lst[]) {+  const char *name = (def) ? luaL_optstring(L, narg, def) :+                             luaL_checkstring(L, narg);+  int i;+  for (i=0; lst[i]; i++)+    if (strcmp(lst[i], name) == 0)+      return i;+  return luaL_argerror(L, narg,+                       lua_pushfstring(L, "invalid option " LUA_QS, name));+}+++LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) {+  lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get registry.name */+  if (!lua_isnil(L, -1))  /* name already in use? */+    return 0;  /* leave previous value on top, but return 0 */+  lua_pop(L, 1);+  lua_newtable(L);  /* create metatable */+  lua_pushvalue(L, -1);+  lua_setfield(L, LUA_REGISTRYINDEX, tname);  /* registry.name = metatable */+  return 1;+}+++LUALIB_API void *luaL_checkudata (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? */+      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */+      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */+        lua_pop(L, 2);  /* remove both metatables */+        return p;+      }+    }+  }+  luaL_typerror(L, ud, tname);  /* else error */+  return NULL;  /* to avoid warnings */+}+++LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {+  if (!lua_checkstack(L, space))+    luaL_error(L, "stack overflow (%s)", mes);+}+++LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {+  if (lua_type(L, narg) != t)+    tag_error(L, narg, t);+}+++LUALIB_API void luaL_checkany (lua_State *L, int narg) {+  if (lua_type(L, narg) == LUA_TNONE)+    luaL_argerror(L, narg, "value expected");+}+++LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {+  const char *s = lua_tolstring(L, narg, len);+  if (!s) tag_error(L, narg, LUA_TSTRING);+  return s;+}+++LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,+                                        const char *def, size_t *len) {+  if (lua_isnoneornil(L, narg)) {+    if (len)+      *len = (def ? strlen(def) : 0);+    return def;+  }+  else return luaL_checklstring(L, narg, len);+}+++LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {+  lua_Number d = lua_tonumber(L, narg);+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */+    tag_error(L, narg, LUA_TNUMBER);+  return d;+}+++LUALIB_API lua_Number luaL_optnumber (lua_State *L, int narg, lua_Number def) {+  return luaL_opt(L, luaL_checknumber, narg, def);+}+++LUALIB_API lua_Integer luaL_checkinteger (lua_State *L, int narg) {+  lua_Integer d = lua_tointeger(L, narg);+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */+    tag_error(L, narg, LUA_TNUMBER);+  return d;+}+++LUALIB_API lua_Integer luaL_optinteger (lua_State *L, int narg,+                                                      lua_Integer def) {+  return luaL_opt(L, luaL_checkinteger, narg, def);+}+++LUALIB_API int luaL_getmetafield (lua_State *L, int obj, const char *event) {+  if (!lua_getmetatable(L, obj))  /* no metatable? */+    return 0;+  lua_pushstring(L, event);+  lua_rawget(L, -2);+  if (lua_isnil(L, -1)) {+    lua_pop(L, 2);  /* remove metatable and metafield */+    return 0;+  }+  else {+    lua_remove(L, -2);  /* remove only metatable */+    return 1;+  }+}+++LUALIB_API int luaL_callmeta (lua_State *L, int obj, const char *event) {+  obj = abs_index(L, obj);+  if (!luaL_getmetafield(L, obj, event))  /* no metafield? */+    return 0;+  lua_pushvalue(L, obj);+  lua_call(L, 1, 1);+  return 1;+}+++LUALIB_API void (luaL_register) (lua_State *L, const char *libname,+                                const luaL_Reg *l) {+  luaI_openlib(L, libname, l, 0);+}+++static int libsize (const luaL_Reg *l) {+  int size = 0;+  for (; l->name; l++) size++;+  return size;+}+++LUALIB_API void luaI_openlib (lua_State *L, const char *libname,+                              const luaL_Reg *l, int nup) {+  if (libname) {+    int size = libsize(l);+    /* check whether lib already exists */+    luaL_findtable(L, LUA_REGISTRYINDEX, "_LOADED", 1);+    lua_getfield(L, -1, libname);  /* get _LOADED[libname] */+    if (!lua_istable(L, -1)) {  /* not found? */+      lua_pop(L, 1);  /* remove previous result */+      /* try global variable (and create one if it does not exist) */+      if (luaL_findtable(L, LUA_GLOBALSINDEX, libname, size) != NULL)+        luaL_error(L, "name conflict for module " LUA_QS, libname);+      lua_pushvalue(L, -1);+      lua_setfield(L, -3, libname);  /* _LOADED[libname] = new table */+    }+    lua_remove(L, -2);  /* remove _LOADED table */+    lua_insert(L, -(nup+1));  /* move library table to below upvalues */+  }+  for (; l->name; l++) {+    int i;+    for (i=0; i<nup; i++)  /* copy upvalues to the top */+      lua_pushvalue(L, -nup);+    lua_pushcclosure(L, l->func, nup);+    lua_setfield(L, -(nup+2), l->name);+  }+  lua_pop(L, nup);  /* remove upvalues */+}++++/*+** {======================================================+** getn-setn: size for arrays+** =======================================================+*/++#if defined(LUA_COMPAT_GETN)++static int checkint (lua_State *L, int topop) {+  int n = (lua_type(L, -1) == LUA_TNUMBER) ? lua_tointeger(L, -1) : -1;+  lua_pop(L, topop);+  return n;+}+++static void getsizes (lua_State *L) {+  lua_getfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");+  if (lua_isnil(L, -1)) {  /* no `size' table? */+    lua_pop(L, 1);  /* remove nil */+    lua_newtable(L);  /* create it */+    lua_pushvalue(L, -1);  /* `size' will be its own metatable */+    lua_setmetatable(L, -2);+    lua_pushliteral(L, "kv");+    lua_setfield(L, -2, "__mode");  /* metatable(N).__mode = "kv" */+    lua_pushvalue(L, -1);+    lua_setfield(L, LUA_REGISTRYINDEX, "LUA_SIZES");  /* store in register */+  }+}+++LUALIB_API void luaL_setn (lua_State *L, int t, int n) {+  t = abs_index(L, t);+  lua_pushliteral(L, "n");+  lua_rawget(L, t);+  if (checkint(L, 1) >= 0) {  /* is there a numeric field `n'? */+    lua_pushliteral(L, "n");  /* use it */+    lua_pushinteger(L, n);+    lua_rawset(L, t);+  }+  else {  /* use `sizes' */+    getsizes(L);+    lua_pushvalue(L, t);+    lua_pushinteger(L, n);+    lua_rawset(L, -3);  /* sizes[t] = n */+    lua_pop(L, 1);  /* remove `sizes' */+  }+}+++LUALIB_API int luaL_getn (lua_State *L, int t) {+  int n;+  t = abs_index(L, t);+  lua_pushliteral(L, "n");  /* try t.n */+  lua_rawget(L, t);+  if ((n = checkint(L, 1)) >= 0) return n;+  getsizes(L);  /* else try sizes[t] */+  lua_pushvalue(L, t);+  lua_rawget(L, -2);+  if ((n = checkint(L, 2)) >= 0) return n;+  return (int)lua_objlen(L, t);+}++#endif++/* }====================================================== */++++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);+}+++LUALIB_API const char *luaL_findtable (lua_State *L, int idx,+                                       const char *fname, int szhint) {+  const char *e;+  lua_pushvalue(L, idx);+  do {+    e = strchr(fname, '.');+    if (e == NULL) e = fname + strlen(fname);+    lua_pushlstring(L, fname, e - fname);+    lua_rawget(L, -2);+    if (lua_isnil(L, -1)) {  /* 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;+}++++/*+** {======================================================+** Generic Buffer manipulation+** =======================================================+*/+++#define bufflen(B)	((B)->p - (B)->buffer)+#define bufffree(B)	((size_t)(LUAL_BUFFERSIZE - bufflen(B)))++#define LIMIT	(LUA_MINSTACK/2)+++static int emptybuffer (luaL_Buffer *B) {+  size_t l = bufflen(B);+  if (l == 0) return 0;  /* put nothing on stack */+  else {+    lua_pushlstring(B->L, B->buffer, l);+    B->p = B->buffer;+    B->lvl++;+    return 1;+  }+}+++static void adjuststack (luaL_Buffer *B) {+  if (B->lvl > 1) {+    lua_State *L = B->L;+    int toget = 1;  /* number of levels to concat */+    size_t toplen = lua_strlen(L, -1);+    do {+      size_t l = lua_strlen(L, -(toget+1));+      if (B->lvl - toget + 1 >= LIMIT || toplen > l) {+        toplen += l;+        toget++;+      }+      else break;+    } while (toget < B->lvl);+    lua_concat(L, toget);+    B->lvl = B->lvl - toget + 1;+  }+}+++LUALIB_API char *luaL_prepbuffer (luaL_Buffer *B) {+  if (emptybuffer(B))+    adjuststack(B);+  return B->buffer;+}+++LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) {+  while (l--)+    luaL_addchar(B, *s++);+}+++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) {+  emptybuffer(B);+  lua_concat(B->L, B->lvl);+  B->lvl = 1;+}+++LUALIB_API void luaL_addvalue (luaL_Buffer *B) {+  lua_State *L = B->L;+  size_t vl;+  const char *s = lua_tolstring(L, -1, &vl);+  if (vl <= bufffree(B)) {  /* fit into buffer? */+    memcpy(B->p, s, vl);  /* put it there */+    B->p += vl;+    lua_pop(L, 1);  /* remove from stack */+  }+  else {+    if (emptybuffer(B))+      lua_insert(L, -2);  /* put buffer before new value */+    B->lvl++;  /* add new value into B stack */+    adjuststack(B);+  }+}+++LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {+  B->L = L;+  B->p = B->buffer;+  B->lvl = 0;+}++/* }====================================================== */+++LUALIB_API int luaL_ref (lua_State *L, int t) {+  int ref;+  t = abs_index(L, t);+  if (lua_isnil(L, -1)) {+    lua_pop(L, 1);  /* remove from stack */+    return LUA_REFNIL;  /* `nil' has a unique fixed reference */+  }+  lua_rawgeti(L, t, FREELIST_REF);  /* get first free element */+  ref = (int)lua_tointeger(L, -1);  /* ref = t[FREELIST_REF] */+  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_REF);  /* (t[FREELIST_REF] = t[ref]) */+  }+  else {  /* no free elements */+    ref = (int)lua_objlen(L, t);+    ref++;  /* create 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 = abs_index(L, t);+    lua_rawgeti(L, t, FREELIST_REF);+    lua_rawseti(L, t, ref);  /* t[ref] = t[FREELIST_REF] */+    lua_pushinteger(L, ref);+    lua_rawseti(L, t, FREELIST_REF);  /* t[FREELIST_REF] = ref */+  }+}++++/*+** {======================================================+** Load functions+** =======================================================+*/++typedef struct LoadF {+  int extraline;+  FILE *f;+  char buff[LUAL_BUFFERSIZE];+} LoadF;+++static const char *getF (lua_State *L, void *ud, size_t *size) {+  LoadF *lf = (LoadF *)ud;+  (void)L;+  if (lf->extraline) {+    lf->extraline = 0;+    *size = 1;+    return "\n";+  }+  if (feof(lf->f)) return NULL;+  *size = fread(lf->buff, 1, sizeof(lf->buff), lf->f);+  return (*size > 0) ? lf->buff : NULL;+}+++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;+}+++LUALIB_API int luaL_loadfile (lua_State *L, const char *filename) {+  LoadF lf;+  int status, readstatus;+  int c;+  int fnameindex = lua_gettop(L) + 1;  /* index of filename on the stack */+  lf.extraline = 0;+  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);+  }+  c = getc(lf.f);+  if (c == '#') {  /* Unix exec. file? */+    lf.extraline = 1;+    while ((c = getc(lf.f)) != EOF && c != '\n') ;  /* skip first line */+    if (c == '\n') c = getc(lf.f);+  }+  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);+    /* skip eventual `#!...' */+   while ((c = getc(lf.f)) != EOF && c != LUA_SIGNATURE[0]) ;+    lf.extraline = 0;+  }+  ungetc(c, lf.f);+  status = lua_load(L, getF, &lf, lua_tostring(L, -1));+  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;+  if (ls->size == 0) return NULL;+  *size = ls->size;+  ls->size = 0;+  return ls->s;+}+++LUALIB_API int luaL_loadbuffer (lua_State *L, const char *buff, size_t size,+                                const char *name) {+  LoadS ls;+  ls.s = buff;+  ls.size = size;+  return lua_load(L, getS, &ls, name);+}+++LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s) {+  return luaL_loadbuffer(L, s, strlen(s), s);+}++++/* }====================================================== */+++static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {+  (void)ud;+  (void)osize;+  if (nsize == 0) {+    free(ptr);+    return NULL;+  }+  else+    return realloc(ptr, nsize);+}+++static int panic (lua_State *L) {+  (void)L;  /* to avoid warnings */+  fprintf(stderr, "PANIC: unprotected error in call to Lua API (%s)\n",+                   lua_tostring(L, -1));+  return 0;+}+++LUALIB_API lua_State *luaL_newstate (void) {+  lua_State *L = lua_newstate(l_alloc, NULL);+  if (L) lua_atpanic(L, &panic);+  return L;+}+

@@ -0,0 +1,174 @@+/*+** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 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"+++#if defined(LUA_COMPAT_GETN)+LUALIB_API int (luaL_getn) (lua_State *L, int t);+LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);+#else+#define luaL_getn(L,i)          ((int)lua_objlen(L, i))+#define luaL_setn(L,i,j)        ((void)0)  /* no op! */+#endif++#if defined(LUA_COMPAT_OPENLIB)+#define luaI_openlib	luaL_openlib+#endif+++/* extra error code for `luaL_load' */+#define LUA_ERRFILE     (LUA_ERRERR+1)+++typedef struct luaL_Reg {+  const char *name;+  lua_CFunction func;+} luaL_Reg;++++LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,+                                const luaL_Reg *l, int nup);+LUALIB_API void (luaL_register) (lua_State *L, const char *libname,+                                const luaL_Reg *l);+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 int (luaL_typerror) (lua_State *L, int narg, const char *tname);+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,+                                                          size_t *l);+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,+                                          const char *def, size_t *l);+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);++LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,+                                          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 narg, int t);+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);++LUALIB_API int   (luaL_newmetatable) (lua_State *L, 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 narg, const char *def,+                                   const char *const lst[]);++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_loadfile) (lua_State *L, const char *filename);+LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,+                                  const char *name);+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);++LUALIB_API lua_State *(luaL_newstate) (void);+++LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,+                                                  const char *r);++LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,+                                         const char *fname, int szhint);+++++/*+** ===============================================================+** some useful macros+** ===============================================================+*/++#define luaL_argcheck(L, cond,numarg,extramsg)	\+		((void)((cond) || luaL_argerror(L, (numarg), (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_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)))++#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)))++/*+** {======================================================+** Generic Buffer manipulation+** =======================================================+*/++++typedef struct luaL_Buffer {+  char *p;			/* current position in buffer */+  int lvl;  /* number of strings in the stack (level) */+  lua_State *L;+  char buffer[LUAL_BUFFERSIZE];+} luaL_Buffer;++#define luaL_addchar(B,c) \+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \+   (*(B)->p++ = (char)(c)))++/* compatibility only */+#define luaL_putchar(B,c)	luaL_addchar(B,c)++#define luaL_addsize(B,n)	((B)->p += (n))++LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);+LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);+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);+++/* }====================================================== */+++/* compatibility with ref system */++/* pre-defined references */+#define LUA_NOREF       (-2)+#define LUA_REFNIL      (-1)++#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \+      (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))++#define lua_unref(L,ref)        luaL_unref(L, LUA_REGISTRYINDEX, (ref))++#define lua_getref(L,ref)       lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))+++#define luaL_reg	luaL_Reg++#endif++

@@ -0,0 +1,653 @@+/*+** $Id: lbaselib.c,v 1.191.1.6 2008/02/14 16:46:22 roberto Exp $+** Basic library+** See Copyright Notice in lua.h+*/++++#include <ctype.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#define lbaselib_c+#define LUA_LIB++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"+++++/*+** If your system does not support `stdout', you can just remove this function.+** If you need, you can define your own `print' function, following this+** model but changing `fputs' to put the strings at a proper place+** (a console window or a log file, for instance).+*/+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;+    lua_pushvalue(L, -1);  /* function to be called */+    lua_pushvalue(L, i);   /* value to print */+    lua_call(L, 1, 1);+    s = lua_tostring(L, -1);  /* get result */+    if (s == NULL)+      return luaL_error(L, LUA_QL("tostring") " must return a string to "+                           LUA_QL("print"));+    if (i>1) fputs("\t", stdout);+    fputs(s, stdout);+    lua_pop(L, 1);  /* pop result */+  }+  fputs("\n", stdout);+  return 0;+}+++static int luaB_tonumber (lua_State *L) {+  int base = luaL_optint(L, 2, 10);+  if (base == 10) {  /* standard conversion */+    luaL_checkany(L, 1);+    if (lua_isnumber(L, 1)) {+      lua_pushnumber(L, lua_tonumber(L, 1));+      return 1;+    }+  }+  else {+    const char *s1 = luaL_checkstring(L, 1);+    char *s2;+    unsigned long n;+    luaL_argcheck(L, 2 <= base && base <= 36, 2, "base out of range");+    n = strtoul(s1, &s2, base);+    if (s1 != s2) {  /* at least one valid digit? */+      while (isspace((unsigned char)(*s2))) s2++;  /* skip trailing spaces */+      if (*s2 == '\0') {  /* no invalid trailing characters? */+        lua_pushnumber(L, (lua_Number)n);+        return 1;+      }+    }+  }+  lua_pushnil(L);  /* else not a number */+  return 1;+}+++static int luaB_error (lua_State *L) {+  int level = luaL_optint(L, 2, 1);+  lua_settop(L, 1);+  if (lua_isstring(L, 1) && level > 0) {  /* add extra information? */+    luaL_where(L, level);+    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"))+    luaL_error(L, "cannot change a protected metatable");+  lua_settop(L, 2);+  lua_setmetatable(L, 1);+  return 1;+}+++static void getfunc (lua_State *L, int opt) {+  if (lua_isfunction(L, 1)) lua_pushvalue(L, 1);+  else {+    lua_Debug ar;+    int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);+    luaL_argcheck(L, level >= 0, 1, "level must be non-negative");+    if (lua_getstack(L, level, &ar) == 0)+      luaL_argerror(L, 1, "invalid level");+    lua_getinfo(L, "f", &ar);+    if (lua_isnil(L, -1))+      luaL_error(L, "no function environment for tail call at level %d",+                    level);+  }+}+++static int luaB_getfenv (lua_State *L) {+  getfunc(L, 1);+  if (lua_iscfunction(L, -1))  /* is a C function? */+    lua_pushvalue(L, LUA_GLOBALSINDEX);  /* return the thread's global env. */+  else+    lua_getfenv(L, -1);+  return 1;+}+++static int luaB_setfenv (lua_State *L) {+  luaL_checktype(L, 2, LUA_TTABLE);+  getfunc(L, 0);+  lua_pushvalue(L, 2);+  if (lua_isnumber(L, 1) && lua_tonumber(L, 1) == 0) {+    /* change environment of current thread */+    lua_pushthread(L);+    lua_insert(L, -2);+    lua_setfenv(L, -2);+    return 0;+  }+  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)+    luaL_error(L,+          LUA_QL("setfenv") " cannot change environment of given object");+  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_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_gcinfo (lua_State *L) {+  lua_pushinteger(L, lua_getgccount(L));+  return 1;+}+++static int luaB_collectgarbage (lua_State *L) {+  static const char *const opts[] = {"stop", "restart", "collect",+    "count", "step", "setpause", "setstepmul", NULL};+  static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,+    LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL};+  int o = luaL_checkoption(L, 1, "collect", opts);+  int ex = luaL_optint(L, 2, 0);+  int res = lua_gc(L, optsnum[o], ex);+  switch (optsnum[o]) {+    case LUA_GCCOUNT: {+      int b = lua_gc(L, LUA_GCCOUNTB, 0);+      lua_pushnumber(L, res + ((lua_Number)b/1024));+      return 1;+    }+    case LUA_GCSTEP: {+      lua_pushboolean(L, res);+      return 1;+    }+    default: {+      lua_pushnumber(L, res);+      return 1;+    }+  }+}+++static int luaB_type (lua_State *L) {+  luaL_checkany(L, 1);+  lua_pushstring(L, luaL_typename(L, 1));+  return 1;+}+++static int luaB_next (lua_State *L) {+  luaL_checktype(L, 1, LUA_TTABLE);+  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */+  if (lua_next(L, 1))+    return 2;+  else {+    lua_pushnil(L);+    return 1;+  }+}+++static int luaB_pairs (lua_State *L) {+  luaL_checktype(L, 1, LUA_TTABLE);+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */+  lua_pushvalue(L, 1);  /* state, */+  lua_pushnil(L);  /* and initial value */+  return 3;+}+++static int ipairsaux (lua_State *L) {+  int i = luaL_checkint(L, 2);+  luaL_checktype(L, 1, LUA_TTABLE);+  i++;  /* next value */+  lua_pushinteger(L, i);+  lua_rawgeti(L, 1, i);+  return (lua_isnil(L, -1)) ? 0 : 2;+}+++static int luaB_ipairs (lua_State *L) {+  luaL_checktype(L, 1, LUA_TTABLE);+  lua_pushvalue(L, lua_upvalueindex(1));  /* return generator, */+  lua_pushvalue(L, 1);  /* state, */+  lua_pushinteger(L, 0);  /* and initial value */+  return 3;+}+++static int load_aux (lua_State *L, int status) {+  if (status == 0)  /* OK? */+    return 1;+  else {+    lua_pushnil(L);+    lua_insert(L, -2);  /* put before error message */+    return 2;  /* return nil plus error message */+  }+}+++static int luaB_loadstring (lua_State *L) {+  size_t l;+  const char *s = luaL_checklstring(L, 1, &l);+  const char *chunkname = luaL_optstring(L, 2, s);+  return load_aux(L, luaL_loadbuffer(L, s, l, chunkname));+}+++static int luaB_loadfile (lua_State *L) {+  const char *fname = luaL_optstring(L, 1, NULL);+  return load_aux(L, luaL_loadfile(L, fname));+}+++/*+** 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;  /* to avoid warnings */+  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)) {+    *size = 0;+    return NULL;+  }+  else if (lua_isstring(L, -1)) {+    lua_replace(L, 3);  /* save string in a reserved stack slot */+    return lua_tolstring(L, 3, size);+  }+  else luaL_error(L, "reader function must return a string");+  return NULL;  /* to avoid warnings */+}+++static int luaB_load (lua_State *L) {+  int status;+  const char *cname = luaL_optstring(L, 2, "=(load)");+  luaL_checktype(L, 1, LUA_TFUNCTION);+  lua_settop(L, 3);  /* function, eventual name, plus one reserved slot */+  status = lua_load(L, generic_reader, NULL, cname);+  return load_aux(L, status);+}+++static int luaB_dofile (lua_State *L) {+  const char *fname = luaL_optstring(L, 1, NULL);+  int n = lua_gettop(L);+  if (luaL_loadfile(L, fname) != 0) lua_error(L);+  lua_call(L, 0, LUA_MULTRET);+  return lua_gettop(L) - n;+}+++static int luaB_assert (lua_State *L) {+  luaL_checkany(L, 1);+  if (!lua_toboolean(L, 1))+    return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));+  return lua_gettop(L);+}+++static int luaB_unpack (lua_State *L) {+  int i, e, n;+  luaL_checktype(L, 1, LUA_TTABLE);+  i = luaL_optint(L, 2, 1);+  e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));+  if (i > e) return 0;  /* empty range */+  n = e - i + 1;  /* number of elements */+  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */+    return luaL_error(L, "too many results to unpack");+  lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */+  while (i++ < e)  /* push arg[i + 1...e] */+    lua_rawgeti(L, 1, i);+  return n;+}+++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 {+    int i = luaL_checkint(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 - i;+  }+}+++static int luaB_pcall (lua_State *L) {+  int status;+  luaL_checkany(L, 1);+  status = lua_pcall(L, lua_gettop(L) - 1, LUA_MULTRET, 0);+  lua_pushboolean(L, (status == 0));+  lua_insert(L, 1);+  return lua_gettop(L);  /* return status + all results */+}+++static int luaB_xpcall (lua_State *L) {+  int status;+  luaL_checkany(L, 2);+  lua_settop(L, 2);+  lua_insert(L, 1);  /* put error function under function to be called */+  status = lua_pcall(L, 0, LUA_MULTRET, 1);+  lua_pushboolean(L, (status == 0));+  lua_replace(L, 1);+  return lua_gettop(L);  /* return status + all results */+}+++static int luaB_tostring (lua_State *L) {+  luaL_checkany(L, 1);+  if (luaL_callmeta(L, 1, "__tostring"))  /* is there a metafield? */+    return 1;  /* use its value */+  switch (lua_type(L, 1)) {+    case LUA_TNUMBER:+      lua_pushstring(L, lua_tostring(L, 1));+      break;+    case LUA_TSTRING:+      lua_pushvalue(L, 1);+      break;+    case LUA_TBOOLEAN:+      lua_pushstring(L, (lua_toboolean(L, 1) ? "true" : "false"));+      break;+    case LUA_TNIL:+      lua_pushliteral(L, "nil");+      break;+    default:+      lua_pushfstring(L, "%s: %p", luaL_typename(L, 1), lua_topointer(L, 1));+      break;+  }+  return 1;+}+++static int luaB_newproxy (lua_State *L) {+  lua_settop(L, 1);+  lua_newuserdata(L, 0);  /* create proxy */+  if (lua_toboolean(L, 1) == 0)+    return 1;  /* no metatable */+  else if (lua_isboolean(L, 1)) {+    lua_newtable(L);  /* create a new metatable `m' ... */+    lua_pushvalue(L, -1);  /* ... and mark `m' as a valid metatable */+    lua_pushboolean(L, 1);+    lua_rawset(L, lua_upvalueindex(1));  /* weaktable[m] = true */+  }+  else {+    int validproxy = 0;  /* to check if weaktable[metatable(u)] == true */+    if (lua_getmetatable(L, 1)) {+      lua_rawget(L, lua_upvalueindex(1));+      validproxy = lua_toboolean(L, -1);+      lua_pop(L, 1);  /* remove value */+    }+    luaL_argcheck(L, validproxy, 1, "boolean or proxy expected");+    lua_getmetatable(L, 1);  /* metatable is valid; get it */+  }+  lua_setmetatable(L, 2);+  return 1;+}+++static const luaL_Reg base_funcs[] = {+  {"assert", luaB_assert},+  {"collectgarbage", luaB_collectgarbage},+  {"dofile", luaB_dofile},+  {"error", luaB_error},+  {"gcinfo", luaB_gcinfo},+  {"getfenv", luaB_getfenv},+  {"getmetatable", luaB_getmetatable},+  {"loadfile", luaB_loadfile},+  {"load", luaB_load},+  {"loadstring", luaB_loadstring},+  {"next", luaB_next},+  {"pcall", luaB_pcall},+  {"print", luaB_print},+  {"rawequal", luaB_rawequal},+  {"rawget", luaB_rawget},+  {"rawset", luaB_rawset},+  {"select", luaB_select},+  {"setfenv", luaB_setfenv},+  {"setmetatable", luaB_setmetatable},+  {"tonumber", luaB_tonumber},+  {"tostring", luaB_tostring},+  {"type", luaB_type},+  {"unpack", luaB_unpack},+  {"xpcall", luaB_xpcall},+  {NULL, NULL}+};+++/*+** {======================================================+** Coroutine library+** =======================================================+*/++#define CO_RUN	0	/* running */+#define CO_SUS	1	/* suspended */+#define CO_NOR	2	/* 'normal' (it resumed another coroutine) */+#define CO_DEAD	3++static const char *const statnames[] =+    {"running", "suspended", "normal", "dead"};++static int costatus (lua_State *L, lua_State *co) {+  if (L == co) return CO_RUN;+  switch (lua_status(co)) {+    case LUA_YIELD:+      return CO_SUS;+    case 0: {+      lua_Debug ar;+      if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */+        return CO_NOR;  /* it is running */+      else if (lua_gettop(co) == 0)+          return CO_DEAD;+      else+        return CO_SUS;  /* initial state */+    }+    default:  /* some error occured */+      return CO_DEAD;+  }+}+++static int luaB_costatus (lua_State *L) {+  lua_State *co = lua_tothread(L, 1);+  luaL_argcheck(L, co, 1, "coroutine expected");+  lua_pushstring(L, statnames[costatus(L, co)]);+  return 1;+}+++static int auxresume (lua_State *L, lua_State *co, int narg) {+  int status = costatus(L, co);+  if (!lua_checkstack(co, narg))+    luaL_error(L, "too many arguments to resume");+  if (status != CO_SUS) {+    lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);+    return -1;  /* error flag */+  }+  lua_xmove(L, co, narg);+  lua_setlevel(L, co);+  status = lua_resume(co, narg);+  if (status == 0 || status == LUA_YIELD) {+    int nres = lua_gettop(co);+    if (!lua_checkstack(L, nres + 1))+      luaL_error(L, "too many results to resume");+    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 = lua_tothread(L, 1);+  int r;+  luaL_argcheck(L, co, 1, "coroutine expected");+  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_isstring(L, -1)) {  /* error object is a string? */+      luaL_where(L, 1);  /* add extra info */+      lua_insert(L, -2);+      lua_concat(L, 2);+    }+    lua_error(L);  /* propagate error */+  }+  return r;+}+++static int luaB_cocreate (lua_State *L) {+  lua_State *NL = lua_newthread(L);+  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1), 1,+    "Lua function expected");+  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_corunning (lua_State *L) {+  if (lua_pushthread(L))+    lua_pushnil(L);  /* main thread is not a coroutine */+  return 1;+}+++static const luaL_Reg co_funcs[] = {+  {"create", luaB_cocreate},+  {"resume", luaB_coresume},+  {"running", luaB_corunning},+  {"status", luaB_costatus},+  {"wrap", luaB_cowrap},+  {"yield", luaB_yield},+  {NULL, NULL}+};++/* }====================================================== */+++static void auxopen (lua_State *L, const char *name,+                     lua_CFunction f, lua_CFunction u) {+  lua_pushcfunction(L, u);+  lua_pushcclosure(L, f, 1);+  lua_setfield(L, -2, name);+}+++static void base_open (lua_State *L) {+  /* set global _G */+  lua_pushvalue(L, LUA_GLOBALSINDEX);+  lua_setglobal(L, "_G");+  /* open lib into global table */+  luaL_register(L, "_G", base_funcs);+  lua_pushliteral(L, LUA_VERSION);+  lua_setglobal(L, "_VERSION");  /* set global _VERSION */+  /* `ipairs' and `pairs' need auxiliary functions as upvalues */+  auxopen(L, "ipairs", luaB_ipairs, ipairsaux);+  auxopen(L, "pairs", luaB_pairs, luaB_next);+  /* `newproxy' needs a weaktable as upvalue */+  lua_createtable(L, 0, 1);  /* new table `w' */+  lua_pushvalue(L, -1);  /* `w' will be its own metatable */+  lua_setmetatable(L, -2);+  lua_pushliteral(L, "kv");+  lua_setfield(L, -2, "__mode");  /* metatable(w).__mode = "kv" */+  lua_pushcclosure(L, luaB_newproxy, 1);+  lua_setglobal(L, "newproxy");  /* set global `newproxy' */+}+++LUALIB_API int luaopen_base (lua_State *L) {+  base_open(L);+  luaL_register(L, LUA_COLIBNAME, co_funcs);+  return 2;+}+

@@ -0,0 +1,831 @@+/*+** $Id: lcode.c,v 2.25.1.5 2011/01/31 14:53:16 roberto Exp $+** Code generator for Lua+** See Copyright Notice in lua.h+*/+++#include <stdlib.h>++#define lcode_c+#define LUA_CORE++#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 "ltable.h"+++#define hasjumps(e)	((e)->t != (e)->f)+++static int isnumeral(expdesc *e) {+  return (e->k == VKNUM && e->t == NO_JUMP && e->f == NO_JUMP);+}+++void luaK_nil (FuncState *fs, int from, int n) {+  Instruction *previous;+  if (fs->pc > fs->lasttarget) {  /* no jumps to current position? */+    if (fs->pc == 0) {  /* function start? */+      if (from >= fs->nactvar)+        return;  /* positions are already clean */+    }+    else {+      previous = &fs->f->code[fs->pc-1];+      if (GET_OPCODE(*previous) == OP_LOADNIL) {+        int pfrom = GETARG_A(*previous);+        int pto = GETARG_B(*previous);+        if (pfrom <= from && from <= pto+1) {  /* can connect both? */+          if (from+n-1 > pto)+            SETARG_B(*previous, from+n-1);+          return;+        }+      }+    }+  }+  luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0);  /* else no optimization */+}+++int luaK_jump (FuncState *fs) {+  int jpc = fs->jpc;  /* save list of jumps to here */+  int j;+  fs->jpc = NO_JUMP;+  j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP);+  luaK_concat(fs, &j, jpc);  /* keep them on hold */+  return j;+}+++void luaK_ret (FuncState *fs, int first, int nret) {+  luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);+}+++static int condjump (FuncState *fs, OpCode op, int A, int B, int C) {+  luaK_codeABC(fs, op, A, B, C);+  return luaK_jump(fs);+}+++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);+}+++/*+** 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;+}+++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 */+}+++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;+}+++/*+** 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 */+}+++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 */+    *i = CREATE_ABC(OP_TEST, GETARG_B(*i), 0, GETARG_C(*i));++  return 1;+}+++static void removevalues (FuncState *fs, int list) {+  for (; list != NO_JUMP; list = getjump(fs, list))+      patchtestreg(fs, list, NO_REG);+}+++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;+  }+}+++static void dischargejpc (FuncState *fs) {+  patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc);+  fs->jpc = NO_JUMP;+}+++void luaK_patchlist (FuncState *fs, int list, int target) {+  if (target == fs->pc)+    luaK_patchtohere(fs, list);+  else {+    lua_assert(target < fs->pc);+    patchlistaux(fs, list, target, NO_REG, target);+  }+}+++void luaK_patchtohere (FuncState *fs, int list) {+  luaK_getlabel(fs);+  luaK_concat(fs, &fs->jpc, list);+}+++void luaK_concat (FuncState *fs, int *l1, int l2) {+  if (l2 == NO_JUMP) return;+  else if (*l1 == NO_JUMP)+    *l1 = l2;+  else {+    int list = *l1;+    int next;+    while ((next = getjump(fs, list)) != NO_JUMP)  /* find last element */+      list = next;+    fixjump(fs, list, l2);+  }+}+++void luaK_checkstack (FuncState *fs, int n) {+  int newstack = fs->freereg + n;+  if (newstack > fs->f->maxstacksize) {+    if (newstack >= MAXSTACK)+      luaX_syntaxerror(fs->ls, "function or expression too complex");+    fs->f->maxstacksize = cast_byte(newstack);+  }+}+++void luaK_reserveregs (FuncState *fs, int n) {+  luaK_checkstack(fs, n);+  fs->freereg += n;+}+++static void freereg (FuncState *fs, int reg) {+  if (!ISK(reg) && reg >= fs->nactvar) {+    fs->freereg--;+    lua_assert(reg == fs->freereg);+  }+}+++static void freeexp (FuncState *fs, expdesc *e) {+  if (e->k == VNONRELOC)+    freereg(fs, e->u.s.info);+}+++static int addk (FuncState *fs, TValue *k, TValue *v) {+  lua_State *L = fs->L;+  TValue *idx = luaH_set(L, fs->h, k);+  Proto *f = fs->f;+  int oldsize = f->sizek;+  if (ttisnumber(idx)) {+    lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));+    return cast_int(nvalue(idx));+  }+  else {  /* constant not found; create a new entry */+    setnvalue(idx, cast_num(fs->nk));+    luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,+                    MAXARG_Bx, "constant table overflow");+    while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);+    setobj(L, &f->k[fs->nk], v);+    luaC_barrier(L, f, v);+    return fs->nk++;+  }+}+++int luaK_stringK (FuncState *fs, TString *s) {+  TValue o;+  setsvalue(fs->L, &o, s);+  return addk(fs, &o, &o);+}+++int luaK_numberK (FuncState *fs, lua_Number r) {+  TValue o;+  setnvalue(&o, r);+  return addk(fs, &o, &o);+}+++static int boolK (FuncState *fs, int b) {+  TValue o;+  setbvalue(&o, b);+  return addk(fs, &o, &o);+}+++static int nilK (FuncState *fs) {+  TValue k, v;+  setnilvalue(&v);+  /* cannot use nil as key; instead use table itself to represent nil */+  sethvalue(fs->L, &k, fs->h);+  return addk(fs, &k, &v);+}+++void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) {+  if (e->k == VCALL) {  /* expression is an open function call? */+    SETARG_C(getcode(fs, e), nresults+1);+  }+  else if (e->k == VVARARG) {+    SETARG_B(getcode(fs, e), nresults+1);+    SETARG_A(getcode(fs, e), fs->freereg);+    luaK_reserveregs(fs, 1);+  }+}+++void luaK_setoneret (FuncState *fs, expdesc *e) {+  if (e->k == VCALL) {  /* expression is an open function call? */+    e->k = VNONRELOC;+    e->u.s.info = GETARG_A(getcode(fs, e));+  }+  else if (e->k == VVARARG) {+    SETARG_B(getcode(fs, e), 2);+    e->k = VRELOCABLE;  /* can relocate its simple result */+  }+}+++void luaK_dischargevars (FuncState *fs, expdesc *e) {+  switch (e->k) {+    case VLOCAL: {+      e->k = VNONRELOC;+      break;+    }+    case VUPVAL: {+      e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0);+      e->k = VRELOCABLE;+      break;+    }+    case VGLOBAL: {+      e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info);+      e->k = VRELOCABLE;+      break;+    }+    case VINDEXED: {+      freereg(fs, e->u.s.aux);+      freereg(fs, e->u.s.info);+      e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux);+      e->k = VRELOCABLE;+      break;+    }+    case VVARARG:+    case VCALL: {+      luaK_setoneret(fs, e);+      break;+    }+    default: break;  /* there is one value available (somewhere) */+  }+}+++static int code_label (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);+}+++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_codeABx(fs, OP_LOADK, reg, e->u.s.info);+      break;+    }+    case VKNUM: {+      luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval));+      break;+    }+    case VRELOCABLE: {+      Instruction *pc = &getcode(fs, e);+      SETARG_A(*pc, reg);+      break;+    }+    case VNONRELOC: {+      if (reg != e->u.s.info)+        luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0);+      break;+    }+    default: {+      lua_assert(e->k == VVOID || e->k == VJMP);+      return;  /* nothing to do... */+    }+  }+  e->u.s.info = reg;+  e->k = VNONRELOC;+}+++static void discharge2anyreg (FuncState *fs, expdesc *e) {+  if (e->k != VNONRELOC) {+    luaK_reserveregs(fs, 1);+    discharge2reg(fs, e, fs->freereg-1);+  }+}+++static void exp2reg (FuncState *fs, expdesc *e, int reg) {+  discharge2reg(fs, e, reg);+  if (e->k == VJMP)+    luaK_concat(fs, &e->t, e->u.s.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_label(fs, reg, 0, 1);+      p_t = code_label(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.s.info = reg;+  e->k = VNONRELOC;+}+++void luaK_exp2nextreg (FuncState *fs, expdesc *e) {+  luaK_dischargevars(fs, e);+  freeexp(fs, e);+  luaK_reserveregs(fs, 1);+  exp2reg(fs, e, fs->freereg - 1);+}+++int luaK_exp2anyreg (FuncState *fs, expdesc *e) {+  luaK_dischargevars(fs, e);+  if (e->k == VNONRELOC) {+    if (!hasjumps(e)) return e->u.s.info;  /* exp is already in a register */+    if (e->u.s.info >= fs->nactvar) {  /* reg. is not a local? */+      exp2reg(fs, e, e->u.s.info);  /* put value on it */+      return e->u.s.info;+    }+  }+  luaK_exp2nextreg(fs, e);  /* default */+  return e->u.s.info;+}+++void luaK_exp2val (FuncState *fs, expdesc *e) {+  if (hasjumps(e))+    luaK_exp2anyreg(fs, e);+  else+    luaK_dischargevars(fs, e);+}+++int luaK_exp2RK (FuncState *fs, expdesc *e) {+  luaK_exp2val(fs, e);+  switch (e->k) {+    case VKNUM:+    case VTRUE:+    case VFALSE:+    case VNIL: {+      if (fs->nk <= MAXINDEXRK) {  /* constant fit in RK operand? */+        e->u.s.info = (e->k == VNIL)  ? nilK(fs) :+                      (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) :+                                        boolK(fs, (e->k == VTRUE));+        e->k = VK;+        return RKASK(e->u.s.info);+      }+      else break;+    }+    case VK: {+      if (e->u.s.info <= MAXINDEXRK)  /* constant fit in argC? */+        return RKASK(e->u.s.info);+      else break;+    }+    default: break;+  }+  /* not a constant in the right range: put it in a register */+  return luaK_exp2anyreg(fs, e);+}+++void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) {+  switch (var->k) {+    case VLOCAL: {+      freeexp(fs, ex);+      exp2reg(fs, ex, var->u.s.info);+      return;+    }+    case VUPVAL: {+      int e = luaK_exp2anyreg(fs, ex);+      luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0);+      break;+    }+    case VGLOBAL: {+      int e = luaK_exp2anyreg(fs, ex);+      luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info);+      break;+    }+    case VINDEXED: {+      int e = luaK_exp2RK(fs, ex);+      luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e);+      break;+    }+    default: {+      lua_assert(0);  /* invalid var kind to store */+      break;+    }+  }+  freeexp(fs, ex);+}+++void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {+  int func;+  luaK_exp2anyreg(fs, e);+  freeexp(fs, e);+  func = fs->freereg;+  luaK_reserveregs(fs, 2);+  luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key));+  freeexp(fs, key);+  e->u.s.info = func;+  e->k = VNONRELOC;+}+++static void invertjump (FuncState *fs, expdesc *e) {+  Instruction *pc = getjumpcontrol(fs, e->u.s.info);+  lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET &&+                                           GET_OPCODE(*pc) != OP_TEST);+  SETARG_A(*pc, !(GETARG_A(*pc)));+}+++static int jumponcond (FuncState *fs, expdesc *e, int cond) {+  if (e->k == VRELOCABLE) {+    Instruction ie = getcode(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.s.info, cond);+}+++void luaK_goiftrue (FuncState *fs, expdesc *e) {+  int pc;  /* pc of last jump */+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VK: case VKNUM: case VTRUE: {+      pc = NO_JUMP;  /* always true; do nothing */+      break;+    }+    case VJMP: {+      invertjump(fs, e);+      pc = e->u.s.info;+      break;+    }+    default: {+      pc = jumponcond(fs, e, 0);+      break;+    }+  }+  luaK_concat(fs, &e->f, pc);  /* insert last jump in `f' list */+  luaK_patchtohere(fs, e->t);+  e->t = NO_JUMP;+}+++static void luaK_goiffalse (FuncState *fs, expdesc *e) {+  int pc;  /* pc of last jump */+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VNIL: case VFALSE: {+      pc = NO_JUMP;  /* always false; do nothing */+      break;+    }+    case VJMP: {+      pc = e->u.s.info;+      break;+    }+    default: {+      pc = jumponcond(fs, e, 1);+      break;+    }+  }+  luaK_concat(fs, &e->t, pc);  /* insert last jump in `t' list */+  luaK_patchtohere(fs, e->f);+  e->f = NO_JUMP;+}+++static void codenot (FuncState *fs, expdesc *e) {+  luaK_dischargevars(fs, e);+  switch (e->k) {+    case VNIL: case VFALSE: {+      e->k = VTRUE;+      break;+    }+    case VK: case VKNUM: case VTRUE: {+      e->k = VFALSE;+      break;+    }+    case VJMP: {+      invertjump(fs, e);+      break;+    }+    case VRELOCABLE:+    case VNONRELOC: {+      discharge2anyreg(fs, e);+      freeexp(fs, e);+      e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0);+      e->k = VRELOCABLE;+      break;+    }+    default: {+      lua_assert(0);  /* cannot happen */+      break;+    }+  }+  /* interchange true and false lists */+  { int temp = e->f; e->f = e->t; e->t = temp; }+  removevalues(fs, e->f);+  removevalues(fs, e->t);+}+++void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) {+  t->u.s.aux = luaK_exp2RK(fs, k);+  t->k = VINDEXED;+}+++static int constfolding (OpCode op, expdesc *e1, expdesc *e2) {+  lua_Number v1, v2, r;+  if (!isnumeral(e1) || !isnumeral(e2)) return 0;+  v1 = e1->u.nval;+  v2 = e2->u.nval;+  switch (op) {+    case OP_ADD: r = luai_numadd(v1, v2); break;+    case OP_SUB: r = luai_numsub(v1, v2); break;+    case OP_MUL: r = luai_nummul(v1, v2); break;+    case OP_DIV:+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */+      r = luai_numdiv(v1, v2); break;+    case OP_MOD:+      if (v2 == 0) return 0;  /* do not attempt to divide by 0 */+      r = luai_nummod(v1, v2); break;+    case OP_POW: r = luai_numpow(v1, v2); break;+    case OP_UNM: r = luai_numunm(v1); break;+    case OP_LEN: return 0;  /* no constant folding for 'len' */+    default: lua_assert(0); r = 0; break;+  }+  if (luai_numisnan(r)) return 0;  /* do not attempt to produce NaN */+  e1->u.nval = r;+  return 1;+}+++static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) {+  if (constfolding(op, e1, e2))+    return;+  else {+    int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0;+    int o1 = luaK_exp2RK(fs, e1);+    if (o1 > o2) {+      freeexp(fs, e1);+      freeexp(fs, e2);+    }+    else {+      freeexp(fs, e2);+      freeexp(fs, e1);+    }+    e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2);+    e1->k = VRELOCABLE;+  }+}+++static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1,+                                                          expdesc *e2) {+  int o1 = luaK_exp2RK(fs, e1);+  int o2 = luaK_exp2RK(fs, e2);+  freeexp(fs, e2);+  freeexp(fs, e1);+  if (cond == 0 && op != OP_EQ) {+    int temp;  /* exchange args to replace by `<' or `<=' */+    temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */+    cond = 1;+  }+  e1->u.s.info = condjump(fs, op, cond, o1, o2);+  e1->k = VJMP;+}+++void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) {+  expdesc e2;+  e2.t = e2.f = NO_JUMP; e2.k = VKNUM; e2.u.nval = 0;+  switch (op) {+    case OPR_MINUS: {+      if (!isnumeral(e))+        luaK_exp2anyreg(fs, e);  /* cannot operate on non-numeric constants */+      codearith(fs, OP_UNM, e, &e2);+      break;+    }+    case OPR_NOT: codenot(fs, e); break;+    case OPR_LEN: {+      luaK_exp2anyreg(fs, e);  /* cannot operate on constants */+      codearith(fs, OP_LEN, e, &e2);+      break;+    }+    default: lua_assert(0);+  }+}+++void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {+  switch (op) {+    case OPR_AND: {+      luaK_goiftrue(fs, v);+      break;+    }+    case OPR_OR: {+      luaK_goiffalse(fs, v);+      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_MOD: case OPR_POW: {+      if (!isnumeral(v)) luaK_exp2RK(fs, v);+      break;+    }+    default: {+      luaK_exp2RK(fs, v);+      break;+    }+  }+}+++void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {+  switch (op) {+    case OPR_AND: {+      lua_assert(e1->t == NO_JUMP);  /* list must be closed */+      luaK_dischargevars(fs, e2);+      luaK_concat(fs, &e2->f, e1->f);+      *e1 = *e2;+      break;+    }+    case OPR_OR: {+      lua_assert(e1->f == NO_JUMP);  /* list must be closed */+      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(getcode(fs, e2)) == OP_CONCAT) {+        lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1);+        freeexp(fs, e1);+        SETARG_B(getcode(fs, e2), e1->u.s.info);+        e1->k = VRELOCABLE; e1->u.s.info = e2->u.s.info;+      }+      else {+        luaK_exp2nextreg(fs, e2);  /* operand must be on the 'stack' */+        codearith(fs, OP_CONCAT, e1, e2);+      }+      break;+    }+    case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break;+    case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break;+    case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break;+    case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break;+    case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break;+    case OPR_POW: codearith(fs, OP_POW, e1, e2); break;+    case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break;+    case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break;+    case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break;+    case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break;+    case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break;+    case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break;+    default: lua_assert(0);+  }+}+++void luaK_fixline (FuncState *fs, int line) {+  fs->f->lineinfo[fs->pc - 1] = line;+}+++static int luaK_code (FuncState *fs, Instruction i, int line) {+  Proto *f = fs->f;+  dischargejpc(fs);  /* `pc' will change */+  /* put new instruction in code array */+  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,+                  MAX_INT, "code size overflow");+  f->code[fs->pc] = i;+  /* save corresponding line information */+  luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int,+                  MAX_INT, "code size overflow");+  f->lineinfo[fs->pc] = line;+  return fs->pc++;+}+++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);+  return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline);+}+++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);+  return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline);+}+++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);+  if (c <= MAXARG_C)+    luaK_codeABC(fs, OP_SETLIST, base, b, c);+  else {+    luaK_codeABC(fs, OP_SETLIST, base, b, 0);+    luaK_code(fs, cast(Instruction, c), fs->ls->lastline);+  }+  fs->freereg = base + 1;  /* free registers with list values */+}+

@@ -0,0 +1,76 @@+/*+** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 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+*/+typedef enum BinOpr {+  OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,+  OPR_CONCAT,+  OPR_NE, OPR_EQ,+  OPR_LT, OPR_LE, OPR_GT, OPR_GE,+  OPR_AND, OPR_OR,+  OPR_NOBINOPR+} BinOpr;+++typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;+++#define getcode(fs,e)	((fs)->f->code[(e)->u.s.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)++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 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_numberK (FuncState *fs, lua_Number r);+LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);+LUAI_FUNC int luaK_exp2anyreg (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_storevar (FuncState *fs, expdesc *var, expdesc *e);+LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);+LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);+LUAI_FUNC int luaK_jump (FuncState *fs);+LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);+LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);+LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);+LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);+LUAI_FUNC int luaK_getlabel (FuncState *fs);+LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);+LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);+LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);+LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);+++#endif

@@ -0,0 +1,398 @@+/*+** $Id: ldblib.c,v 1.104.1.4 2009/08/04 18:50:18 roberto Exp $+** Interface from Lua to its debug API+** See Copyright Notice in lua.h+*/+++#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#define ldblib_c+#define LUA_LIB++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"++++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_pushboolean(L, lua_setmetatable(L, 1));+  return 1;+}+++static int db_getfenv (lua_State *L) {+  luaL_checkany(L, 1);+  lua_getfenv(L, 1);+  return 1;+}+++static int db_setfenv (lua_State *L) {+  luaL_checktype(L, 2, LUA_TTABLE);+  lua_settop(L, 2);+  if (lua_setfenv(L, 1) == 0)+    luaL_error(L, LUA_QL("setfenv")+                  " cannot change environment of given object");+  return 1;+}+++static void settabss (lua_State *L, const char *i, const char *v) {+  lua_pushstring(L, v);+  lua_setfield(L, -2, i);+}+++static void settabsi (lua_State *L, const char *i, int v) {+  lua_pushinteger(L, v);+  lua_setfield(L, -2, i);+}+++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;+  }+}+++static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {+  if (L == L1) {+    lua_pushvalue(L, -2);+    lua_remove(L, -3);+  }+  else+    lua_xmove(L1, L, 1);+  lua_setfield(L, -2, fname);+}+++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, "flnSu");+  if (lua_isnumber(L, arg+1)) {+    if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {+      lua_pushnil(L);  /* level out of range */+      return 1;+    }+  }+  else if (lua_isfunction(L, arg+1)) {+    lua_pushfstring(L, ">%s", options);+    options = lua_tostring(L, -1);+    lua_pushvalue(L, arg+1);+    lua_xmove(L, L1, 1);+  }+  else+    return luaL_argerror(L, arg+1, "function or level expected");+  if (!lua_getinfo(L1, options, &ar))+    return luaL_argerror(L, arg+2, "invalid option");+  lua_createtable(L, 0, 2);+  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);+  if (strchr(options, 'n')) {+    settabss(L, "name", ar.name);+    settabss(L, "namewhat", ar.namewhat);+  }+  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;+  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */+    return luaL_argerror(L, arg+1, "level out of range");+  name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));+  if (name) {+    lua_xmove(L1, L, 1);+    lua_pushstring(L, name);+    lua_pushvalue(L, -2);+    return 2;+  }+  else {+    lua_pushnil(L);+    return 1;+  }+}+++static int db_setlocal (lua_State *L) {+  int arg;+  lua_State *L1 = getthread(L, &arg);+  lua_Debug ar;+  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */+    return luaL_argerror(L, arg+1, "level out of range");+  luaL_checkany(L, arg+3);+  lua_settop(L, arg+3);+  lua_xmove(L, L1, 1);+  lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));+  return 1;+}+++static int auxupvalue (lua_State *L, int get) {+  const char *name;+  int n = luaL_checkint(L, 2);+  luaL_checktype(L, 1, LUA_TFUNCTION);+  if (lua_iscfunction(L, 1)) return 0;  /* cannot touch C upvalues from Lua */+  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));+  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);+}++++static const char KEY_HOOK = 'h';+++static void hookf (lua_State *L, lua_Debug *ar) {+  static const char *const hooknames[] =+    {"call", "return", "line", "count", "tail return"};+  lua_pushlightuserdata(L, (void *)&KEY_HOOK);+  lua_rawget(L, LUA_REGISTRYINDEX);+  lua_pushlightuserdata(L, L);+  lua_rawget(L, -2);+  if (lua_isfunction(L, -1)) {+    lua_pushstring(L, hooknames[(int)ar->event]);+    if (ar->currentline >= 0)+      lua_pushinteger(L, ar->currentline);+    else lua_pushnil(L);+    lua_assert(lua_getinfo(L, "lS", ar));+    lua_call(L, 2, 0);+  }+}+++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;+}+++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 void gethooktable (lua_State *L) {+  lua_pushlightuserdata(L, (void *)&KEY_HOOK);+  lua_rawget(L, LUA_REGISTRYINDEX);+  if (!lua_istable(L, -1)) {+    lua_pop(L, 1);+    lua_createtable(L, 0, 1);+    lua_pushlightuserdata(L, (void *)&KEY_HOOK);+    lua_pushvalue(L, -2);+    lua_rawset(L, LUA_REGISTRYINDEX);+  }+}+++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)) {+    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 = luaL_optint(L, arg+3, 0);+    func = hookf; mask = makemask(smask, count);+  }+  gethooktable(L);+  lua_pushlightuserdata(L, L1);+  lua_pushvalue(L, arg+1);+  lua_rawset(L, -3);  /* set new hook */+  lua_pop(L, 1);  /* remove hook table */+  lua_sethook(L1, func, mask, count);  /* set hooks */+  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 && hook != hookf)  /* external hook? */+    lua_pushliteral(L, "external hook");+  else {+    gethooktable(L);+    lua_pushlightuserdata(L, L1);+    lua_rawget(L, -2);   /* get hook */+    lua_remove(L, -2);  /* remove hook table */+  }+  lua_pushstring(L, unmakemask(mask, buff));+  lua_pushinteger(L, lua_gethookcount(L1));+  return 3;+}+++static int db_debug (lua_State *L) {+  for (;;) {+    char buffer[250];+    fputs("lua_debug> ", stderr);+    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)) {+      fputs(lua_tostring(L, -1), stderr);+      fputs("\n", stderr);+    }+    lua_settop(L, 0);  /* remove eventual returns */+  }+}+++#define LEVELS1	12	/* size of the first part of the stack */+#define LEVELS2	10	/* size of the second part of the stack */++static int db_errorfb (lua_State *L) {+  int level;+  int firstpart = 1;  /* still before eventual `...' */+  int arg;+  lua_State *L1 = getthread(L, &arg);+  lua_Debug ar;+  if (lua_isnumber(L, arg+2)) {+    level = (int)lua_tointeger(L, arg+2);+    lua_pop(L, 1);+  }+  else+    level = (L == L1) ? 1 : 0;  /* level 0 may be this own function */+  if (lua_gettop(L) == arg)+    lua_pushliteral(L, "");+  else if (!lua_isstring(L, arg+1)) return 1;  /* message is not a string */+  else lua_pushliteral(L, "\n");+  lua_pushliteral(L, "stack traceback:");+  while (lua_getstack(L1, level++, &ar)) {+    if (level > LEVELS1 && firstpart) {+      /* no more than `LEVELS2' more levels? */+      if (!lua_getstack(L1, level+LEVELS2, &ar))+        level--;  /* keep going */+      else {+        lua_pushliteral(L, "\n\t...");  /* too many levels */+        while (lua_getstack(L1, level+LEVELS2, &ar))  /* find last levels */+          level++;+      }+      firstpart = 0;+      continue;+    }+    lua_pushliteral(L, "\n\t");+    lua_getinfo(L1, "Snl", &ar);+    lua_pushfstring(L, "%s:", ar.short_src);+    if (ar.currentline > 0)+      lua_pushfstring(L, "%d:", ar.currentline);+    if (*ar.namewhat != '\0')  /* is there a name? */+        lua_pushfstring(L, " in function " LUA_QS, ar.name);+    else {+      if (*ar.what == 'm')  /* main? */+        lua_pushfstring(L, " in main chunk");+      else if (*ar.what == 'C' || *ar.what == 't')+        lua_pushliteral(L, " ?");  /* C function or tail call */+      else+        lua_pushfstring(L, " in function <%s:%d>",+                           ar.short_src, ar.linedefined);+    }+    lua_concat(L, lua_gettop(L) - arg);+  }+  lua_concat(L, lua_gettop(L) - arg);+  return 1;+}+++static const luaL_Reg dblib[] = {+  {"debug", db_debug},+  {"getfenv", db_getfenv},+  {"gethook", db_gethook},+  {"getinfo", db_getinfo},+  {"getlocal", db_getlocal},+  {"getregistry", db_getregistry},+  {"getmetatable", db_getmetatable},+  {"getupvalue", db_getupvalue},+  {"setfenv", db_setfenv},+  {"sethook", db_sethook},+  {"setlocal", db_setlocal},+  {"setmetatable", db_setmetatable},+  {"setupvalue", db_setupvalue},+  {"traceback", db_errorfb},+  {NULL, NULL}+};+++LUALIB_API int luaopen_debug (lua_State *L) {+  luaL_register(L, LUA_DBLIBNAME, dblib);+  return 1;+}+

@@ -0,0 +1,638 @@+/*+** $Id: ldebug.c,v 2.29.1.6 2008/05/08 16:56:26 roberto Exp $+** Debug Interface+** See Copyright Notice in lua.h+*/+++#include <stdarg.h>+#include <stddef.h>+#include <string.h>+++#define ldebug_c+#define LUA_CORE++#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"++++static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);+++static int currentpc (lua_State *L, CallInfo *ci) {+  if (!isLua(ci)) return -1;  /* function is not a Lua function? */+  if (ci == L->ci)+    ci->savedpc = L->savedpc;+  return pcRel(ci->savedpc, ci_func(ci)->l.p);+}+++static int currentline (lua_State *L, CallInfo *ci) {+  int pc = currentpc(L, ci);+  if (pc < 0)+    return -1;  /* only active lua functions have current-line information */+  else+    return getline(ci_func(ci)->l.p, pc);+}+++/*+** this function can be called asynchronous (e.g. during a signal)+*/+LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {+  if (func == NULL || mask == 0) {  /* turn off hooks? */+    mask = 0;+    func = NULL;+  }+  L->hook = func;+  L->basehookcount = count;+  resethookcount(L);+  L->hookmask = cast_byte(mask);+  return 1;+}+++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;+  lua_lock(L);+  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {+    level--;+    if (f_isLua(ci))  /* Lua function? */+      level -= ci->tailcalls;  /* skip lost tail calls */+  }+  if (level == 0 && ci > L->base_ci) {  /* level found? */+    status = 1;+    ar->i_ci = cast_int(ci - L->base_ci);+  }+  else if (level < 0) {  /* level is of a lost tail call? */+    status = 1;+    ar->i_ci = 0;+  }+  else status = 0;  /* no such level */+  lua_unlock(L);+  return status;+}+++static Proto *getluaproto (CallInfo *ci) {+  return (isLua(ci) ? ci_func(ci)->l.p : NULL);+}+++static const char *findlocal (lua_State *L, CallInfo *ci, int n) {+  const char *name;+  Proto *fp = getluaproto(ci);+  if (fp && (name = luaF_getlocalname(fp, n, currentpc(L, ci))) != NULL)+    return name;  /* is a local variable in a Lua function */+  else {+    StkId limit = (ci == L->ci) ? L->top : (ci+1)->func;+    if (limit - ci->base >= n && n > 0)  /* is 'n' inside 'ci' stack? */+      return "(*temporary)";+    else+      return NULL;+  }+}+++LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {+  CallInfo *ci = L->base_ci + ar->i_ci;+  const char *name = findlocal(L, ci, n);+  lua_lock(L);+  if (name)+      luaA_pushobject(L, ci->base + (n - 1));+  lua_unlock(L);+  return name;+}+++LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {+  CallInfo *ci = L->base_ci + ar->i_ci;+  const char *name = findlocal(L, ci, n);+  lua_lock(L);+  if (name)+      setobjs2s(L, ci->base + (n - 1), L->top - 1);+  L->top--;  /* pop value */+  lua_unlock(L);+  return name;+}+++static void funcinfo (lua_Debug *ar, Closure *cl) {+  if (cl->c.isC) {+    ar->source = "=[C]";+    ar->linedefined = -1;+    ar->lastlinedefined = -1;+    ar->what = "C";+  }+  else {+    ar->source = getstr(cl->l.p->source);+    ar->linedefined = cl->l.p->linedefined;+    ar->lastlinedefined = cl->l.p->lastlinedefined;+    ar->what = (ar->linedefined == 0) ? "main" : "Lua";+  }+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);+}+++static void info_tailcall (lua_Debug *ar) {+  ar->name = ar->namewhat = "";+  ar->what = "tail";+  ar->lastlinedefined = ar->linedefined = ar->currentline = -1;+  ar->source = "=(tail call)";+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);+  ar->nups = 0;+}+++static void collectvalidlines (lua_State *L, Closure *f) {+  if (f == NULL || f->c.isC) {+    setnilvalue(L->top);+  }+  else {+    Table *t = luaH_new(L, 0, 0);+    int *lineinfo = f->l.p->lineinfo;+    int i;+    for (i=0; i<f->l.p->sizelineinfo; i++)+      setbvalue(luaH_setnum(L, t, lineinfo[i]), 1);+    sethvalue(L, L->top, t); +  }+  incr_top(L);+}+++static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,+                    Closure *f, CallInfo *ci) {+  int status = 1;+  if (f == NULL) {+    info_tailcall(ar);+    return status;+  }+  for (; *what; what++) {+    switch (*what) {+      case 'S': {+        funcinfo(ar, f);+        break;+      }+      case 'l': {+        ar->currentline = (ci) ? currentline(L, ci) : -1;+        break;+      }+      case 'u': {+        ar->nups = f->c.nupvalues;+        break;+      }+      case 'n': {+        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;+        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 *f = NULL;+  CallInfo *ci = NULL;+  lua_lock(L);+  if (*what == '>') {+    StkId func = L->top - 1;+    luai_apicheck(L, ttisfunction(func));+    what++;  /* skip the '>' */+    f = clvalue(func);+    L->top--;  /* pop function */+  }+  else if (ar->i_ci != 0) {  /* no tail call? */+    ci = L->base_ci + ar->i_ci;+    lua_assert(ttisfunction(ci->func));+    f = clvalue(ci->func);+  }+  status = auxgetinfo(L, what, ar, f, ci);+  if (strchr(what, 'f')) {+    if (f == NULL) setnilvalue(L->top);+    else setclvalue(L, L->top, f);+    incr_top(L);+  }+  if (strchr(what, 'L'))+    collectvalidlines(L, f);+  lua_unlock(L);+  return status;+}+++/*+** {======================================================+** Symbolic Execution and code checker+** =======================================================+*/++#define check(x)		if (!(x)) return 0;++#define checkjump(pt,pc)	check(0 <= pc && pc < pt->sizecode)++#define checkreg(pt,reg)	check((reg) < (pt)->maxstacksize)++++static int precheck (const Proto *pt) {+  check(pt->maxstacksize <= MAXSTACK);+  check(pt->numparams+(pt->is_vararg & VARARG_HASARG) <= pt->maxstacksize);+  check(!(pt->is_vararg & VARARG_NEEDSARG) ||+              (pt->is_vararg & VARARG_HASARG));+  check(pt->sizeupvalues <= pt->nups);+  check(pt->sizelineinfo == pt->sizecode || pt->sizelineinfo == 0);+  check(pt->sizecode > 0 && GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);+  return 1;+}+++#define checkopenop(pt,pc)	luaG_checkopenop((pt)->code[(pc)+1])++int luaG_checkopenop (Instruction i) {+  switch (GET_OPCODE(i)) {+    case OP_CALL:+    case OP_TAILCALL:+    case OP_RETURN:+    case OP_SETLIST: {+      check(GETARG_B(i) == 0);+      return 1;+    }+    default: return 0;  /* invalid instruction after an open call */+  }+}+++static int checkArgMode (const Proto *pt, int r, enum OpArgMask mode) {+  switch (mode) {+    case OpArgN: check(r == 0); break;+    case OpArgU: break;+    case OpArgR: checkreg(pt, r); break;+    case OpArgK:+      check(ISK(r) ? INDEXK(r) < pt->sizek : r < pt->maxstacksize);+      break;+  }+  return 1;+}+++static Instruction symbexec (const Proto *pt, int lastpc, int reg) {+  int pc;+  int last;  /* stores position of last instruction that changed `reg' */+  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */+  check(precheck(pt));+  for (pc = 0; pc < lastpc; pc++) {+    Instruction i = pt->code[pc];+    OpCode op = GET_OPCODE(i);+    int a = GETARG_A(i);+    int b = 0;+    int c = 0;+    check(op < NUM_OPCODES);+    checkreg(pt, a);+    switch (getOpMode(op)) {+      case iABC: {+        b = GETARG_B(i);+        c = GETARG_C(i);+        check(checkArgMode(pt, b, getBMode(op)));+        check(checkArgMode(pt, c, getCMode(op)));+        break;+      }+      case iABx: {+        b = GETARG_Bx(i);+        if (getBMode(op) == OpArgK) check(b < pt->sizek);+        break;+      }+      case iAsBx: {+        b = GETARG_sBx(i);+        if (getBMode(op) == OpArgR) {+          int dest = pc+1+b;+          check(0 <= dest && dest < pt->sizecode);+          if (dest > 0) {+            int j;+            /* check that it does not jump to a setlist count; this+               is tricky, because the count from a previous setlist may+               have the same value of an invalid setlist; so, we must+               go all the way back to the first of them (if any) */+            for (j = 0; j < dest; j++) {+              Instruction d = pt->code[dest-1-j];+              if (!(GET_OPCODE(d) == OP_SETLIST && GETARG_C(d) == 0)) break;+            }+            /* if 'j' is even, previous value is not a setlist (even if+               it looks like one) */+            check((j&1) == 0);+          }+        }+        break;+      }+    }+    if (testAMode(op)) {+      if (a == reg) last = pc;  /* change register `a' */+    }+    if (testTMode(op)) {+      check(pc+2 < pt->sizecode);  /* check skip */+      check(GET_OPCODE(pt->code[pc+1]) == OP_JMP);+    }+    switch (op) {+      case OP_LOADBOOL: {+        if (c == 1) {  /* does it jump? */+          check(pc+2 < pt->sizecode);  /* check its jump */+          check(GET_OPCODE(pt->code[pc+1]) != OP_SETLIST ||+                GETARG_C(pt->code[pc+1]) != 0);+        }+        break;+      }+      case OP_LOADNIL: {+        if (a <= reg && reg <= b)+          last = pc;  /* set registers from `a' to `b' */+        break;+      }+      case OP_GETUPVAL:+      case OP_SETUPVAL: {+        check(b < pt->nups);+        break;+      }+      case OP_GETGLOBAL:+      case OP_SETGLOBAL: {+        check(ttisstring(&pt->k[b]));+        break;+      }+      case OP_SELF: {+        checkreg(pt, a+1);+        if (reg == a+1) last = pc;+        break;+      }+      case OP_CONCAT: {+        check(b < c);  /* at least two operands */+        break;+      }+      case OP_TFORLOOP: {+        check(c >= 1);  /* at least one result (control variable) */+        checkreg(pt, a+2+c);  /* space for results */+        if (reg >= a+2) last = pc;  /* affect all regs above its base */+        break;+      }+      case OP_FORLOOP:+      case OP_FORPREP:+        checkreg(pt, a+3);+        /* go through */+      case OP_JMP: {+        int dest = pc+1+b;+        /* not full check and jump is forward and do not skip `lastpc'? */+        if (reg != NO_REG && pc < dest && dest <= lastpc)+          pc += b;  /* do the jump */+        break;+      }+      case OP_CALL:+      case OP_TAILCALL: {+        if (b != 0) {+          checkreg(pt, a+b-1);+        }+        c--;  /* c = num. returns */+        if (c == LUA_MULTRET) {+          check(checkopenop(pt, pc));+        }+        else if (c != 0)+          checkreg(pt, a+c-1);+        if (reg >= a) last = pc;  /* affect all registers above base */+        break;+      }+      case OP_RETURN: {+        b--;  /* b = num. returns */+        if (b > 0) checkreg(pt, a+b-1);+        break;+      }+      case OP_SETLIST: {+        if (b > 0) checkreg(pt, a + b);+        if (c == 0) {+          pc++;+          check(pc < pt->sizecode - 1);+        }+        break;+      }+      case OP_CLOSURE: {+        int nup, j;+        check(b < pt->sizep);+        nup = pt->p[b]->nups;+        check(pc + nup < pt->sizecode);+        for (j = 1; j <= nup; j++) {+          OpCode op1 = GET_OPCODE(pt->code[pc + j]);+          check(op1 == OP_GETUPVAL || op1 == OP_MOVE);+        }+        if (reg != NO_REG)  /* tracing? */+          pc += nup;  /* do not 'execute' these pseudo-instructions */+        break;+      }+      case OP_VARARG: {+        check((pt->is_vararg & VARARG_ISVARARG) &&+             !(pt->is_vararg & VARARG_NEEDSARG));+        b--;+        if (b == LUA_MULTRET) check(checkopenop(pt, pc));+        checkreg(pt, a+b-1);+        break;+      }+      default: break;+    }+  }+  return pt->code[last];+}++#undef check+#undef checkjump+#undef checkreg++/* }====================================================== */+++int luaG_checkcode (const Proto *pt) {+  return (symbexec(pt, pt->sizecode, NO_REG) != 0);+}+++static const char *kname (Proto *p, int c) {+  if (ISK(c) && ttisstring(&p->k[INDEXK(c)]))+    return svalue(&p->k[INDEXK(c)]);+  else+    return "?";+}+++static const char *getobjname (lua_State *L, CallInfo *ci, int stackpos,+                               const char **name) {+  if (isLua(ci)) {  /* a Lua function? */+    Proto *p = ci_func(ci)->l.p;+    int pc = currentpc(L, ci);+    Instruction i;+    *name = luaF_getlocalname(p, stackpos+1, pc);+    if (*name)  /* is a local? */+      return "local";+    i = symbexec(p, pc, stackpos);  /* try symbolic execution */+    lua_assert(pc != -1);+    switch (GET_OPCODE(i)) {+      case OP_GETGLOBAL: {+        int g = GETARG_Bx(i);  /* global index */+        lua_assert(ttisstring(&p->k[g]));+        *name = svalue(&p->k[g]);+        return "global";+      }+      case OP_MOVE: {+        int a = GETARG_A(i);+        int b = GETARG_B(i);  /* move from `b' to `a' */+        if (b < a)+          return getobjname(L, ci, b, name);  /* get name for `b' */+        break;+      }+      case OP_GETTABLE: {+        int k = GETARG_C(i);  /* key index */+        *name = kname(p, k);+        return "field";+      }+      case OP_GETUPVAL: {+        int u = GETARG_B(i);  /* upvalue index */+        *name = p->upvalues ? getstr(p->upvalues[u]) : "?";+        return "upvalue";+      }+      case OP_SELF: {+        int k = GETARG_C(i);  /* key index */+        *name = kname(p, k);+        return "method";+      }+      default: break;+    }+  }+  return NULL;  /* no useful name found */+}+++static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {+  Instruction i;+  if ((isLua(ci) && ci->tailcalls > 0) || !isLua(ci - 1))+    return NULL;  /* calling function is not Lua (or is unknown) */+  ci--;  /* calling function */+  i = ci_func(ci)->l.p->code[currentpc(L, ci)];+  if (GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||+      GET_OPCODE(i) == OP_TFORLOOP)+    return getobjname(L, ci, GETARG_A(i), name);+  else+    return NULL;  /* no useful name can be found */+}+++/* only ANSI way to check whether a pointer points to an array */+static int isinstack (CallInfo *ci, const TValue *o) {+  StkId p;+  for (p = ci->base; p < ci->top; p++)+    if (o == p) return 1;+  return 0;+}+++void luaG_typeerror (lua_State *L, const TValue *o, const char *op) {+  const char *name = NULL;+  const char *t = luaT_typenames[ttype(o)];+  const char *kind = (isinstack(L->ci, o)) ?+                         getobjname(L, L->ci, cast_int(o - L->base), &name) :+                         NULL;+  if (kind)+    luaG_runerror(L, "attempt to %s %s " LUA_QS " (a %s value)",+                op, kind, name, t);+  else+    luaG_runerror(L, "attempt to %s a %s value", op, t);+}+++void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {+  if (ttisstring(p1) || ttisnumber(p1)) p1 = p2;+  lua_assert(!ttisstring(p1) && !ttisnumber(p1));+  luaG_typeerror(L, p1, "concatenate");+}+++void luaG_aritherror (lua_State *L, const TValue *p1, const TValue *p2) {+  TValue temp;+  if (luaV_tonumber(p1, &temp) == NULL)+    p2 = p1;  /* first operand is wrong */+  luaG_typeerror(L, p2, "perform arithmetic on");+}+++int luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) {+  const char *t1 = luaT_typenames[ttype(p1)];+  const char *t2 = luaT_typenames[ttype(p2)];+  if (t1[2] == t2[2])+    luaG_runerror(L, "attempt to compare two %s values", t1);+  else+    luaG_runerror(L, "attempt to compare %s with %s", t1, t2);+  return 0;+}+++static void addinfo (lua_State *L, const char *msg) {+  CallInfo *ci = L->ci;+  if (isLua(ci)) {  /* is Lua code? */+    char buff[LUA_IDSIZE];  /* add file:line information */+    int line = currentline(L, ci);+    luaO_chunkid(buff, getstr(getluaproto(ci)->source), LUA_IDSIZE);+    luaO_pushfstring(L, "%s:%d: %s", buff, line, msg);+  }+}+++void luaG_errormsg (lua_State *L) {+  if (L->errfunc != 0) {  /* is there an error handling function? */+    StkId errfunc = restorestack(L, L->errfunc);+    if (!ttisfunction(errfunc)) luaD_throw(L, LUA_ERRERR);+    setobjs2s(L, L->top, L->top - 1);  /* move argument */+    setobjs2s(L, L->top - 1, errfunc);  /* push function */+    incr_top(L);+    luaD_call(L, L->top - 2, 1);  /* call it */+  }+  luaD_throw(L, LUA_ERRRUN);+}+++void luaG_runerror (lua_State *L, const char *fmt, ...) {+  va_list argp;+  va_start(argp, fmt);+  addinfo(L, luaO_pushvfstring(L, fmt, argp));+  va_end(argp);+  luaG_errormsg(L);+}+

@@ -0,0 +1,33 @@+/*+** $Id: ldebug.h,v 2.3.1.1 2007/12/27 13:02:25 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 getline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)++#define resethookcount(L)	(L->hookcount = L->basehookcount)+++LUAI_FUNC void luaG_typeerror (lua_State *L, const TValue *o,+                                             const char *opname);+LUAI_FUNC void luaG_concaterror (lua_State *L, StkId p1, StkId p2);+LUAI_FUNC void luaG_aritherror (lua_State *L, const TValue *p1,+                                              const TValue *p2);+LUAI_FUNC int luaG_ordererror (lua_State *L, const TValue *p1,+                                             const TValue *p2);+LUAI_FUNC void luaG_runerror (lua_State *L, const char *fmt, ...);+LUAI_FUNC void luaG_errormsg (lua_State *L);+LUAI_FUNC int luaG_checkcode (const Proto *pt);+LUAI_FUNC int luaG_checkopenop (Instruction i);++#endif

@@ -0,0 +1,519 @@+/*+** $Id: ldo.c,v 2.38.1.4 2012/01/18 02:27:10 roberto Exp $+** Stack and Call structure of Lua+** See Copyright Notice in lua.h+*/+++#include <setjmp.h>+#include <stdlib.h>+#include <string.h>++#define ldo_c+#define LUA_CORE++#include "lua.h"++#include "ldebug.h"+#include "ldo.h"+#include "lfunc.h"+#include "lgc.h"+#include "lmem.h"+#include "lobject.h"+#include "lopcodes.h"+#include "lparser.h"+#include "lstate.h"+#include "lstring.h"+#include "ltable.h"+#include "ltm.h"+#include "lundump.h"+#include "lvm.h"+#include "lzio.h"+++++/*+** {======================================================+** Error-recovery functions+** =======================================================+*/+++/* chain list of long jump buffers */+struct lua_longjmp {+  struct lua_longjmp *previous;+  luai_jmpbuf b;+  volatile int status;  /* error code */+};+++void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {+  switch (errcode) {+    case LUA_ERRMEM: {+      setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));+      break;+    }+    case LUA_ERRERR: {+      setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));+      break;+    }+    case LUA_ERRSYNTAX:+    case LUA_ERRRUN: {+      setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */+      break;+    }+  }+  L->top = oldtop + 1;+}+++static void restore_stack_limit (lua_State *L) {+  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);+  if (L->size_ci > LUAI_MAXCALLS) {  /* there was an overflow? */+    int inuse = cast_int(L->ci - L->base_ci);+    if (inuse + 1 < LUAI_MAXCALLS)  /* can `undo' overflow? */+      luaD_reallocCI(L, LUAI_MAXCALLS);+  }+}+++static void resetstack (lua_State *L, int status) {+  L->ci = L->base_ci;+  L->base = L->ci->base;+  luaF_close(L, L->base);  /* close eventual pending closures */+  luaD_seterrorobj(L, status, L->base);+  L->nCcalls = L->baseCcalls;+  L->allowhook = 1;+  restore_stack_limit(L);+  L->errfunc = 0;+  L->errorJmp = NULL;+}+++void luaD_throw (lua_State *L, int errcode) {+  if (L->errorJmp) {+    L->errorJmp->status = errcode;+    LUAI_THROW(L, L->errorJmp);+  }+  else {+    L->status = cast_byte(errcode);+    if (G(L)->panic) {+      resetstack(L, errcode);+      lua_unlock(L);+      G(L)->panic(L);+    }+    exit(EXIT_FAILURE);+  }+}+++int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {+  struct lua_longjmp lj;+  lj.status = 0;+  lj.previous = L->errorJmp;  /* chain new error handler */+  L->errorJmp = &lj;+  LUAI_TRY(L, &lj,+    (*f)(L, ud);+  );+  L->errorJmp = lj.previous;  /* restore old error handler */+  return lj.status;+}++/* }====================================================== */+++static void correctstack (lua_State *L, TValue *oldstack) {+  CallInfo *ci;+  GCObject *up;+  L->top = (L->top - oldstack) + L->stack;+  for (up = L->openupval; up != NULL; up = up->gch.next)+    gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;+  for (ci = L->base_ci; ci <= L->ci; ci++) {+    ci->top = (ci->top - oldstack) + L->stack;+    ci->base = (ci->base - oldstack) + L->stack;+    ci->func = (ci->func - oldstack) + L->stack;+  }+  L->base = (L->base - oldstack) + L->stack;+}+++void luaD_reallocstack (lua_State *L, int newsize) {+  TValue *oldstack = L->stack;+  int realsize = newsize + 1 + EXTRA_STACK;+  lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);+  luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);+  L->stacksize = realsize;+  L->stack_last = L->stack+newsize;+  correctstack(L, oldstack);+}+++void luaD_reallocCI (lua_State *L, int newsize) {+  CallInfo *oldci = L->base_ci;+  luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);+  L->size_ci = newsize;+  L->ci = (L->ci - oldci) + L->base_ci;+  L->end_ci = L->base_ci + L->size_ci - 1;+}+++void luaD_growstack (lua_State *L, int n) {+  if (n <= L->stacksize)  /* double size is enough? */+    luaD_reallocstack(L, 2*L->stacksize);+  else+    luaD_reallocstack(L, L->stacksize + n);+}+++static CallInfo *growCI (lua_State *L) {+  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */+    luaD_throw(L, LUA_ERRERR);+  else {+    luaD_reallocCI(L, 2*L->size_ci);+    if (L->size_ci > LUAI_MAXCALLS)+      luaG_runerror(L, "stack overflow");+  }+  return ++L->ci;+}+++void luaD_callhook (lua_State *L, int event, int line) {+  lua_Hook hook = L->hook;+  if (hook && L->allowhook) {+    ptrdiff_t top = savestack(L, L->top);+    ptrdiff_t ci_top = savestack(L, L->ci->top);+    lua_Debug ar;+    ar.event = event;+    ar.currentline = line;+    if (event == LUA_HOOKTAILRET)+      ar.i_ci = 0;  /* tail call; no debug information about it */+    else+      ar.i_ci = cast_int(L->ci - L->base_ci);+    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */+    L->ci->top = L->top + LUA_MINSTACK;+    lua_assert(L->ci->top <= L->stack_last);+    L->allowhook = 0;  /* cannot call hooks inside a hook */+    lua_unlock(L);+    (*hook)(L, &ar);+    lua_lock(L);+    lua_assert(!L->allowhook);+    L->allowhook = 1;+    L->ci->top = restorestack(L, ci_top);+    L->top = restorestack(L, top);+  }+}+++static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {+  int i;+  int nfixargs = p->numparams;+  Table *htab = NULL;+  StkId base, fixed;+  for (; actual < nfixargs; ++actual)+    setnilvalue(L->top++);+#if defined(LUA_COMPAT_VARARG)+  if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */+    int nvar = actual - nfixargs;  /* number of extra arguments */+    lua_assert(p->is_vararg & VARARG_HASARG);+    luaC_checkGC(L);+    luaD_checkstack(L, p->maxstacksize);+    htab = luaH_new(L, nvar, 1);  /* create `arg' table */+    for (i=0; i<nvar; i++)  /* put extra arguments into `arg' table */+      setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);+    /* store counter in field `n' */+    setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));+  }+#endif+  /* move fixed parameters to final position */+  fixed = L->top - actual;  /* first fixed argument */+  base = L->top;  /* final position of first argument */+  for (i=0; i<nfixargs; i++) {+    setobjs2s(L, L->top++, fixed+i);+    setnilvalue(fixed+i);+  }+  /* add `arg' parameter */+  if (htab) {+    sethvalue(L, L->top++, htab);+    lua_assert(iswhite(obj2gco(htab)));+  }+  return base;+}+++static StkId tryfuncTM (lua_State *L, StkId func) {+  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);+  StkId p;+  ptrdiff_t funcr = savestack(L, func);+  if (!ttisfunction(tm))+    luaG_typeerror(L, func, "call");+  /* Open a hole inside the stack at `func' */+  for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);+  incr_top(L);+  func = restorestack(L, funcr);  /* previous call may change stack */+  setobj2s(L, func, tm);  /* tag method is the new function to be called */+  return func;+}++++#define inc_ci(L) \+  ((L->ci == L->end_ci) ? growCI(L) : \+   (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))+++int luaD_precall (lua_State *L, StkId func, int nresults) {+  LClosure *cl;+  ptrdiff_t funcr;+  if (!ttisfunction(func)) /* `func' is not a function? */+    func = tryfuncTM(L, func);  /* check the `function' tag method */+  funcr = savestack(L, func);+  cl = &clvalue(func)->l;+  L->ci->savedpc = L->savedpc;+  if (!cl->isC) {  /* Lua function? prepare its call */+    CallInfo *ci;+    StkId st, base;+    Proto *p = cl->p;+    luaD_checkstack(L, p->maxstacksize);+    func = restorestack(L, funcr);+    if (!p->is_vararg) {  /* no varargs? */+      base = func + 1;+      if (L->top > base + p->numparams)+        L->top = base + p->numparams;+    }+    else {  /* vararg function */+      int nargs = cast_int(L->top - func) - 1;+      base = adjust_varargs(L, p, nargs);+      func = restorestack(L, funcr);  /* previous call may change the stack */+    }+    ci = inc_ci(L);  /* now `enter' new function */+    ci->func = func;+    L->base = ci->base = base;+    ci->top = L->base + p->maxstacksize;+    lua_assert(ci->top <= L->stack_last);+    L->savedpc = p->code;  /* starting point */+    ci->tailcalls = 0;+    ci->nresults = nresults;+    for (st = L->top; st < ci->top; st++)+      setnilvalue(st);+    L->top = ci->top;+    if (L->hookmask & LUA_MASKCALL) {+      L->savedpc++;  /* hooks assume 'pc' is already incremented */+      luaD_callhook(L, LUA_HOOKCALL, -1);+      L->savedpc--;  /* correct 'pc' */+    }+    return PCRLUA;+  }+  else {  /* if is a C function, call it */+    CallInfo *ci;+    int n;+    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */+    ci = inc_ci(L);  /* now `enter' new function */+    ci->func = restorestack(L, funcr);+    L->base = ci->base = ci->func + 1;+    ci->top = L->top + LUA_MINSTACK;+    lua_assert(ci->top <= L->stack_last);+    ci->nresults = nresults;+    if (L->hookmask & LUA_MASKCALL)+      luaD_callhook(L, LUA_HOOKCALL, -1);+    lua_unlock(L);+    n = (*curr_func(L)->c.f)(L);  /* do the actual call */+    lua_lock(L);+    if (n < 0)  /* yielding? */+      return PCRYIELD;+    else {+      luaD_poscall(L, L->top - n);+      return PCRC;+    }+  }+}+++static StkId callrethooks (lua_State *L, StkId firstResult) {+  ptrdiff_t fr = savestack(L, firstResult);  /* next call may change stack */+  luaD_callhook(L, LUA_HOOKRET, -1);+  if (f_isLua(L->ci)) {  /* Lua function? */+    while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */+      luaD_callhook(L, LUA_HOOKTAILRET, -1);+  }+  return restorestack(L, fr);+}+++int luaD_poscall (lua_State *L, StkId firstResult) {+  StkId res;+  int wanted, i;+  CallInfo *ci;+  if (L->hookmask & LUA_MASKRET)+    firstResult = callrethooks(L, firstResult);+  ci = L->ci--;+  res = ci->func;  /* res == final position of 1st result */+  wanted = ci->nresults;+  L->base = (ci - 1)->base;  /* restore base */+  L->savedpc = (ci - 1)->savedpc;  /* restore savedpc */+  /* move results to correct place */+  for (i = wanted; i != 0 && firstResult < L->top; i--)+    setobjs2s(L, res++, firstResult++);+  while (i-- > 0)+    setnilvalue(res++);+  L->top = res;+  return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */+}+++/*+** Call a function (C or Lua). The function to be called is at *func.+** The arguments are on the stack, right after the function.+** When returns, all the results are on the stack, starting at the original+** function position.+*/ +void luaD_call (lua_State *L, StkId func, int nResults) {+  if (++L->nCcalls >= LUAI_MAXCCALLS) {+    if (L->nCcalls == LUAI_MAXCCALLS)+      luaG_runerror(L, "C stack overflow");+    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))+      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */+  }+  if (luaD_precall(L, func, nResults) == PCRLUA)  /* is a Lua function? */+    luaV_execute(L, 1);  /* call it */+  L->nCcalls--;+  luaC_checkGC(L);+}+++static void resume (lua_State *L, void *ud) {+  StkId firstArg = cast(StkId, ud);+  CallInfo *ci = L->ci;+  if (L->status == 0) {  /* start coroutine? */+    lua_assert(ci == L->base_ci && firstArg > L->base);+    if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)+      return;+  }+  else {  /* resuming from previous yield */+    lua_assert(L->status == LUA_YIELD);+    L->status = 0;+    if (!f_isLua(ci)) {  /* `common' yield? */+      /* finish interrupted execution of `OP_CALL' */+      lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||+                 GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);+      if (luaD_poscall(L, firstArg))  /* complete it... */+        L->top = L->ci->top;  /* and correct top if not multiple results */+    }+    else  /* yielded inside a hook: just continue its execution */+      L->base = L->ci->base;+  }+  luaV_execute(L, cast_int(L->ci - L->base_ci));+}+++static int resume_error (lua_State *L, const char *msg) {+  L->top = L->ci->base;+  setsvalue2s(L, L->top, luaS_new(L, msg));+  incr_top(L);+  lua_unlock(L);+  return LUA_ERRRUN;+}+++LUA_API int lua_resume (lua_State *L, int nargs) {+  int status;+  lua_lock(L);+  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))+      return resume_error(L, "cannot resume non-suspended coroutine");+  if (L->nCcalls >= LUAI_MAXCCALLS)+    return resume_error(L, "C stack overflow");+  luai_userstateresume(L, nargs);+  lua_assert(L->errfunc == 0);+  L->baseCcalls = ++L->nCcalls;+  status = luaD_rawrunprotected(L, resume, L->top - nargs);+  if (status != 0) {  /* error? */+    L->status = cast_byte(status);  /* mark thread as `dead' */+    luaD_seterrorobj(L, status, L->top);+    L->ci->top = L->top;+  }+  else {+    lua_assert(L->nCcalls == L->baseCcalls);+    status = L->status;+  }+  --L->nCcalls;+  lua_unlock(L);+  return status;+}+++LUA_API int lua_yield (lua_State *L, int nresults) {+  luai_userstateyield(L, nresults);+  lua_lock(L);+  if (L->nCcalls > L->baseCcalls)+    luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");+  L->base = L->top - nresults;  /* protect stack slots below */+  L->status = LUA_YIELD;+  lua_unlock(L);+  return -1;+}+++int luaD_pcall (lua_State *L, Pfunc func, void *u,+                ptrdiff_t old_top, ptrdiff_t ef) {+  int status;+  unsigned short oldnCcalls = L->nCcalls;+  ptrdiff_t old_ci = saveci(L, L->ci);+  lu_byte old_allowhooks = L->allowhook;+  ptrdiff_t old_errfunc = L->errfunc;+  L->errfunc = ef;+  status = luaD_rawrunprotected(L, func, u);+  if (status != 0) {  /* an error occurred? */+    StkId oldtop = restorestack(L, old_top);+    luaF_close(L, oldtop);  /* close eventual pending closures */+    luaD_seterrorobj(L, status, oldtop);+    L->nCcalls = oldnCcalls;+    L->ci = restoreci(L, old_ci);+    L->base = L->ci->base;+    L->savedpc = L->ci->savedpc;+    L->allowhook = old_allowhooks;+    restore_stack_limit(L);+  }+  L->errfunc = old_errfunc;+  return status;+}++++/*+** Execute a protected parser.+*/+struct SParser {  /* data to `f_parser' */+  ZIO *z;+  Mbuffer buff;  /* buffer to be used by the scanner */+  const char *name;+};++static void f_parser (lua_State *L, void *ud) {+  int i;+  Proto *tf;+  Closure *cl;+  struct SParser *p = cast(struct SParser *, ud);+  int c = luaZ_lookahead(p->z);+  luaC_checkGC(L);+  tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,+                                                             &p->buff, p->name);+  cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));+  cl->l.p = tf;+  for (i = 0; i < tf->nups; i++)  /* initialize eventual upvalues */+    cl->l.upvals[i] = luaF_newupval(L);+  setclvalue(L, L->top, cl);+  incr_top(L);+}+++int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {+  struct SParser p;+  int status;+  p.z = z; p.name = name;+  luaZ_initbuffer(L, &p.buff);+  status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);+  luaZ_freebuffer(L, &p.buff);+  return status;+}++

@@ -0,0 +1,57 @@+/*+** $Id: ldo.h,v 2.7.1.1 2007/12/27 13:02:25 roberto Exp $+** Stack and Call structure of Lua+** See Copyright Notice in lua.h+*/++#ifndef ldo_h+#define ldo_h+++#include "lobject.h"+#include "lstate.h"+#include "lzio.h"+++#define luaD_checkstack(L,n)	\+  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \+    luaD_growstack(L, n); \+  else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));+++#define incr_top(L) {luaD_checkstack(L,1); L->top++;}++#define savestack(L,p)		((char *)(p) - (char *)L->stack)+#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))++#define saveci(L,p)		((char *)(p) - (char *)L->base_ci)+#define restoreci(L,n)		((CallInfo *)((char *)L->base_ci + (n)))+++/* results from luaD_precall */+#define PCRLUA		0	/* initiated a call to a Lua function */+#define PCRC		1	/* did a call to a C function */+#define PCRYIELD	2	/* C funtion yielded */+++/* type of protected functions, to be ran by `runprotected' */+typedef void (*Pfunc) (lua_State *L, void *ud);++LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name);+LUAI_FUNC void luaD_callhook (lua_State *L, int event, int line);+LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);+LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);+LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,+                                        ptrdiff_t oldtop, ptrdiff_t ef);+LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);+LUAI_FUNC void luaD_reallocCI (lua_State *L, int newsize);+LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);+LUAI_FUNC void luaD_growstack (lua_State *L, int n);++LUAI_FUNC void luaD_throw (lua_State *L, int errcode);+LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);++LUAI_FUNC void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop);++#endif+

@@ -0,0 +1,164 @@+/*+** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $+** save precompiled Lua chunks+** See Copyright Notice in lua.h+*/++#include <stddef.h>++#define ldump_c+#define LUA_CORE++#include "lua.h"++#include "lobject.h"+#include "lstate.h"+#include "lundump.h"++typedef struct {+ lua_State* L;+ lua_Writer writer;+ void* data;+ int strip;+ int status;+} DumpState;++#define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)+#define DumpVar(x,D)	 	DumpMem(&x,1,sizeof(x),D)++static void DumpBlock(const void* b, size_t size, DumpState* D)+{+ if (D->status==0)+ {+  lua_unlock(D->L);+  D->status=(*D->writer)(D->L,b,size,D->data);+  lua_lock(D->L);+ }+}++static void DumpChar(int y, DumpState* D)+{+ char x=(char)y;+ DumpVar(x,D);+}++static void DumpInt(int x, DumpState* D)+{+ DumpVar(x,D);+}++static void DumpNumber(lua_Number x, DumpState* D)+{+ DumpVar(x,D);+}++static void DumpVector(const void* b, int n, size_t size, DumpState* D)+{+ DumpInt(n,D);+ DumpMem(b,n,size,D);+}++static void DumpString(const TString* s, DumpState* D)+{+ if (s==NULL || getstr(s)==NULL)+ {+  size_t size=0;+  DumpVar(size,D);+ }+ else+ {+  size_t size=s->tsv.len+1;		/* include trailing '\0' */+  DumpVar(size,D);+  DumpBlock(getstr(s),size,D);+ }+}++#define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)++static void DumpFunction(const Proto* f, const TString* p, DumpState* D);++static void DumpConstants(const Proto* f, DumpState* D)+{+ int i,n=f->sizek;+ DumpInt(n,D);+ for (i=0; i<n; i++)+ {+  const TValue* o=&f->k[i];+  DumpChar(ttype(o),D);+  switch (ttype(o))+  {+   case LUA_TNIL:+	break;+   case LUA_TBOOLEAN:+	DumpChar(bvalue(o),D);+	break;+   case LUA_TNUMBER:+	DumpNumber(nvalue(o),D);+	break;+   case LUA_TSTRING:+	DumpString(rawtsvalue(o),D);+	break;+   default:+	lua_assert(0);			/* cannot happen */+	break;+  }+ }+ n=f->sizep;+ DumpInt(n,D);+ for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);+}++static void DumpDebug(const Proto* f, DumpState* D)+{+ int i,n;+ n= (D->strip) ? 0 : f->sizelineinfo;+ DumpVector(f->lineinfo,n,sizeof(int),D);+ n= (D->strip) ? 0 : f->sizelocvars;+ DumpInt(n,D);+ for (i=0; i<n; i++)+ {+  DumpString(f->locvars[i].varname,D);+  DumpInt(f->locvars[i].startpc,D);+  DumpInt(f->locvars[i].endpc,D);+ }+ n= (D->strip) ? 0 : f->sizeupvalues;+ DumpInt(n,D);+ for (i=0; i<n; i++) DumpString(f->upvalues[i],D);+}++static void DumpFunction(const Proto* f, const TString* p, DumpState* D)+{+ DumpString((f->source==p || D->strip) ? NULL : f->source,D);+ DumpInt(f->linedefined,D);+ DumpInt(f->lastlinedefined,D);+ DumpChar(f->nups,D);+ DumpChar(f->numparams,D);+ DumpChar(f->is_vararg,D);+ DumpChar(f->maxstacksize,D);+ DumpCode(f,D);+ DumpConstants(f,D);+ DumpDebug(f,D);+}++static void DumpHeader(DumpState* D)+{+ char h[LUAC_HEADERSIZE];+ luaU_header(h);+ DumpBlock(h,LUAC_HEADERSIZE,D);+}++/*+** dump Lua function as precompiled chunk+*/+int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)+{+ DumpState D;+ D.L=L;+ D.writer=w;+ D.data=data;+ D.strip=strip;+ D.status=0;+ DumpHeader(&D);+ DumpFunction(f,NULL,&D);+ return D.status;+}

@@ -0,0 +1,174 @@+/*+** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $+** Auxiliary functions to manipulate prototypes and closures+** See Copyright Notice in lua.h+*/+++#include <stddef.h>++#define lfunc_c+#define LUA_CORE++#include "lua.h"++#include "lfunc.h"+#include "lgc.h"+#include "lmem.h"+#include "lobject.h"+#include "lstate.h"++++Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {+  Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);+  c->c.isC = 1;+  c->c.env = e;+  c->c.nupvalues = cast_byte(nelems);+  return c;+}+++Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {+  Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));+  luaC_link(L, obj2gco(c), LUA_TFUNCTION);+  c->l.isC = 0;+  c->l.env = e;+  c->l.nupvalues = cast_byte(nelems);+  while (nelems--) c->l.upvals[nelems] = NULL;+  return c;+}+++UpVal *luaF_newupval (lua_State *L) {+  UpVal *uv = luaM_new(L, UpVal);+  luaC_link(L, obj2gco(uv), LUA_TUPVAL);+  uv->v = &uv->u.value;+  setnilvalue(uv->v);+  return uv;+}+++UpVal *luaF_findupval (lua_State *L, StkId level) {+  global_State *g = G(L);+  GCObject **pp = &L->openupval;+  UpVal *p;+  UpVal *uv;+  while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {+    lua_assert(p->v != &p->u.value);+    if (p->v == level) {  /* found a corresponding upvalue? */+      if (isdead(g, obj2gco(p)))  /* is it dead? */+        changewhite(obj2gco(p));  /* ressurect it */+      return p;+    }+    pp = &p->next;+  }+  uv = luaM_new(L, UpVal);  /* not found: create a new one */+  uv->tt = LUA_TUPVAL;+  uv->marked = luaC_white(g);+  uv->v = level;  /* current value lives in the stack */+  uv->next = *pp;  /* chain it in the proper position */+  *pp = obj2gco(uv);+  uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */+  uv->u.l.next = g->uvhead.u.l.next;+  uv->u.l.next->u.l.prev = uv;+  g->uvhead.u.l.next = uv;+  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);+  return uv;+}+++static void unlinkupval (UpVal *uv) {+  lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);+  uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */+  uv->u.l.prev->u.l.next = uv->u.l.next;+}+++void luaF_freeupval (lua_State *L, UpVal *uv) {+  if (uv->v != &uv->u.value)  /* is it open? */+    unlinkupval(uv);  /* remove from open list */+  luaM_free(L, uv);  /* free upvalue */+}+++void luaF_close (lua_State *L, StkId level) {+  UpVal *uv;+  global_State *g = G(L);+  while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {+    GCObject *o = obj2gco(uv);+    lua_assert(!isblack(o) && uv->v != &uv->u.value);+    L->openupval = uv->next;  /* remove from `open' list */+    if (isdead(g, o))+      luaF_freeupval(L, uv);  /* free upvalue */+    else {+      unlinkupval(uv);+      setobj(L, &uv->u.value, uv->v);+      uv->v = &uv->u.value;  /* now current value lives here */+      luaC_linkupval(L, uv);  /* link upvalue into `gcroot' list */+    }+  }+}+++Proto *luaF_newproto (lua_State *L) {+  Proto *f = luaM_new(L, Proto);+  luaC_link(L, obj2gco(f), LUA_TPROTO);+  f->k = NULL;+  f->sizek = 0;+  f->p = NULL;+  f->sizep = 0;+  f->code = NULL;+  f->sizecode = 0;+  f->sizelineinfo = 0;+  f->sizeupvalues = 0;+  f->nups = 0;+  f->upvalues = NULL;+  f->numparams = 0;+  f->is_vararg = 0;+  f->maxstacksize = 0;+  f->lineinfo = NULL;+  f->sizelocvars = 0;+  f->locvars = NULL;+  f->linedefined = 0;+  f->lastlinedefined = 0;+  f->source = NULL;+  return f;+}+++void luaF_freeproto (lua_State *L, Proto *f) {+  luaM_freearray(L, f->code, f->sizecode, Instruction);+  luaM_freearray(L, f->p, f->sizep, Proto *);+  luaM_freearray(L, f->k, f->sizek, TValue);+  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);+  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);+  luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);+  luaM_free(L, f);+}+++void luaF_freeclosure (lua_State *L, Closure *c) {+  int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :+                          sizeLclosure(c->l.nupvalues);+  luaM_freemem(L, c, size);+}+++/*+** Look for n-th local variable at line `line' in function `func'.+** Returns NULL if not found.+*/+const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {+  int i;+  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {+    if (pc < f->locvars[i].endpc) {  /* is variable active? */+      local_number--;+      if (local_number == 0)+        return getstr(f->locvars[i].varname);+    }+  }+  return NULL;  /* not found */+}+

@@ -0,0 +1,34 @@+/*+** $Id: lfunc.h,v 2.4.1.1 2007/12/27 13:02:25 roberto Exp $+** Auxiliary functions to manipulate prototypes and closures+** See Copyright Notice in lua.h+*/++#ifndef lfunc_h+#define lfunc_h+++#include "lobject.h"+++#define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \+                         cast(int, sizeof(TValue)*((n)-1)))++#define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \+                         cast(int, sizeof(TValue *)*((n)-1)))+++LUAI_FUNC Proto *luaF_newproto (lua_State *L);+LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e);+LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e);+LUAI_FUNC UpVal *luaF_newupval (lua_State *L);+LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);+LUAI_FUNC void luaF_close (lua_State *L, StkId level);+LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);+LUAI_FUNC void luaF_freeclosure (lua_State *L, Closure *c);+LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);+LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,+                                         int pc);+++#endif

@@ -0,0 +1,710 @@+/*+** $Id: lgc.c,v 2.38.1.2 2011/03/18 18:05:38 roberto Exp $+** Garbage Collector+** See Copyright Notice in lua.h+*/++#include <string.h>++#define lgc_c+#define LUA_CORE++#include "lua.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"+++#define GCSTEPSIZE	1024u+#define GCSWEEPMAX	40+#define GCSWEEPCOST	10+#define GCFINALIZECOST	100+++#define maskmarks	cast_byte(~(bitmask(BLACKBIT)|WHITEBITS))++#define makewhite(g,x)	\+   ((x)->gch.marked = cast_byte(((x)->gch.marked & maskmarks) | luaC_white(g)))++#define white2gray(x)	reset2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)+#define black2gray(x)	resetbit((x)->gch.marked, BLACKBIT)++#define stringmark(s)	reset2bits((s)->tsv.marked, WHITE0BIT, WHITE1BIT)+++#define isfinalized(u)		testbit((u)->marked, FINALIZEDBIT)+#define markfinalized(u)	l_setbit((u)->marked, FINALIZEDBIT)+++#define KEYWEAK         bitmask(KEYWEAKBIT)+#define VALUEWEAK       bitmask(VALUEWEAKBIT)++++#define markvalue(g,o) { checkconsistency(o); \+  if (iscollectable(o) && iswhite(gcvalue(o))) reallymarkobject(g,gcvalue(o)); }++#define markobject(g,t) { if (iswhite(obj2gco(t))) \+		reallymarkobject(g, obj2gco(t)); }+++#define setthreshold(g)  (g->GCthreshold = (g->estimate/100) * g->gcpause)+++static void removeentry (Node *n) {+  lua_assert(ttisnil(gval(n)));+  if (iscollectable(gkey(n)))+    setttype(gkey(n), LUA_TDEADKEY);  /* dead key; remove it */+}+++static void reallymarkobject (global_State *g, GCObject *o) {+  lua_assert(iswhite(o) && !isdead(g, o));+  white2gray(o);+  switch (o->gch.tt) {+    case LUA_TSTRING: {+      return;+    }+    case LUA_TUSERDATA: {+      Table *mt = gco2u(o)->metatable;+      gray2black(o);  /* udata are never gray */+      if (mt) markobject(g, mt);+      markobject(g, gco2u(o)->env);+      return;+    }+    case LUA_TUPVAL: {+      UpVal *uv = gco2uv(o);+      markvalue(g, uv->v);+      if (uv->v == &uv->u.value)  /* closed? */+        gray2black(o);  /* open upvalues are never black */+      return;+    }+    case LUA_TFUNCTION: {+      gco2cl(o)->c.gclist = g->gray;+      g->gray = o;+      break;+    }+    case LUA_TTABLE: {+      gco2h(o)->gclist = g->gray;+      g->gray = o;+      break;+    }+    case LUA_TTHREAD: {+      gco2th(o)->gclist = g->gray;+      g->gray = o;+      break;+    }+    case LUA_TPROTO: {+      gco2p(o)->gclist = g->gray;+      g->gray = o;+      break;+    }+    default: lua_assert(0);+  }+}+++static void marktmu (global_State *g) {+  GCObject *u = g->tmudata;+  if (u) {+    do {+      u = u->gch.next;+      makewhite(g, u);  /* may be marked, if left from previous GC */+      reallymarkobject(g, u);+    } while (u != g->tmudata);+  }+}+++/* move `dead' udata that need finalization to list `tmudata' */+size_t luaC_separateudata (lua_State *L, int all) {+  global_State *g = G(L);+  size_t deadmem = 0;+  GCObject **p = &g->mainthread->next;+  GCObject *curr;+  while ((curr = *p) != NULL) {+    if (!(iswhite(curr) || all) || isfinalized(gco2u(curr)))+      p = &curr->gch.next;  /* don't bother with them */+    else if (fasttm(L, gco2u(curr)->metatable, TM_GC) == NULL) {+      markfinalized(gco2u(curr));  /* don't need finalization */+      p = &curr->gch.next;+    }+    else {  /* must call its gc method */+      deadmem += sizeudata(gco2u(curr));+      markfinalized(gco2u(curr));+      *p = curr->gch.next;+      /* link `curr' at the end of `tmudata' list */+      if (g->tmudata == NULL)  /* list is empty? */+        g->tmudata = curr->gch.next = curr;  /* creates a circular list */+      else {+        curr->gch.next = g->tmudata->gch.next;+        g->tmudata->gch.next = curr;+        g->tmudata = curr;+      }+    }+  }+  return deadmem;+}+++static int traversetable (global_State *g, Table *h) {+  int i;+  int weakkey = 0;+  int weakvalue = 0;+  const TValue *mode;+  if (h->metatable)+    markobject(g, h->metatable);+  mode = gfasttm(g, h->metatable, TM_MODE);+  if (mode && ttisstring(mode)) {  /* is there a weak mode? */+    weakkey = (strchr(svalue(mode), 'k') != NULL);+    weakvalue = (strchr(svalue(mode), 'v') != NULL);+    if (weakkey || weakvalue) {  /* is really weak? */+      h->marked &= ~(KEYWEAK | VALUEWEAK);  /* clear bits */+      h->marked |= cast_byte((weakkey << KEYWEAKBIT) |+                             (weakvalue << VALUEWEAKBIT));+      h->gclist = g->weak;  /* must be cleared after GC, ... */+      g->weak = obj2gco(h);  /* ... so put in the appropriate list */+    }+  }+  if (weakkey && weakvalue) return 1;+  if (!weakvalue) {+    i = h->sizearray;+    while (i--)+      markvalue(g, &h->array[i]);+  }+  i = sizenode(h);+  while (i--) {+    Node *n = gnode(h, i);+    lua_assert(ttype(gkey(n)) != LUA_TDEADKEY || ttisnil(gval(n)));+    if (ttisnil(gval(n)))+      removeentry(n);  /* remove empty entries */+    else {+      lua_assert(!ttisnil(gkey(n)));+      if (!weakkey) markvalue(g, gkey(n));+      if (!weakvalue) markvalue(g, gval(n));+    }+  }+  return weakkey || weakvalue;+}+++/*+** All marks are conditional because a GC may happen while the+** prototype is still being created+*/+static void traverseproto (global_State *g, Proto *f) {+  int i;+  if (f->source) stringmark(f->source);+  for (i=0; i<f->sizek; i++)  /* mark literals */+    markvalue(g, &f->k[i]);+  for (i=0; i<f->sizeupvalues; i++) {  /* mark upvalue names */+    if (f->upvalues[i])+      stringmark(f->upvalues[i]);+  }+  for (i=0; i<f->sizep; i++) {  /* mark nested protos */+    if (f->p[i])+      markobject(g, f->p[i]);+  }+  for (i=0; i<f->sizelocvars; i++) {  /* mark local-variable names */+    if (f->locvars[i].varname)+      stringmark(f->locvars[i].varname);+  }+}++++static void traverseclosure (global_State *g, Closure *cl) {+  markobject(g, cl->c.env);+  if (cl->c.isC) {+    int i;+    for (i=0; i<cl->c.nupvalues; i++)  /* mark its upvalues */+      markvalue(g, &cl->c.upvalue[i]);+  }+  else {+    int i;+    lua_assert(cl->l.nupvalues == cl->l.p->nups);+    markobject(g, cl->l.p);+    for (i=0; i<cl->l.nupvalues; i++)  /* mark its upvalues */+      markobject(g, cl->l.upvals[i]);+  }+}+++static void checkstacksizes (lua_State *L, StkId max) {+  int ci_used = cast_int(L->ci - L->base_ci);  /* number of `ci' in use */+  int s_used = cast_int(max - L->stack);  /* part of stack in use */+  if (L->size_ci > LUAI_MAXCALLS)  /* handling overflow? */+    return;  /* do not touch the stacks */+  if (4*ci_used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)+    luaD_reallocCI(L, L->size_ci/2);  /* still big enough... */+  condhardstacktests(luaD_reallocCI(L, ci_used + 1));+  if (4*s_used < L->stacksize &&+      2*(BASIC_STACK_SIZE+EXTRA_STACK) < L->stacksize)+    luaD_reallocstack(L, L->stacksize/2);  /* still big enough... */+  condhardstacktests(luaD_reallocstack(L, s_used));+}+++static void traversestack (global_State *g, lua_State *l) {+  StkId o, lim;+  CallInfo *ci;+  markvalue(g, gt(l));+  lim = l->top;+  for (ci = l->base_ci; ci <= l->ci; ci++) {+    lua_assert(ci->top <= l->stack_last);+    if (lim < ci->top) lim = ci->top;+  }+  for (o = l->stack; o < l->top; o++)+    markvalue(g, o);+  for (; o <= lim; o++)+    setnilvalue(o);+  checkstacksizes(l, lim);+}+++/*+** traverse one gray object, turning it to black.+** Returns `quantity' traversed.+*/+static l_mem propagatemark (global_State *g) {+  GCObject *o = g->gray;+  lua_assert(isgray(o));+  gray2black(o);+  switch (o->gch.tt) {+    case LUA_TTABLE: {+      Table *h = gco2h(o);+      g->gray = h->gclist;+      if (traversetable(g, h))  /* table is weak? */+        black2gray(o);  /* keep it gray */+      return sizeof(Table) + sizeof(TValue) * h->sizearray ++                             sizeof(Node) * sizenode(h);+    }+    case LUA_TFUNCTION: {+      Closure *cl = gco2cl(o);+      g->gray = cl->c.gclist;+      traverseclosure(g, cl);+      return (cl->c.isC) ? sizeCclosure(cl->c.nupvalues) :+                           sizeLclosure(cl->l.nupvalues);+    }+    case LUA_TTHREAD: {+      lua_State *th = gco2th(o);+      g->gray = th->gclist;+      th->gclist = g->grayagain;+      g->grayagain = o;+      black2gray(o);+      traversestack(g, th);+      return sizeof(lua_State) + sizeof(TValue) * th->stacksize ++                                 sizeof(CallInfo) * th->size_ci;+    }+    case LUA_TPROTO: {+      Proto *p = gco2p(o);+      g->gray = p->gclist;+      traverseproto(g, p);+      return sizeof(Proto) + sizeof(Instruction) * p->sizecode ++                             sizeof(Proto *) * p->sizep ++                             sizeof(TValue) * p->sizek + +                             sizeof(int) * p->sizelineinfo ++                             sizeof(LocVar) * p->sizelocvars ++                             sizeof(TString *) * p->sizeupvalues;+    }+    default: lua_assert(0); return 0;+  }+}+++static size_t propagateall (global_State *g) {+  size_t m = 0;+  while (g->gray) m += propagatemark(g);+  return m;+}+++/*+** The next function tells whether a key or value can be cleared from+** a weak table. Non-collectable objects are never removed from weak+** tables. Strings behave as `values', so are never removed too. for+** other objects: if really collected, cannot keep them; for userdata+** being finalized, keep them in keys, but not in values+*/+static int iscleared (const TValue *o, int iskey) {+  if (!iscollectable(o)) return 0;+  if (ttisstring(o)) {+    stringmark(rawtsvalue(o));  /* strings are `values', so are never weak */+    return 0;+  }+  return iswhite(gcvalue(o)) ||+    (ttisuserdata(o) && (!iskey && isfinalized(uvalue(o))));+}+++/*+** clear collected entries from weaktables+*/+static void cleartable (GCObject *l) {+  while (l) {+    Table *h = gco2h(l);+    int i = h->sizearray;+    lua_assert(testbit(h->marked, VALUEWEAKBIT) ||+               testbit(h->marked, KEYWEAKBIT));+    if (testbit(h->marked, VALUEWEAKBIT)) {+      while (i--) {+        TValue *o = &h->array[i];+        if (iscleared(o, 0))  /* value was collected? */+          setnilvalue(o);  /* remove value */+      }+    }+    i = sizenode(h);+    while (i--) {+      Node *n = gnode(h, i);+      if (!ttisnil(gval(n)) &&  /* non-empty entry? */+          (iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {+        setnilvalue(gval(n));  /* remove value ... */+        removeentry(n);  /* remove entry from table */+      }+    }+    l = h->gclist;+  }+}+++static void freeobj (lua_State *L, GCObject *o) {+  switch (o->gch.tt) {+    case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;+    case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;+    case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;+    case LUA_TTABLE: luaH_free(L, gco2h(o)); break;+    case LUA_TTHREAD: {+      lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);+      luaE_freethread(L, gco2th(o));+      break;+    }+    case LUA_TSTRING: {+      G(L)->strt.nuse--;+      luaM_freemem(L, o, sizestring(gco2ts(o)));+      break;+    }+    case LUA_TUSERDATA: {+      luaM_freemem(L, o, sizeudata(gco2u(o)));+      break;+    }+    default: lua_assert(0);+  }+}++++#define sweepwholelist(L,p)	sweeplist(L,p,MAX_LUMEM)+++static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {+  GCObject *curr;+  global_State *g = G(L);+  int deadmask = otherwhite(g);+  while ((curr = *p) != NULL && count-- > 0) {+    if (curr->gch.tt == LUA_TTHREAD)  /* sweep open upvalues of each thread */+      sweepwholelist(L, &gco2th(curr)->openupval);+    if ((curr->gch.marked ^ WHITEBITS) & deadmask) {  /* not dead? */+      lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));+      makewhite(g, curr);  /* make it white (for next cycle) */+      p = &curr->gch.next;+    }+    else {  /* must erase `curr' */+      lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));+      *p = curr->gch.next;+      if (curr == g->rootgc)  /* is the first element of the list? */+        g->rootgc = curr->gch.next;  /* adjust first */+      freeobj(L, curr);+    }+  }+  return p;+}+++static void checkSizes (lua_State *L) {+  global_State *g = G(L);+  /* check size of string hash */+  if (g->strt.nuse < cast(lu_int32, g->strt.size/4) &&+      g->strt.size > MINSTRTABSIZE*2)+    luaS_resize(L, g->strt.size/2);  /* table is too big */+  /* check size of buffer */+  if (luaZ_sizebuffer(&g->buff) > LUA_MINBUFFER*2) {  /* buffer too big? */+    size_t newsize = luaZ_sizebuffer(&g->buff) / 2;+    luaZ_resizebuffer(L, &g->buff, newsize);+  }+}+++static void GCTM (lua_State *L) {+  global_State *g = G(L);+  GCObject *o = g->tmudata->gch.next;  /* get first element */+  Udata *udata = rawgco2u(o);+  const TValue *tm;+  /* remove udata from `tmudata' */+  if (o == g->tmudata)  /* last element? */+    g->tmudata = NULL;+  else+    g->tmudata->gch.next = udata->uv.next;+  udata->uv.next = g->mainthread->next;  /* return it to `root' list */+  g->mainthread->next = o;+  makewhite(g, o);+  tm = fasttm(L, udata->uv.metatable, TM_GC);+  if (tm != NULL) {+    lu_byte oldah = L->allowhook;+    lu_mem oldt = g->GCthreshold;+    L->allowhook = 0;  /* stop debug hooks during GC tag method */+    g->GCthreshold = 2*g->totalbytes;  /* avoid GC steps */+    setobj2s(L, L->top, tm);+    setuvalue(L, L->top+1, udata);+    L->top += 2;+    luaD_call(L, L->top - 2, 0);+    L->allowhook = oldah;  /* restore hooks */+    g->GCthreshold = oldt;  /* restore threshold */+  }+}+++/*+** Call all GC tag methods+*/+void luaC_callGCTM (lua_State *L) {+  while (G(L)->tmudata)+    GCTM(L);+}+++void luaC_freeall (lua_State *L) {+  global_State *g = G(L);+  int i;+  g->currentwhite = WHITEBITS | bitmask(SFIXEDBIT);  /* mask to collect all elements */+  sweepwholelist(L, &g->rootgc);+  for (i = 0; i < g->strt.size; i++)  /* free all string lists */+    sweepwholelist(L, &g->strt.hash[i]);+}+++static void markmt (global_State *g) {+  int i;+  for (i=0; i<NUM_TAGS; i++)+    if (g->mt[i]) markobject(g, g->mt[i]);+}+++/* mark root set */+static void markroot (lua_State *L) {+  global_State *g = G(L);+  g->gray = NULL;+  g->grayagain = NULL;+  g->weak = NULL;+  markobject(g, g->mainthread);+  /* make global table be traversed before main stack */+  markvalue(g, gt(g->mainthread));+  markvalue(g, registry(L));+  markmt(g);+  g->gcstate = GCSpropagate;+}+++static void remarkupvals (global_State *g) {+  UpVal *uv;+  for (uv = g->uvhead.u.l.next; uv != &g->uvhead; uv = uv->u.l.next) {+    lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);+    if (isgray(obj2gco(uv)))+      markvalue(g, uv->v);+  }+}+++static void atomic (lua_State *L) {+  global_State *g = G(L);+  size_t udsize;  /* total size of userdata to be finalized */+  /* remark occasional upvalues of (maybe) dead threads */+  remarkupvals(g);+  /* traverse objects cautch by write barrier and by 'remarkupvals' */+  propagateall(g);+  /* remark weak tables */+  g->gray = g->weak;+  g->weak = NULL;+  lua_assert(!iswhite(obj2gco(g->mainthread)));+  markobject(g, L);  /* mark running thread */+  markmt(g);  /* mark basic metatables (again) */+  propagateall(g);+  /* remark gray again */+  g->gray = g->grayagain;+  g->grayagain = NULL;+  propagateall(g);+  udsize = luaC_separateudata(L, 0);  /* separate userdata to be finalized */+  marktmu(g);  /* mark `preserved' userdata */+  udsize += propagateall(g);  /* remark, to propagate `preserveness' */+  cleartable(g->weak);  /* remove collected objects from weak tables */+  /* flip current white */+  g->currentwhite = cast_byte(otherwhite(g));+  g->sweepstrgc = 0;+  g->sweepgc = &g->rootgc;+  g->gcstate = GCSsweepstring;+  g->estimate = g->totalbytes - udsize;  /* first estimate */+}+++static l_mem singlestep (lua_State *L) {+  global_State *g = G(L);+  /*lua_checkmemory(L);*/+  switch (g->gcstate) {+    case GCSpause: {+      markroot(L);  /* start a new collection */+      return 0;+    }+    case GCSpropagate: {+      if (g->gray)+        return propagatemark(g);+      else {  /* no more `gray' objects */+        atomic(L);  /* finish mark phase */+        return 0;+      }+    }+    case GCSsweepstring: {+      lu_mem old = g->totalbytes;+      sweepwholelist(L, &g->strt.hash[g->sweepstrgc++]);+      if (g->sweepstrgc >= g->strt.size)  /* nothing more to sweep? */+        g->gcstate = GCSsweep;  /* end sweep-string phase */+      lua_assert(old >= g->totalbytes);+      g->estimate -= old - g->totalbytes;+      return GCSWEEPCOST;+    }+    case GCSsweep: {+      lu_mem old = g->totalbytes;+      g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX);+      if (*g->sweepgc == NULL) {  /* nothing more to sweep? */+        checkSizes(L);+        g->gcstate = GCSfinalize;  /* end sweep phase */+      }+      lua_assert(old >= g->totalbytes);+      g->estimate -= old - g->totalbytes;+      return GCSWEEPMAX*GCSWEEPCOST;+    }+    case GCSfinalize: {+      if (g->tmudata) {+        GCTM(L);+        if (g->estimate > GCFINALIZECOST)+          g->estimate -= GCFINALIZECOST;+        return GCFINALIZECOST;+      }+      else {+        g->gcstate = GCSpause;  /* end collection */+        g->gcdept = 0;+        return 0;+      }+    }+    default: lua_assert(0); return 0;+  }+}+++void luaC_step (lua_State *L) {+  global_State *g = G(L);+  l_mem lim = (GCSTEPSIZE/100) * g->gcstepmul;+  if (lim == 0)+    lim = (MAX_LUMEM-1)/2;  /* no limit */+  g->gcdept += g->totalbytes - g->GCthreshold;+  do {+    lim -= singlestep(L);+    if (g->gcstate == GCSpause)+      break;+  } while (lim > 0);+  if (g->gcstate != GCSpause) {+    if (g->gcdept < GCSTEPSIZE)+      g->GCthreshold = g->totalbytes + GCSTEPSIZE;  /* - lim/g->gcstepmul;*/+    else {+      g->gcdept -= GCSTEPSIZE;+      g->GCthreshold = g->totalbytes;+    }+  }+  else {+    setthreshold(g);+  }+}+++void luaC_fullgc (lua_State *L) {+  global_State *g = G(L);+  if (g->gcstate <= GCSpropagate) {+    /* reset sweep marks to sweep all elements (returning them to white) */+    g->sweepstrgc = 0;+    g->sweepgc = &g->rootgc;+    /* reset other collector lists */+    g->gray = NULL;+    g->grayagain = NULL;+    g->weak = NULL;+    g->gcstate = GCSsweepstring;+  }+  lua_assert(g->gcstate != GCSpause && g->gcstate != GCSpropagate);+  /* finish any pending sweep phase */+  while (g->gcstate != GCSfinalize) {+    lua_assert(g->gcstate == GCSsweepstring || g->gcstate == GCSsweep);+    singlestep(L);+  }+  markroot(L);+  while (g->gcstate != GCSpause) {+    singlestep(L);+  }+  setthreshold(g);+}+++void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v) {+  global_State *g = G(L);+  lua_assert(isblack(o) && iswhite(v) && !isdead(g, v) && !isdead(g, o));+  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);+  lua_assert(ttype(&o->gch) != LUA_TTABLE);+  /* must keep invariant? */+  if (g->gcstate == GCSpropagate)+    reallymarkobject(g, v);  /* restore invariant */+  else  /* don't mind */+    makewhite(g, o);  /* mark as white just to avoid other barriers */+}+++void luaC_barrierback (lua_State *L, Table *t) {+  global_State *g = G(L);+  GCObject *o = obj2gco(t);+  lua_assert(isblack(o) && !isdead(g, o));+  lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);+  black2gray(o);  /* make table gray (again) */+  t->gclist = g->grayagain;+  g->grayagain = o;+}+++void luaC_link (lua_State *L, GCObject *o, lu_byte tt) {+  global_State *g = G(L);+  o->gch.next = g->rootgc;+  g->rootgc = o;+  o->gch.marked = luaC_white(g);+  o->gch.tt = tt;+}+++void luaC_linkupval (lua_State *L, UpVal *uv) {+  global_State *g = G(L);+  GCObject *o = obj2gco(uv);+  o->gch.next = g->rootgc;  /* link upvalue into `rootgc' list */+  g->rootgc = o;+  if (isgray(o)) { +    if (g->gcstate == GCSpropagate) {+      gray2black(o);  /* closed upvalues need barrier */+      luaC_barrier(L, uv, uv->v);+    }+    else {  /* sweep phase: sweep it (turning it into white) */+      makewhite(g, o);+      lua_assert(g->gcstate != GCSfinalize && g->gcstate != GCSpause);+    }+  }+}+

@@ -0,0 +1,110 @@+/*+** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $+** Garbage Collector+** See Copyright Notice in lua.h+*/++#ifndef lgc_h+#define lgc_h+++#include "lobject.h"+++/*+** Possible states of the Garbage Collector+*/+#define GCSpause	0+#define GCSpropagate	1+#define GCSsweepstring	2+#define GCSsweep	3+#define GCSfinalize	4+++/*+** some userful bit tricks+*/+#define resetbits(x,m)	((x) &= cast(lu_byte, ~(m)))+#define setbits(x,m)	((x) |= (m))+#define testbits(x,m)	((x) & (m))+#define bitmask(b)	(1<<(b))+#define bit2mask(b1,b2)	(bitmask(b1) | bitmask(b2))+#define l_setbit(x,b)	setbits(x, bitmask(b))+#define resetbit(x,b)	resetbits(x, bitmask(b))+#define testbit(x,b)	testbits(x, bitmask(b))+#define set2bits(x,b1,b2)	setbits(x, (bit2mask(b1, b2)))+#define reset2bits(x,b1,b2)	resetbits(x, (bit2mask(b1, b2)))+#define test2bits(x,b1,b2)	testbits(x, (bit2mask(b1, b2)))++++/*+** Layout for bit use in `marked' field:+** bit 0 - object is white (type 0)+** bit 1 - object is white (type 1)+** bit 2 - object is black+** bit 3 - for userdata: has been finalized+** bit 3 - for tables: has weak keys+** bit 4 - for tables: has weak values+** bit 5 - object is fixed (should not be collected)+** bit 6 - object is "super" fixed (only the main thread)+*/+++#define WHITE0BIT	0+#define WHITE1BIT	1+#define BLACKBIT	2+#define FINALIZEDBIT	3+#define KEYWEAKBIT	3+#define VALUEWEAKBIT	4+#define FIXEDBIT	5+#define SFIXEDBIT	6+#define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)+++#define iswhite(x)      test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)+#define isblack(x)      testbit((x)->gch.marked, BLACKBIT)+#define isgray(x)	(!isblack(x) && !iswhite(x))++#define otherwhite(g)	(g->currentwhite ^ WHITEBITS)+#define isdead(g,v)	((v)->gch.marked & otherwhite(g) & WHITEBITS)++#define changewhite(x)	((x)->gch.marked ^= WHITEBITS)+#define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)++#define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))++#define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)+++#define luaC_checkGC(L) { \+  condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \+  if (G(L)->totalbytes >= G(L)->GCthreshold) \+	luaC_step(L); }+++#define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \+	luaC_barrierf(L,obj2gco(p),gcvalue(v)); }++#define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t)))  \+	luaC_barrierback(L,t); }++#define luaC_objbarrier(L,p,o)  \+	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \+		luaC_barrierf(L,obj2gco(p),obj2gco(o)); }++#define luaC_objbarriert(L,t,o)  \+   { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }++LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);+LUAI_FUNC void luaC_callGCTM (lua_State *L);+LUAI_FUNC void luaC_freeall (lua_State *L);+LUAI_FUNC void luaC_step (lua_State *L);+LUAI_FUNC void luaC_fullgc (lua_State *L);+LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);+LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);+LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);+LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);+++#endif

@@ -0,0 +1,38 @@+/*+** $Id: linit.c,v 1.14.1.1 2007/12/27 13:02:25 roberto Exp $+** Initialization of libraries for lua.c+** See Copyright Notice in lua.h+*/+++#define linit_c+#define LUA_LIB++#include "lua.h"++#include "lualib.h"+#include "lauxlib.h"+++static const luaL_Reg lualibs[] = {+  {"", luaopen_base},+  {LUA_LOADLIBNAME, luaopen_package},+  {LUA_TABLIBNAME, luaopen_table},+  {LUA_IOLIBNAME, luaopen_io},+  {LUA_OSLIBNAME, luaopen_os},+  {LUA_STRLIBNAME, luaopen_string},+  {LUA_MATHLIBNAME, luaopen_math},+  {LUA_DBLIBNAME, luaopen_debug},+  {NULL, NULL}+};+++LUALIB_API void luaL_openlibs (lua_State *L) {+  const luaL_Reg *lib = lualibs;+  for (; lib->func; lib++) {+    lua_pushcfunction(L, lib->func);+    lua_pushstring(L, lib->name);+    lua_call(L, 1, 0);+  }+}+

@@ -0,0 +1,556 @@+/*+** $Id: liolib.c,v 2.73.1.4 2010/05/14 15:33:51 roberto Exp $+** Standard I/O (and system) library+** See Copyright Notice in lua.h+*/+++#include <errno.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>++#define liolib_c+#define LUA_LIB++#include "lua.h"++#include "lauxlib.h"+#include "lualib.h"++++#define IO_INPUT	1+#define IO_OUTPUT	2+++static const char *const fnames[] = {"input", "output"};+++static int pushresult (lua_State *L, int i, const char *filename) {+  int en = errno;  /* calls to Lua API may change this value */+  if (i) {+    lua_pushboolean(L, 1);+    return 1;+  }+  else {+    lua_pushnil(L);+    if (filename)+      lua_pushfstring(L, "%s: %s", filename, strerror(en));+    else+      lua_pushfstring(L, "%s", strerror(en));+    lua_pushinteger(L, en);+    return 3;+  }+}+++static void fileerror (lua_State *L, int arg, const char *filename) {+  lua_pushfstring(L, "%s: %s", filename, strerror(errno));+  luaL_argerror(L, arg, lua_tostring(L, -1));+}+++#define tofilep(L)	((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))+++static int io_type (lua_State *L) {+  void *ud;+  luaL_checkany(L, 1);+  ud = lua_touserdata(L, 1);+  lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);+  if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))+    lua_pushnil(L);  /* not a file */+  else if (*((FILE **)ud) == NULL)+    lua_pushliteral(L, "closed file");+  else+    lua_pushliteral(L, "file");+  return 1;+}+++static FILE *tofile (lua_State *L) {+  FILE **f = tofilep(L);+  if (*f == NULL)+    luaL_error(L, "attempt to use a closed file");+  return *f;+}++++/*+** When creating file handles, always creates a `closed' file handle+** before opening the actual file; so, if there is a memory error, the+** file is not left opened.+*/+static FILE **newfile (lua_State *L) {+  FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));+  *pf = NULL;  /* file handle is currently `closed' */+  luaL_getmetatable(L, LUA_FILEHANDLE);+  lua_setmetatable(L, -2);+  return pf;+}+++/*+** function to (not) close the standard files stdin, stdout, and stderr+*/+static int io_noclose (lua_State *L) {+  lua_pushnil(L);+  lua_pushliteral(L, "cannot close standard file");+  return 2;+}+++/*+** function to close 'popen' files+*/+static int io_pclose (lua_State *L) {+  FILE **p = tofilep(L);+  int ok = lua_pclose(L, *p);+  *p = NULL;+  return pushresult(L, ok, NULL);+}+++/*+** function to close regular files+*/+static int io_fclose (lua_State *L) {+  FILE **p = tofilep(L);+  int ok = (fclose(*p) == 0);+  *p = NULL;+  return pushresult(L, ok, NULL);+}+++static int aux_close (lua_State *L) {+  lua_getfenv(L, 1);+  lua_getfield(L, -1, "__close");+  return (lua_tocfunction(L, -1))(L);+}+++static int io_close (lua_State *L) {+  if (lua_isnone(L, 1))+    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);+  tofile(L);  /* make sure argument is a file */+  return aux_close(L);+}+++static int io_gc (lua_State *L) {+  FILE *f = *tofilep(L);+  /* ignore closed files */+  if (f != NULL)+    aux_close(L);+  return 0;+}+++static int io_tostring (lua_State *L) {+  FILE *f = *tofilep(L);+  if (f == NULL)+    lua_pushliteral(L, "file (closed)");+  else+    lua_pushfstring(L, "file (%p)", f);+  return 1;+}+++static int io_open (lua_State *L) {+  const char *filename = luaL_checkstring(L, 1);+  const char *mode = luaL_optstring(L, 2, "r");+  FILE **pf = newfile(L);+  *pf = fopen(filename, mode);+  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;+}+++/*+** this function has a separated environment, which defines the+** correct __close for 'popen' files+*/+static int io_popen (lua_State *L) {+  const char *filename = luaL_checkstring(L, 1);+  const char *mode = luaL_optstring(L, 2, "r");+  FILE **pf = newfile(L);+  *pf = lua_popen(L, filename, mode);+  return (*pf == NULL) ? pushresult(L, 0, filename) : 1;+}+++static int io_tmpfile (lua_State *L) {+  FILE **pf = newfile(L);+  *pf = tmpfile();+  return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;+}+++static FILE *getiofile (lua_State *L, int findex) {+  FILE *f;+  lua_rawgeti(L, LUA_ENVIRONINDEX, findex);+  f = *(FILE **)lua_touserdata(L, -1);+  if (f == NULL)+    luaL_error(L, "standard %s file is closed", fnames[findex - 1]);+  return f;+}+++static int g_iofile (lua_State *L, int f, const char *mode) {+  if (!lua_isnoneornil(L, 1)) {+    const char *filename = lua_tostring(L, 1);+    if (filename) {+      FILE **pf = newfile(L);+      *pf = fopen(filename, mode);+      if (*pf == NULL)+        fileerror(L, 1, filename);+    }+    else {+      tofile(L);  /* check that it's a valid file handle */+      lua_pushvalue(L, 1);+    }+    lua_rawseti(L, LUA_ENVIRONINDEX, f);+  }+  /* return current value */+  lua_rawgeti(L, LUA_ENVIRONINDEX, f);+  return 1;+}+++static int io_input (lua_State *L) {+  return g_iofile(L, IO_INPUT, "r");+}+++static int io_output (lua_State *L) {+  return g_iofile(L, IO_OUTPUT, "w");+}+++static int io_readline (lua_State *L);+++static void aux_lines (lua_State *L, int idx, int toclose) {+  lua_pushvalue(L, idx);+  lua_pushboolean(L, toclose);  /* close/not close file when finished */+  lua_pushcclosure(L, io_readline, 2);+}+++static int f_lines (lua_State *L) {+  tofile(L);  /* check that it's a valid file handle */+  aux_lines(L, 1, 0);+  return 1;+}+++static int io_lines (lua_State *L) {+  if (lua_isnoneornil(L, 1)) {  /* no arguments? */+    /* will iterate over default input */+    lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);+    return f_lines(L);+  }+  else {+    const char *filename = luaL_checkstring(L, 1);+    FILE **pf = newfile(L);+    *pf = fopen(filename, "r");+    if (*pf == NULL)+      fileerror(L, 1, filename);+    aux_lines(L, lua_gettop(L), 1);+    return 1;+  }+}+++/*+** {======================================================+** READ+** =======================================================+*/+++static int read_number (lua_State *L, FILE *f) {+  lua_Number d;+  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {+    lua_pushnumber(L, d);+    return 1;+  }+  else {+    lua_pushnil(L);  /* "result" to be removed */+    return 0;  /* read fails */+  }+}+++static int test_eof (lua_State *L, FILE *f) {+  int c = getc(f);+  ungetc(c, f);+  lua_pushlstring(L, NULL, 0);+  return (c != EOF);+}+++static int read_line (lua_State *L, FILE *f) {+  luaL_Buffer b;+  luaL_buffinit(L, &b);+  for (;;) {+    size_t l;+    char *p = luaL_prepbuffer(&b);+    if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) {  /* eof? */+      luaL_pushresult(&b);  /* close buffer */+      return (lua_objlen(L, -1) > 0);  /* check whether read something */+    }+    l = strlen(p);+    if (l == 0 || p[l-1] != '\n')+      luaL_addsize(&b, l);+    else {+      luaL_addsize(&b, l - 1);  /* do not include `eol' */+      luaL_pushresult(&b);  /* close buffer */+      return 1;  /* read at least an `eol' */+    }+  }+}+++static int read_chars (lua_State *L, FILE *f, size_t n) {+  size_t rlen;  /* how much to read */+  size_t nr;  /* number of chars actually read */+  luaL_Buffer b;+  luaL_buffinit(L, &b);+  rlen = LUAL_BUFFERSIZE;  /* try to read that much each time */+  do {+    char *p = luaL_prepbuffer(&b);+    if (rlen > n) rlen = n;  /* cannot read more than asked */+    nr = fread(p, sizeof(char), rlen, f);+    luaL_addsize(&b, nr);+    n -= nr;  /* still have to read `n' chars */+  } while (n > 0 && nr == rlen);  /* until end of count or eof */+  luaL_pushresult(&b);  /* close buffer */+  return (n == 0 || lua_objlen(L, -1) > 0);+}+++static int g_read (lua_State *L, FILE *f, int first) {+  int nargs = lua_gettop(L) - 1;+  int success;+  int n;+  clearerr(f);+  if (nargs == 0) {  /* no arguments? */+    success = read_line(L, f);+    n = first+1;  /* to return 1 result */+  }+  else {  /* ensure stack space for all results and for auxlib's buffer */+    luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");+    success = 1;+    for (n = first; nargs-- && success; n++) {+      if (lua_type(L, n) == LUA_TNUMBER) {+        size_t l = (size_t)lua_tointeger(L, n);+        success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);+      }+      else {+        const char *p = lua_tostring(L, n);+        luaL_argcheck(L, p && p[0] == '*', n, "invalid option");+        switch (p[1]) {+          case 'n':  /* number */+            success = read_number(L, f);+            break;+          case 'l':  /* line */+            success = read_line(L, f);+            break;+          case 'a':  /* file */+            read_chars(L, f, ~((size_t)0));  /* read MAX_SIZE_T chars */+            success = 1; /* always success */+            break;+          default:+            return luaL_argerror(L, n, "invalid format");+        }+      }+    }+  }+  if (ferror(f))+    return pushresult(L, 0, NULL);+  if (!success) {+    lua_pop(L, 1);  /* remove last result */+    lua_pushnil(L);  /* push nil instead */+  }+  return n - first;+}+++static int io_read (lua_State *L) {+  return g_read(L, getiofile(L, IO_INPUT), 1);+}+++static int f_read (lua_State *L) {+  return g_read(L, tofile(L), 2);+}+++static int io_readline (lua_State *L) {+  FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));+  int sucess;+  if (f == NULL)  /* file is already closed? */+    luaL_error(L, "file is already closed");+  sucess = read_line(L, f);+  if (ferror(f))+    return luaL_error(L, "%s", strerror(errno));+  if (sucess) return 1;+  else {  /* EOF */+    if (lua_toboolean(L, lua_upvalueindex(2))) {  /* generator created file? */+      lua_settop(L, 0);+      lua_pushvalue(L, lua_upvalueindex(1));+      aux_close(L);  /* close it */+    }+    return 0;+  }+}++/* }====================================================== */+++static int g_write (lua_State *L, FILE *f, int arg) {+  int nargs = lua_gettop(L) - 1;+  int status = 1;+  for (; nargs--; arg++) {+    if (lua_type(L, arg) == LUA_TNUMBER) {+      /* optimization: could be done exactly as for strings */+      status = status &&+          fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;+    }+    else {+      size_t l;+      const char *s = luaL_checklstring(L, arg, &l);+      status = status && (fwrite(s, sizeof(char), l, f) == l);+    }+  }+  return pushresult(L, status, NULL);+}+++static int io_write (lua_State *L) {+  return g_write(L, getiofile(L, IO_OUTPUT), 1);+}+++static int f_write (lua_State *L) {+  return g_write(L, tofile(L), 2);+}+++static int f_seek (lua_State *L) {+  static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};+  static const char *const modenames[] = {"set", "cur", "end", NULL};+  FILE *f = tofile(L);+  int op = luaL_checkoption(L, 2, "cur", modenames);+  long offset = luaL_optlong(L, 3, 0);+  op = fseek(f, offset, mode[op]);+  if (op)+    return pushresult(L, 0, NULL);  /* error */+  else {+    lua_pushinteger(L, ftell(f));+    return 1;+  }+}+++static int f_setvbuf (lua_State *L) {+  static const int mode[] = {_IONBF, _IOFBF, _IOLBF};+  static const char *const modenames[] = {"no", "full", "line", NULL};+  FILE *f = tofile(L);+  int op = luaL_checkoption(L, 2, NULL, modenames);+  lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);+  int res = setvbuf(f, NULL, mode[op], sz);+  return pushresult(L, res == 0, NULL);+}++++static int io_flush (lua_State *L) {+  return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);+}+++static int f_flush (lua_State *L) {+  return pushresult(L, fflush(tofile(L)) == 0, NULL);+}+++static const luaL_Reg iolib[] = {+  {"close", io_close},+  {"flush", io_flush},+  {"input", io_input},+  {"lines", io_lines},+  {"open", io_open},+  {"output", io_output},+  {"popen", io_popen},+  {"read", io_read},+  {"tmpfile", io_tmpfile},+  {"type", io_type},+  {"write", io_write},+  {NULL, NULL}+};+++static const luaL_Reg flib[] = {+  {"close", io_close},+  {"flush", f_flush},+  {"lines", f_lines},+  {"read", f_read},+  {"seek", f_seek},+  {"setvbuf", f_setvbuf},+  {"write", f_write},+  {"__gc", io_gc},+  {"__tostring", io_tostring},+  {NULL, NULL}+};+++static void createmeta (lua_State *L) {+  luaL_newmetatable(L, LUA_FILEHANDLE);  /* create metatable for file handles */+  lua_pushvalue(L, -1);  /* push metatable */+  lua_setfield(L, -2, "__index");  /* metatable.__index = metatable */+  luaL_register(L, NULL, flib);  /* file methods */+}+++static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {+  *newfile(L) = f;+  if (k > 0) {+    lua_pushvalue(L, -1);+    lua_rawseti(L, LUA_ENVIRONINDEX, k);+  }+  lua_pushvalue(L, -2);  /* copy environment */+  lua_setfenv(L, -2);  /* set it */+  lua_setfield(L, -3, fname);+}+++static void newfenv (lua_State *L, lua_CFunction cls) {+  lua_createtable(L, 0, 1);+  lua_pushcfunction(L, cls);+  lua_setfield(L, -2, "__close");+}+++LUALIB_API int luaopen_io (lua_State *L) {+  createmeta(L);+  /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */+  newfenv(L, io_fclose);+  lua_replace(L, LUA_ENVIRONINDEX);+  /* open library */+  luaL_register(L, LUA_IOLIBNAME, iolib);+  /* create (and set) default files */+  newfenv(L, io_noclose);  /* close function for default files */+  createstdfile(L, stdin, IO_INPUT, "stdin");+  createstdfile(L, stdout, IO_OUTPUT, "stdout");+  createstdfile(L, stderr, 0, "stderr");+  lua_pop(L, 1);  /* pop environment for default files */+  lua_getfield(L, -1, "popen");+  newfenv(L, io_pclose);  /* create environment for 'popen' */+  lua_setfenv(L, -2);  /* set fenv for 'popen' */+  lua_pop(L, 1);  /* pop 'popen' */+  return 1;+}+