├── .gitignore
├── lua52-sys
    ├── .gitignore
    ├── lua
    │   ├── README
    │   ├── src
    │   │   ├── lua.hpp
    │   │   ├── lapi.h
    │   │   ├── lundump.h
    │   │   ├── lfunc.h
    │   │   ├── ldebug.h
    │   │   ├── lualib.h
    │   │   ├── ltm.h
    │   │   ├── lstring.h
    │   │   ├── ltable.h
    │   │   ├── lvm.h
    │   │   ├── ldo.h
    │   │   ├── lzio.h
    │   │   ├── lzio.c
    │   │   ├── linit.c
    │   │   ├── lmem.h
    │   │   ├── ltm.c
    │   │   ├── lctype.h
    │   │   ├── llex.h
    │   │   ├── lctype.c
    │   │   ├── lmem.c
    │   │   ├── lcode.h
    │   │   ├── lopcodes.c
    │   │   ├── lparser.h
    │   │   ├── ldump.c
    │   │   ├── lcorolib.c
    │   │   ├── lfunc.c
    │   │   ├── lbitlib.c
    │   │   ├── lstring.c
    │   │   ├── lgc.h
    │   │   ├── lundump.c
    │   │   ├── Makefile
    │   │   ├── lmathlib.c
    │   │   ├── lauxlib.h
    │   │   ├── lstate.h
    │   │   ├── llimits.h
    │   │   ├── ltablib.c
    │   │   ├── lobject.c
    │   │   ├── lstate.c
    │   │   ├── loslib.c
    │   │   ├── lopcodes.h
    │   │   └── luac.c
    │   └── Makefile
    ├── Cargo.toml
    └── build.rs
├── Cargo.toml
├── hlua
    ├── examples
    │   ├── basic.rs
    │   ├── rust_function.rs
    │   ├── repl.rs
    │   └── sound-api.rs
    ├── Cargo.toml
    ├── tests
    │   ├── ffi.rs
    │   └── userdata.rs
    └── src
    │   ├── macros.rs
    │   ├── tuples.rs
    │   └── userdata.rs
├── .gitattributes
├── LICENSE
├── .travis.yml
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | Cargo.lock
2 | doc/
3 | target/
4 | 


--------------------------------------------------------------------------------
/lua52-sys/.gitignore:
--------------------------------------------------------------------------------
1 | Cargo.lock
2 | target
3 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
1 | [workspace]
2 | members = ["hlua", "lua52-sys"]
3 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/README:
--------------------------------------------------------------------------------
1 | 
2 | This is Lua 5.2.4, released on 25 Feb 2015.
3 | 
4 | For installation instructions, license details, and
5 | further information about Lua, see doc/readme.html.
6 | 
7 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lua.hpp:
--------------------------------------------------------------------------------
 1 | // lua.hpp
 2 | // Lua header files for C++
 3 | // <<extern "C">> not supplied automatically because Lua also compiles as C++
 4 | 
 5 | extern "C" {
 6 | #include "lua.h"
 7 | #include "lualib.h"
 8 | #include "lauxlib.h"
 9 | }
10 | 


--------------------------------------------------------------------------------
/hlua/examples/basic.rs:
--------------------------------------------------------------------------------
 1 | extern crate hlua;
 2 | 
 3 | // To see the generated assembly, run:
 4 | // cargo rustc --release --example basic -- --emit=asm
 5 | 
 6 | fn main() {
 7 |     let mut lua = hlua::Lua::new();
 8 | 
 9 |     lua.set("a", 12);
10 |     let val: i32 = lua.execute(r#"return a * 5;"#).unwrap();
11 | 
12 |     assert_eq!(val, 60);
13 | }
14 | 


--------------------------------------------------------------------------------
/hlua/examples/rust_function.rs:
--------------------------------------------------------------------------------
 1 | extern crate hlua;
 2 | 
 3 | // To see the generated assembly, run:
 4 | // cargo rustc --release --example rust_function -- --emit=asm
 5 | 
 6 | fn main() {
 7 |     let mut lua = hlua::Lua::new();
 8 | 
 9 |     lua.set("foo", hlua::function1(|val: i32| val * 5));
10 | 
11 |     let val: i32 = lua.execute(r#"return foo(8)"#).unwrap();
12 |     assert_eq!(val, 40);
13 | }
14 | 


--------------------------------------------------------------------------------
/hlua/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "hlua"
 3 | version = "0.4.3"
 4 | authors = [ "pierre.krieger1708@gmail.com" ]
 5 | description = "Zero-cost high-level wrapper for Lua"
 6 | keywords = ["lua"]
 7 | repository = "https://github.com/tomaka/hlua"
 8 | documentation = "http://docs.rs/hlua"
 9 | license = "MIT"
10 | 
11 | [dependencies]
12 | libc = "0.2"
13 | lua52-sys = { version = "0.1.1", path = "../lua52-sys" }
14 | 


--------------------------------------------------------------------------------
/hlua/tests/ffi.rs:
--------------------------------------------------------------------------------
 1 | //! Test to make sure the low-level API can be accessed from hlua.
 2 | 
 3 | extern crate hlua;
 4 | 
 5 | use hlua::AsLua;
 6 | 
 7 | #[test]
 8 | fn get_version() {
 9 |     let lua = hlua::Lua::new();
10 |     let state_ptr = lua.as_lua().state_ptr();
11 | 
12 |     let version = unsafe { *hlua::ffi::lua_version(state_ptr) as i32 };
13 |     // 502 = Lua 5.2
14 |     assert_eq!(version, 502);
15 | }
16 | 


--------------------------------------------------------------------------------
/lua52-sys/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | 
 3 | name = "lua52-sys"
 4 | version = "0.1.3"
 5 | authors = ["Pierre Krieger <pierre.krieger1708@gmail.com>"]
 6 | description = "Bindings for Lua 5.2"
 7 | build = "build.rs"
 8 | links = "lua"
 9 | license = "MIT"
10 | repository = "https://github.com/tomaka/rust-hl-lua"
11 | 
12 | [build-dependencies]
13 | pkg-config = "0.3"
14 | cc = "1.0"
15 | 
16 | [dependencies]
17 | libc = "0.2"
18 | 


--------------------------------------------------------------------------------
/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Auto detect text files and perform LF normalization
 2 | * text=auto
 3 | 
 4 | # Custom for Visual Studio
 5 | *.cs     diff=csharp
 6 | *.sln    merge=union
 7 | *.csproj merge=union
 8 | *.vbproj merge=union
 9 | *.fsproj merge=union
10 | *.dbproj merge=union
11 | 
12 | # Standard to msysgit
13 | *.doc	 diff=astextplain
14 | *.DOC	 diff=astextplain
15 | *.docx diff=astextplain
16 | *.DOCX diff=astextplain
17 | *.dot  diff=astextplain
18 | *.DOT  diff=astextplain
19 | *.pdf  diff=astextplain
20 | *.PDF	 diff=astextplain
21 | *.rtf	 diff=astextplain
22 | *.RTF	 diff=astextplain
23 | 


--------------------------------------------------------------------------------
/hlua/examples/repl.rs:
--------------------------------------------------------------------------------
 1 | extern crate hlua;
 2 | 
 3 | use hlua::AnyLuaValue;
 4 | 
 5 | use std::io::prelude::*;
 6 | use std::io::{stdin, stdout};
 7 | 
 8 | fn main() {
 9 |     let mut lua = hlua::Lua::new();
10 |     lua.openlibs();
11 | 
12 |     let stdin = stdin();
13 |     loop {
14 |         print!("> ");
15 |         stdout().flush().unwrap();
16 | 
17 |         let mut line = String::new();
18 |         stdin.read_line(&mut line).unwrap();
19 | 
20 |         match lua.execute::<AnyLuaValue>(&line) {
21 |             Ok(value) => println!("{:?}", value),
22 |             Err(e) => println!("error: {:?}", e),
23 |         }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lapi.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lapi.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Auxiliary functions from Lua API
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lapi_h
 8 | #define lapi_h
 9 | 
10 | 
11 | #include "llimits.h"
12 | #include "lstate.h"
13 | 
14 | #define api_incr_top(L)   {L->top++; api_check(L, L->top <= L->ci->top, \
15 | 				"stack overflow");}
16 | 
17 | #define adjustresults(L,nres) \
18 |     { if ((nres) == LUA_MULTRET && L->ci->top < L->top) L->ci->top = L->top; }
19 | 
20 | #define api_checknelems(L,n)	api_check(L, (n) < (L->top - L->ci->func), \
21 | 				  "not enough elements in the stack")
22 | 
23 | 
24 | #endif
25 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lundump.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lundump.h,v 1.39.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** load precompiled Lua chunks
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lundump_h
 8 | #define lundump_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | /* load one chunk; from lundump.c */
14 | LUAI_FUNC Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name);
15 | 
16 | /* make header; from lundump.c */
17 | LUAI_FUNC void luaU_header (lu_byte* h);
18 | 
19 | /* dump one chunk; from ldump.c */
20 | LUAI_FUNC int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip);
21 | 
22 | /* data to catch conversion errors */
23 | #define LUAC_TAIL		"\x19\x93\r\n\x1a\n"
24 | 
25 | /* size in bytes of header of binary files */
26 | #define LUAC_HEADERSIZE		(sizeof(LUA_SIGNATURE)-sizeof(char)+2+6+sizeof(LUAC_TAIL)-sizeof(char))
27 | 
28 | #endif
29 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Pierre Krieger
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy
 4 | of this software and associated documentation files (the "Software"), to deal
 5 | in the Software without restriction, including without limitation the rights
 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 7 | copies of the Software, and to permit persons to whom the Software is
 8 | furnished to do so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lfunc.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lfunc.h,v 2.8.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Auxiliary functions to manipulate prototypes and closures
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lfunc_h
 8 | #define lfunc_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | #define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
15 |                          cast(int, sizeof(TValue)*((n)-1)))
16 | 
17 | #define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
18 |                          cast(int, sizeof(TValue *)*((n)-1)))
19 | 
20 | 
21 | LUAI_FUNC Proto *luaF_newproto (lua_State *L);
22 | LUAI_FUNC Closure *luaF_newCclosure (lua_State *L, int nelems);
23 | LUAI_FUNC Closure *luaF_newLclosure (lua_State *L, int nelems);
24 | LUAI_FUNC UpVal *luaF_newupval (lua_State *L);
25 | LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
26 | LUAI_FUNC void luaF_close (lua_State *L, StkId level);
27 | LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
28 | LUAI_FUNC void luaF_freeupval (lua_State *L, UpVal *uv);
29 | LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
30 |                                          int pc);
31 | 
32 | 
33 | #endif
34 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ldebug.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldebug.h,v 2.7.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Auxiliary functions from Debug Interface module
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldebug_h
 8 | #define ldebug_h
 9 | 
10 | 
11 | #include "lstate.h"
12 | 
13 | 
14 | #define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
15 | 
16 | #define getfuncline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : 0)
17 | 
18 | #define resethookcount(L)	(L->hookcount = L->basehookcount)
19 | 
20 | /* Active Lua function (given call info) */
21 | #define ci_func(ci)		(clLvalue((ci)->func))
22 | 
23 | 
24 | LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
25 |                                                 const char *opname);
26 | LUAI_FUNC l_noret luaG_concaterror (lua_State *L, StkId p1, StkId p2);
27 | LUAI_FUNC l_noret luaG_aritherror (lua_State *L, const TValue *p1,
28 |                                                  const TValue *p2);
29 | LUAI_FUNC l_noret luaG_ordererror (lua_State *L, const TValue *p1,
30 |                                                  const TValue *p2);
31 | LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
32 | LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
33 | 
34 | #endif
35 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: rust
 2 | 
 3 | rust:
 4 |  - stable
 5 |  - beta
 6 |  - nightly
 7 | 
 8 | env:
 9 |   global:
10 |     - secure: "BzoIUhSxk27LcMIKXcwXlMPs3RrO1J/XileGsWceU1FP4CyXbigmFdEu1Wcm7doEhPsGFvd5ogUc/yTyPhExpmy7aymkwlA5aaKqhOif/u1aHEhcE0oofPoyFNpkm0GR+U+3ExvMmYzJYVddwIXuIADUcV/Dusv4ZQB2Z/ZMtyU="
11 |     - secure: "zsXkul12GoVz/SGbhZHlP9vQXzfWi0nhPkJSmuoCbmVgvCvfL+xURdI0XUwc3oZbRy9EO+Q6bJFtogOnc5edTRdXNVONweLLhM7fpbNV3YcDcgHC3WBZtupkjXszQ0oRA/3pzGPo2tRxzmuGJkbi1zRJRLHFDljv25Bf4lCHyuY="
12 | 
13 | script:
14 |   - cargo test --manifest-path lua52-sys/Cargo.toml
15 |   - cargo test --manifest-path hlua/Cargo.toml
16 | 
17 | after_success:
18 |   - |
19 |       [ $TRAVIS_BRANCH = master ] &&
20 |       [ $TRAVIS_PULL_REQUEST = false ] &&
21 |       cargo doc --manifest-path hlua/Cargo.toml &&
22 |       sudo pip install ghp-import &&
23 |       ghp-import hlua/target/doc &&
24 |       git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages
25 |   - |
26 |       [ $TRAVIS_BRANCH = master ] &&
27 |       [ $TRAVIS_PULL_REQUEST = false ] &&
28 |       cargo publish --manifest-path lua52-sys/Cargo.toml --token ${CRATESIO_TOKEN}
29 |   - |
30 |       [ $TRAVIS_BRANCH = master ] &&
31 |       [ $TRAVIS_PULL_REQUEST = false ] &&
32 |       cargo publish --manifest-path hlua/Cargo.toml --token ${CRATESIO_TOKEN}
33 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lualib.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lualib.h,v 1.43.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Lua standard libraries
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lualib_h
 9 | #define lualib_h
10 | 
11 | #include "lua.h"
12 | 
13 | 
14 | 
15 | LUAMOD_API int (luaopen_base) (lua_State *L);
16 | 
17 | #define LUA_COLIBNAME	"coroutine"
18 | LUAMOD_API int (luaopen_coroutine) (lua_State *L);
19 | 
20 | #define LUA_TABLIBNAME	"table"
21 | LUAMOD_API int (luaopen_table) (lua_State *L);
22 | 
23 | #define LUA_IOLIBNAME	"io"
24 | LUAMOD_API int (luaopen_io) (lua_State *L);
25 | 
26 | #define LUA_OSLIBNAME	"os"
27 | LUAMOD_API int (luaopen_os) (lua_State *L);
28 | 
29 | #define LUA_STRLIBNAME	"string"
30 | LUAMOD_API int (luaopen_string) (lua_State *L);
31 | 
32 | #define LUA_BITLIBNAME	"bit32"
33 | LUAMOD_API int (luaopen_bit32) (lua_State *L);
34 | 
35 | #define LUA_MATHLIBNAME	"math"
36 | LUAMOD_API int (luaopen_math) (lua_State *L);
37 | 
38 | #define LUA_DBLIBNAME	"debug"
39 | LUAMOD_API int (luaopen_debug) (lua_State *L);
40 | 
41 | #define LUA_LOADLIBNAME	"package"
42 | LUAMOD_API int (luaopen_package) (lua_State *L);
43 | 
44 | 
45 | /* open all previous libraries */
46 | LUALIB_API void (luaL_openlibs) (lua_State *L);
47 | 
48 | 
49 | 
50 | #if !defined(lua_assert)
51 | #define lua_assert(x)	((void)0)
52 | #endif
53 | 
54 | 
55 | #endif
56 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ltm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.h,v 2.11.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltm_h
 8 | #define ltm_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | 
13 | 
14 | /*
15 | * WARNING: if you change the order of this enumeration,
16 | * grep "ORDER TM"
17 | */
18 | typedef enum {
19 |   TM_INDEX,
20 |   TM_NEWINDEX,
21 |   TM_GC,
22 |   TM_MODE,
23 |   TM_LEN,
24 |   TM_EQ,  /* last tag method with `fast' access */
25 |   TM_ADD,
26 |   TM_SUB,
27 |   TM_MUL,
28 |   TM_DIV,
29 |   TM_MOD,
30 |   TM_POW,
31 |   TM_UNM,
32 |   TM_LT,
33 |   TM_LE,
34 |   TM_CONCAT,
35 |   TM_CALL,
36 |   TM_N		/* number of elements in the enum */
37 | } TMS;
38 | 
39 | 
40 | 
41 | #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
42 |   ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
43 | 
44 | #define fasttm(l,et,e)	gfasttm(G(l), et, e)
45 | 
46 | #define ttypename(x)	luaT_typenames_[(x) + 1]
47 | #define objtypename(x)	ttypename(ttypenv(x))
48 | 
49 | LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
50 | 
51 | 
52 | LUAI_FUNC const TValue *luaT_gettm (Table *events, TMS event, TString *ename);
53 | LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
54 |                                                        TMS event);
55 | LUAI_FUNC void luaT_init (lua_State *L);
56 | 
57 | #endif
58 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lstring.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lstring.h,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** String table (keep all strings handled by Lua)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lstring_h
 8 | #define lstring_h
 9 | 
10 | #include "lgc.h"
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | 
14 | 
15 | #define sizestring(s)	(sizeof(union TString)+((s)->len+1)*sizeof(char))
16 | 
17 | #define sizeudata(u)	(sizeof(union Udata)+(u)->len)
18 | 
19 | #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
20 |                                  (sizeof(s)/sizeof(char))-1))
21 | 
22 | #define luaS_fix(s)	l_setbit((s)->tsv.marked, FIXEDBIT)
23 | 
24 | 
25 | /*
26 | ** test whether a string is a reserved word
27 | */
28 | #define isreserved(s)	((s)->tsv.tt == LUA_TSHRSTR && (s)->tsv.extra > 0)
29 | 
30 | 
31 | /*
32 | ** equality for short strings, which are always internalized
33 | */
34 | #define eqshrstr(a,b)	check_exp((a)->tsv.tt == LUA_TSHRSTR, (a) == (b))
35 | 
36 | 
37 | LUAI_FUNC unsigned int luaS_hash (const char *str, size_t l, unsigned int seed);
38 | LUAI_FUNC int luaS_eqlngstr (TString *a, TString *b);
39 | LUAI_FUNC int luaS_eqstr (TString *a, TString *b);
40 | LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
41 | LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, Table *e);
42 | LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
43 | LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
44 | 
45 | 
46 | #endif
47 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ltable.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltable.h,v 2.16.1.2 2013/08/30 15:49:41 roberto Exp $
 3 | ** Lua tables (hash)
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ltable_h
 8 | #define ltable_h
 9 | 
10 | #include "lobject.h"
11 | 
12 | 
13 | #define gnode(t,i)	(&(t)->node[i])
14 | #define gkey(n)		(&(n)->i_key.tvk)
15 | #define gval(n)		(&(n)->i_val)
16 | #define gnext(n)	((n)->i_key.nk.next)
17 | 
18 | #define invalidateTMcache(t)	((t)->flags = 0)
19 | 
20 | /* returns the key, given the value of a table entry */
21 | #define keyfromval(v) \
22 |   (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
23 | 
24 | 
25 | LUAI_FUNC const TValue *luaH_getint (Table *t, int key);
26 | LUAI_FUNC void luaH_setint (lua_State *L, Table *t, int key, TValue *value);
27 | LUAI_FUNC const TValue *luaH_getstr (Table *t, TString *key);
28 | LUAI_FUNC const TValue *luaH_get (Table *t, const TValue *key);
29 | LUAI_FUNC TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key);
30 | LUAI_FUNC TValue *luaH_set (lua_State *L, Table *t, const TValue *key);
31 | LUAI_FUNC Table *luaH_new (lua_State *L);
32 | LUAI_FUNC void luaH_resize (lua_State *L, Table *t, int nasize, int nhsize);
33 | LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, int nasize);
34 | LUAI_FUNC void luaH_free (lua_State *L, Table *t);
35 | LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
36 | LUAI_FUNC int luaH_getn (Table *t);
37 | 
38 | 
39 | #if defined(LUA_DEBUG)
40 | LUAI_FUNC Node *luaH_mainposition (const Table *t, const TValue *key);
41 | LUAI_FUNC int luaH_isdummy (Node *n);
42 | #endif
43 | 
44 | 
45 | #endif
46 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lvm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lvm.h,v 2.18.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Lua virtual machine
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lvm_h
 8 | #define lvm_h
 9 | 
10 | 
11 | #include "ldo.h"
12 | #include "lobject.h"
13 | #include "ltm.h"
14 | 
15 | 
16 | #define tostring(L,o) (ttisstring(o) || (luaV_tostring(L, o)))
17 | 
18 | #define tonumber(o,n)	(ttisnumber(o) || (((o) = luaV_tonumber(o,n)) != NULL))
19 | 
20 | #define equalobj(L,o1,o2)  (ttisequal(o1, o2) && luaV_equalobj_(L, o1, o2))
21 | 
22 | #define luaV_rawequalobj(o1,o2)		equalobj(NULL,o1,o2)
23 | 
24 | 
25 | /* not to called directly */
26 | LUAI_FUNC int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2);
27 | 
28 | 
29 | LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
30 | LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
31 | LUAI_FUNC const TValue *luaV_tonumber (const TValue *obj, TValue *n);
32 | LUAI_FUNC int luaV_tostring (lua_State *L, StkId obj);
33 | LUAI_FUNC void luaV_gettable (lua_State *L, const TValue *t, TValue *key,
34 |                                             StkId val);
35 | LUAI_FUNC void luaV_settable (lua_State *L, const TValue *t, TValue *key,
36 |                                             StkId val);
37 | LUAI_FUNC void luaV_finishOp (lua_State *L);
38 | LUAI_FUNC void luaV_execute (lua_State *L);
39 | LUAI_FUNC void luaV_concat (lua_State *L, int total);
40 | LUAI_FUNC void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
41 |                            const TValue *rc, TMS op);
42 | LUAI_FUNC void luaV_objlen (lua_State *L, StkId ra, const TValue *rb);
43 | 
44 | #endif
45 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ldo.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ldo.h,v 2.20.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Stack and Call structure of Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef ldo_h
 8 | #define ldo_h
 9 | 
10 | 
11 | #include "lobject.h"
12 | #include "lstate.h"
13 | #include "lzio.h"
14 | 
15 | 
16 | #define luaD_checkstack(L,n)	if (L->stack_last - L->top <= (n)) \
17 | 				    luaD_growstack(L, n); else condmovestack(L);
18 | 
19 | 
20 | #define incr_top(L) {L->top++; luaD_checkstack(L,0);}
21 | 
22 | #define savestack(L,p)		((char *)(p) - (char *)L->stack)
23 | #define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
24 | 
25 | 
26 | /* type of protected functions, to be ran by `runprotected' */
27 | typedef void (*Pfunc) (lua_State *L, void *ud);
28 | 
29 | LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
30 |                                                   const char *mode);
31 | LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
32 | LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
33 | LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults,
34 |                                         int allowyield);
35 | LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
36 |                                         ptrdiff_t oldtop, ptrdiff_t ef);
37 | LUAI_FUNC int luaD_poscall (lua_State *L, StkId firstResult);
38 | LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
39 | LUAI_FUNC void luaD_growstack (lua_State *L, int n);
40 | LUAI_FUNC void luaD_shrinkstack (lua_State *L);
41 | 
42 | LUAI_FUNC l_noret luaD_throw (lua_State *L, int errcode);
43 | LUAI_FUNC int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud);
44 | 
45 | #endif
46 | 
47 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lzio.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.h,v 1.26.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #ifndef lzio_h
 9 | #define lzio_h
10 | 
11 | #include "lua.h"
12 | 
13 | #include "lmem.h"
14 | 
15 | 
16 | #define EOZ	(-1)			/* end of stream */
17 | 
18 | typedef struct Zio ZIO;
19 | 
20 | #define zgetc(z)  (((z)->n--)>0 ?  cast_uchar(*(z)->p++) : luaZ_fill(z))
21 | 
22 | 
23 | typedef struct Mbuffer {
24 |   char *buffer;
25 |   size_t n;
26 |   size_t buffsize;
27 | } Mbuffer;
28 | 
29 | #define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0)
30 | 
31 | #define luaZ_buffer(buff)	((buff)->buffer)
32 | #define luaZ_sizebuffer(buff)	((buff)->buffsize)
33 | #define luaZ_bufflen(buff)	((buff)->n)
34 | 
35 | #define luaZ_resetbuffer(buff) ((buff)->n = 0)
36 | 
37 | 
38 | #define luaZ_resizebuffer(L, buff, size) \
39 | 	(luaM_reallocvector(L, (buff)->buffer, (buff)->buffsize, size, char), \
40 | 	(buff)->buffsize = size)
41 | 
42 | #define luaZ_freebuffer(L, buff)	luaZ_resizebuffer(L, buff, 0)
43 | 
44 | 
45 | LUAI_FUNC char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n);
46 | LUAI_FUNC void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader,
47 |                                         void *data);
48 | LUAI_FUNC size_t luaZ_read (ZIO* z, void* b, size_t n);	/* read next n bytes */
49 | 
50 | 
51 | 
52 | /* --------- Private Part ------------------ */
53 | 
54 | struct Zio {
55 |   size_t n;			/* bytes still unread */
56 |   const char *p;		/* current position in buffer */
57 |   lua_Reader reader;		/* reader function */
58 |   void* data;			/* additional data */
59 |   lua_State *L;			/* Lua state (for reader) */
60 | };
61 | 
62 | 
63 | LUAI_FUNC int luaZ_fill (ZIO *z);
64 | 
65 | #endif
66 | 


--------------------------------------------------------------------------------
/lua52-sys/build.rs:
--------------------------------------------------------------------------------
 1 | extern crate cc;
 2 | extern crate pkg_config;
 3 | 
 4 | use std::env;
 5 | 
 6 | fn main() {
 7 |     match pkg_config::find_library("lua5.2") {
 8 |         Ok(_) => return,
 9 |         Err(..) => {}
10 |     };
11 | 
12 |     let mut build = cc::Build::new();
13 | 
14 |     if env::var("CARGO_CFG_TARGET_OS") == Ok("linux".to_string()) {
15 |         // Enable `io.popen` support
16 |         build.define("LUA_USE_LINUX", None);
17 |     }
18 | 
19 |     build
20 |         .file("lua/src/lapi.c")
21 |         .file("lua/src/lcode.c")
22 |         .file("lua/src/lctype.c")
23 |         .file("lua/src/ldebug.c")
24 |         .file("lua/src/ldo.c")
25 |         .file("lua/src/ldump.c")
26 |         .file("lua/src/lfunc.c")
27 |         .file("lua/src/lgc.c")
28 |         .file("lua/src/llex.c")
29 |         .file("lua/src/lmem.c")
30 |         .file("lua/src/lobject.c")
31 |         .file("lua/src/lopcodes.c")
32 |         .file("lua/src/lparser.c")
33 |         .file("lua/src/lstate.c")
34 |         .file("lua/src/lstring.c")
35 |         .file("lua/src/ltable.c")
36 |         .file("lua/src/ltm.c")
37 |         .file("lua/src/lundump.c")
38 |         .file("lua/src/lvm.c")
39 |         .file("lua/src/lzio.c")
40 |         .file("lua/src/lauxlib.c")
41 |         .file("lua/src/lbaselib.c")
42 |         .file("lua/src/lbitlib.c")
43 |         .file("lua/src/lcorolib.c")
44 |         .file("lua/src/ldblib.c")
45 |         .file("lua/src/liolib.c")
46 |         .file("lua/src/lmathlib.c")
47 |         .file("lua/src/loslib.c")
48 |         .file("lua/src/lstrlib.c")
49 |         .file("lua/src/ltablib.c")
50 |         .file("lua/src/loadlib.c")
51 |         .file("lua/src/linit.c")
52 |         .define("LUA_COMPAT_ALL", None)
53 |         .include("lua/src")
54 |         .compile("liblua.a");
55 | }
56 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lzio.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lzio.c,v 1.35.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Buffered streams
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 9 | 
10 | #define lzio_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "llimits.h"
16 | #include "lmem.h"
17 | #include "lstate.h"
18 | #include "lzio.h"
19 | 
20 | 
21 | int luaZ_fill (ZIO *z) {
22 |   size_t size;
23 |   lua_State *L = z->L;
24 |   const char *buff;
25 |   lua_unlock(L);
26 |   buff = z->reader(L, z->data, &size);
27 |   lua_lock(L);
28 |   if (buff == NULL || size == 0)
29 |     return EOZ;
30 |   z->n = size - 1;  /* discount char being returned */
31 |   z->p = buff;
32 |   return cast_uchar(*(z->p++));
33 | }
34 | 
35 | 
36 | void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) {
37 |   z->L = L;
38 |   z->reader = reader;
39 |   z->data = data;
40 |   z->n = 0;
41 |   z->p = NULL;
42 | }
43 | 
44 | 
45 | /* --------------------------------------------------------------- read --- */
46 | size_t luaZ_read (ZIO *z, void *b, size_t n) {
47 |   while (n) {
48 |     size_t m;
49 |     if (z->n == 0) {  /* no bytes in buffer? */
50 |       if (luaZ_fill(z) == EOZ)  /* try to read more */
51 |         return n;  /* no more input; return number of missing bytes */
52 |       else {
53 |         z->n++;  /* luaZ_fill consumed first byte; put it back */
54 |         z->p--;
55 |       }
56 |     }
57 |     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
58 |     memcpy(b, z->p, m);
59 |     z->n -= m;
60 |     z->p += m;
61 |     b = (char *)b + m;
62 |     n -= m;
63 |   }
64 |   return 0;
65 | }
66 | 
67 | /* ------------------------------------------------------------------------ */
68 | char *luaZ_openspace (lua_State *L, Mbuffer *buff, size_t n) {
69 |   if (n > buff->buffsize) {
70 |     if (n < LUA_MINBUFFER) n = LUA_MINBUFFER;
71 |     luaZ_resizebuffer(L, buff, n);
72 |   }
73 |   return buff->buffer;
74 | }
75 | 
76 | 
77 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/linit.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: linit.c,v 1.32.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Initialization of libraries for lua.c and other clients
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | /*
 9 | ** If you embed Lua in your program and need to open the standard
10 | ** libraries, call luaL_openlibs in your program. If you need a
11 | ** different set of libraries, copy this file to your project and edit
12 | ** it to suit your needs.
13 | */
14 | 
15 | 
16 | #define linit_c
17 | #define LUA_LIB
18 | 
19 | #include "lua.h"
20 | 
21 | #include "lualib.h"
22 | #include "lauxlib.h"
23 | 
24 | 
25 | /*
26 | ** these libs are loaded by lua.c and are readily available to any Lua
27 | ** program
28 | */
29 | static const luaL_Reg loadedlibs[] = {
30 |   {"_G", luaopen_base},
31 |   {LUA_LOADLIBNAME, luaopen_package},
32 |   {LUA_COLIBNAME, luaopen_coroutine},
33 |   {LUA_TABLIBNAME, luaopen_table},
34 |   {LUA_IOLIBNAME, luaopen_io},
35 |   {LUA_OSLIBNAME, luaopen_os},
36 |   {LUA_STRLIBNAME, luaopen_string},
37 |   {LUA_BITLIBNAME, luaopen_bit32},
38 |   {LUA_MATHLIBNAME, luaopen_math},
39 |   {LUA_DBLIBNAME, luaopen_debug},
40 |   {NULL, NULL}
41 | };
42 | 
43 | 
44 | /*
45 | ** these libs are preloaded and must be required before used
46 | */
47 | static const luaL_Reg preloadedlibs[] = {
48 |   {NULL, NULL}
49 | };
50 | 
51 | 
52 | LUALIB_API void luaL_openlibs (lua_State *L) {
53 |   const luaL_Reg *lib;
54 |   /* call open functions from 'loadedlibs' and set results to global table */
55 |   for (lib = loadedlibs; lib->func; lib++) {
56 |     luaL_requiref(L, lib->name, lib->func, 1);
57 |     lua_pop(L, 1);  /* remove lib */
58 |   }
59 |   /* add open functions from 'preloadedlibs' into 'package.preload' table */
60 |   luaL_getsubtable(L, LUA_REGISTRYINDEX, "_PRELOAD");
61 |   for (lib = preloadedlibs; lib->func; lib++) {
62 |     lua_pushcfunction(L, lib->func);
63 |     lua_setfield(L, -2, lib->name);
64 |   }
65 |   lua_pop(L, 1);  /* remove _PRELOAD table */
66 | }
67 | 
68 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lmem.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lmem.h,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Interface to Memory Manager
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lmem_h
 8 | #define lmem_h
 9 | 
10 | 
11 | #include <stddef.h>
12 | 
13 | #include "llimits.h"
14 | #include "lua.h"
15 | 
16 | 
17 | /*
18 | ** This macro avoids the runtime division MAX_SIZET/(e), as 'e' is
19 | ** always constant.
20 | ** The macro is somewhat complex to avoid warnings:
21 | ** +1 avoids warnings of "comparison has constant result";
22 | ** cast to 'void' avoids warnings of "value unused".
23 | */
24 | #define luaM_reallocv(L,b,on,n,e) \
25 |   (cast(void, \
26 |      (cast(size_t, (n)+1) > MAX_SIZET/(e)) ? (luaM_toobig(L), 0) : 0), \
27 |    luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
28 | 
29 | #define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
30 | #define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
31 | #define luaM_freearray(L, b, n)   luaM_reallocv(L, (b), n, 0, sizeof((b)[0]))
32 | 
33 | #define luaM_malloc(L,s)	luaM_realloc_(L, NULL, 0, (s))
34 | #define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
35 | #define luaM_newvector(L,n,t) \
36 | 		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
37 | 
38 | #define luaM_newobject(L,tag,s)	luaM_realloc_(L, NULL, tag, (s))
39 | 
40 | #define luaM_growvector(L,v,nelems,size,t,limit,e) \
41 |           if ((nelems)+1 > (size)) \
42 |             ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
43 | 
44 | #define luaM_reallocvector(L, v,oldn,n,t) \
45 |    ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
46 | 
47 | LUAI_FUNC l_noret luaM_toobig (lua_State *L);
48 | 
49 | /* not to be called directly */
50 | LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
51 |                                                           size_t size);
52 | LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
53 |                                size_t size_elem, int limit,
54 |                                const char *what);
55 | 
56 | #endif
57 | 
58 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ltm.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: ltm.c,v 2.14.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Tag methods
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | 
 8 | #include <string.h>
 9 | 
10 | #define ltm_c
11 | #define LUA_CORE
12 | 
13 | #include "lua.h"
14 | 
15 | #include "lobject.h"
16 | #include "lstate.h"
17 | #include "lstring.h"
18 | #include "ltable.h"
19 | #include "ltm.h"
20 | 
21 | 
22 | static const char udatatypename[] = "userdata";
23 | 
24 | LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
25 |   "no value",
26 |   "nil", "boolean", udatatypename, "number",
27 |   "string", "table", "function", udatatypename, "thread",
28 |   "proto", "upval"  /* these last two cases are used for tests only */
29 | };
30 | 
31 | 
32 | void luaT_init (lua_State *L) {
33 |   static const char *const luaT_eventname[] = {  /* ORDER TM */
34 |     "__index", "__newindex",
35 |     "__gc", "__mode", "__len", "__eq",
36 |     "__add", "__sub", "__mul", "__div", "__mod",
37 |     "__pow", "__unm", "__lt", "__le",
38 |     "__concat", "__call"
39 |   };
40 |   int i;
41 |   for (i=0; i<TM_N; i++) {
42 |     G(L)->tmname[i] = luaS_new(L, luaT_eventname[i]);
43 |     luaS_fix(G(L)->tmname[i]);  /* never collect these names */
44 |   }
45 | }
46 | 
47 | 
48 | /*
49 | ** function to be used with macro "fasttm": optimized for absence of
50 | ** tag methods
51 | */
52 | const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
53 |   const TValue *tm = luaH_getstr(events, ename);
54 |   lua_assert(event <= TM_EQ);
55 |   if (ttisnil(tm)) {  /* no tag method? */
56 |     events->flags |= cast_byte(1u<<event);  /* cache this fact */
57 |     return NULL;
58 |   }
59 |   else return tm;
60 | }
61 | 
62 | 
63 | const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
64 |   Table *mt;
65 |   switch (ttypenv(o)) {
66 |     case LUA_TTABLE:
67 |       mt = hvalue(o)->metatable;
68 |       break;
69 |     case LUA_TUSERDATA:
70 |       mt = uvalue(o)->metatable;
71 |       break;
72 |     default:
73 |       mt = G(L)->mt[ttypenv(o)];
74 |   }
75 |   return (mt ? luaH_getstr(mt, G(L)->tmname[event]) : luaO_nilobject);
76 | }
77 | 
78 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lctype.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** 'ctype' functions for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lctype_h
 8 | #define lctype_h
 9 | 
10 | #include "lua.h"
11 | 
12 | 
13 | /*
14 | ** WARNING: the functions defined here do not necessarily correspond
15 | ** to the similar functions in the standard C ctype.h. They are
16 | ** optimized for the specific needs of Lua
17 | */
18 | 
19 | #if !defined(LUA_USE_CTYPE)
20 | 
21 | #if 'A' == 65 && '0' == 48
22 | /* ASCII case: can use its own tables; faster and fixed */
23 | #define LUA_USE_CTYPE	0
24 | #else
25 | /* must use standard C ctype */
26 | #define LUA_USE_CTYPE	1
27 | #endif
28 | 
29 | #endif
30 | 
31 | 
32 | #if !LUA_USE_CTYPE	/* { */
33 | 
34 | #include <limits.h>
35 | 
36 | #include "llimits.h"
37 | 
38 | 
39 | #define ALPHABIT	0
40 | #define DIGITBIT	1
41 | #define PRINTBIT	2
42 | #define SPACEBIT	3
43 | #define XDIGITBIT	4
44 | 
45 | 
46 | #define MASK(B)		(1 << (B))
47 | 
48 | 
49 | /*
50 | ** add 1 to char to allow index -1 (EOZ)
51 | */
52 | #define testprop(c,p)	(luai_ctype_[(c)+1] & (p))
53 | 
54 | /*
55 | ** 'lalpha' (Lua alphabetic) and 'lalnum' (Lua alphanumeric) both include '_'
56 | */
57 | #define lislalpha(c)	testprop(c, MASK(ALPHABIT))
58 | #define lislalnum(c)	testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT)))
59 | #define lisdigit(c)	testprop(c, MASK(DIGITBIT))
60 | #define lisspace(c)	testprop(c, MASK(SPACEBIT))
61 | #define lisprint(c)	testprop(c, MASK(PRINTBIT))
62 | #define lisxdigit(c)	testprop(c, MASK(XDIGITBIT))
63 | 
64 | /*
65 | ** this 'ltolower' only works for alphabetic characters
66 | */
67 | #define ltolower(c)	((c) | ('A' ^ 'a'))
68 | 
69 | 
70 | /* two more entries for 0 and -1 (EOZ) */
71 | LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
72 | 
73 | 
74 | #else			/* }{ */
75 | 
76 | /*
77 | ** use standard C ctypes
78 | */
79 | 
80 | #include <ctype.h>
81 | 
82 | 
83 | #define lislalpha(c)	(isalpha(c) || (c) == '_')
84 | #define lislalnum(c)	(isalnum(c) || (c) == '_')
85 | #define lisdigit(c)	(isdigit(c))
86 | #define lisspace(c)	(isspace(c))
87 | #define lisprint(c)	(isprint(c))
88 | #define lisxdigit(c)	(isxdigit(c))
89 | 
90 | #define ltolower(c)	(tolower(c))
91 | 
92 | #endif			/* } */
93 | 
94 | #endif
95 | 
96 | 


--------------------------------------------------------------------------------
/hlua/examples/sound-api.rs:
--------------------------------------------------------------------------------
 1 | #[macro_use]
 2 | extern crate hlua;
 3 | 
 4 | fn main() {
 5 |     let mut lua = hlua::Lua::new();
 6 |     lua.openlibs();
 7 | 
 8 |     // we create a fill an array named `Sound` which will be used as a class-like interface
 9 |     {
10 |         let mut sound_namespace = lua.empty_array("Sound");
11 | 
12 |         // creating the `Sound.new` function
13 |         sound_namespace.set("new", hlua::function0(|| Sound::new()));
14 |     }
15 | 
16 |     lua.execute::<()>(
17 |         r#"
18 |         s = Sound.new();
19 |         s:play();
20 | 
21 |         print("hello world from within lua!");
22 |         print("is the sound playing:", s:is_playing());
23 | 
24 |         s:stop();
25 |         print("is the sound playing:", s:is_playing());
26 | 
27 |     "#,
28 |     )
29 |     .unwrap();
30 | }
31 | 
32 | // this `Sound` struct is the object that we will use to demonstrate hlua
33 | struct Sound {
34 |     playing: bool,
35 | }
36 | 
37 | // this macro implements the required trait so that we can *push* the object to lua
38 | // (ie. move it inside lua)
39 | implement_lua_push!(Sound, |mut metatable| {
40 |     // we create a `__index` entry in the metatable
41 |     // when the lua code calls `sound:play()`, it will look for `play` in there
42 |     let mut index = metatable.empty_array("__index");
43 | 
44 |     index.set("play", hlua::function1(|snd: &mut Sound| snd.play()));
45 | 
46 |     index.set("stop", hlua::function1(|snd: &mut Sound| snd.stop()));
47 | 
48 |     index.set(
49 |         "is_playing",
50 |         hlua::function1(|snd: &Sound| snd.is_playing()),
51 |     );
52 | });
53 | 
54 | // this macro implements the require traits so that we can *read* the object back
55 | implement_lua_read!(Sound);
56 | 
57 | impl Sound {
58 |     pub fn new() -> Sound {
59 |         Sound { playing: false }
60 |     }
61 | 
62 |     pub fn play(&mut self) {
63 |         println!("playing");
64 |         self.playing = true;
65 |     }
66 | 
67 |     pub fn stop(&mut self) {
68 |         println!("stopping");
69 |         self.playing = false;
70 |     }
71 | 
72 |     pub fn is_playing(&self) -> bool {
73 |         self.playing
74 |     }
75 | }
76 | 
77 | // this destructor is here to show you that objects are properly getting destroyed
78 | impl Drop for Sound {
79 |     fn drop(&mut self) {
80 |         println!("`Sound` object destroyed");
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/llex.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: llex.h,v 1.72.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Lexical Analyzer
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef llex_h
 8 | #define llex_h
 9 | 
10 | #include "lobject.h"
11 | #include "lzio.h"
12 | 
13 | 
14 | #define FIRST_RESERVED	257
15 | 
16 | 
17 | 
18 | /*
19 | * WARNING: if you change the order of this enumeration,
20 | * grep "ORDER RESERVED"
21 | */
22 | enum RESERVED {
23 |   /* terminal symbols denoted by reserved words */
24 |   TK_AND = FIRST_RESERVED, TK_BREAK,
25 |   TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FALSE, TK_FOR, TK_FUNCTION,
26 |   TK_GOTO, TK_IF, TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT,
27 |   TK_RETURN, TK_THEN, TK_TRUE, TK_UNTIL, TK_WHILE,
28 |   /* other terminal symbols */
29 |   TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_DBCOLON, TK_EOS,
30 |   TK_NUMBER, TK_NAME, TK_STRING
31 | };
32 | 
33 | /* number of reserved words */
34 | #define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
35 | 
36 | 
37 | typedef union {
38 |   lua_Number r;
39 |   TString *ts;
40 | } SemInfo;  /* semantics information */
41 | 
42 | 
43 | typedef struct Token {
44 |   int token;
45 |   SemInfo seminfo;
46 | } Token;
47 | 
48 | 
49 | /* state of the lexer plus state of the parser when shared by all
50 |    functions */
51 | typedef struct LexState {
52 |   int current;  /* current character (charint) */
53 |   int linenumber;  /* input line counter */
54 |   int lastline;  /* line of last token `consumed' */
55 |   Token t;  /* current token */
56 |   Token lookahead;  /* look ahead token */
57 |   struct FuncState *fs;  /* current function (parser) */
58 |   struct lua_State *L;
59 |   ZIO *z;  /* input stream */
60 |   Mbuffer *buff;  /* buffer for tokens */
61 |   struct Dyndata *dyd;  /* dynamic structures used by the parser */
62 |   TString *source;  /* current source name */
63 |   TString *envn;  /* environment variable name */
64 |   char decpoint;  /* locale decimal point */
65 | } LexState;
66 | 
67 | 
68 | LUAI_FUNC void luaX_init (lua_State *L);
69 | LUAI_FUNC void luaX_setinput (lua_State *L, LexState *ls, ZIO *z,
70 |                               TString *source, int firstchar);
71 | LUAI_FUNC TString *luaX_newstring (LexState *ls, const char *str, size_t l);
72 | LUAI_FUNC void luaX_next (LexState *ls);
73 | LUAI_FUNC int luaX_lookahead (LexState *ls);
74 | LUAI_FUNC l_noret luaX_syntaxerror (LexState *ls, const char *s);
75 | LUAI_FUNC const char *luaX_token2str (LexState *ls, int token);
76 | 
77 | 
78 | #endif
79 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lctype.c:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lctype.c,v 1.11.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** 'ctype' functions for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #define lctype_c
 8 | #define LUA_CORE
 9 | 
10 | #include "lctype.h"
11 | 
12 | #if !LUA_USE_CTYPE	/* { */
13 | 
14 | #include <limits.h>
15 | 
16 | LUAI_DDEF const lu_byte luai_ctype_[UCHAR_MAX + 2] = {
17 |   0x00,  /* EOZ */
18 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 0. */
19 |   0x00,  0x08,  0x08,  0x08,  0x08,  0x08,  0x00,  0x00,
20 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 1. */
21 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
22 |   0x0c,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,	/* 2. */
23 |   0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
24 |   0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,  0x16,	/* 3. */
25 |   0x16,  0x16,  0x04,  0x04,  0x04,  0x04,  0x04,  0x04,
26 |   0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 4. */
27 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
28 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 5. */
29 |   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x05,
30 |   0x04,  0x15,  0x15,  0x15,  0x15,  0x15,  0x15,  0x05,	/* 6. */
31 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,
32 |   0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,  0x05,	/* 7. */
33 |   0x05,  0x05,  0x05,  0x04,  0x04,  0x04,  0x04,  0x00,
34 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 8. */
35 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
36 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* 9. */
37 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
38 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* a. */
39 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
40 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* b. */
41 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
42 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* c. */
43 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
44 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* d. */
45 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
46 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* e. */
47 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
48 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,	/* f. */
49 |   0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,  0x00,
50 | };
51 | 
52 | #endif			/* } */
53 | 


--------------------------------------------------------------------------------
/hlua/src/macros.rs:
--------------------------------------------------------------------------------
 1 | #[macro_export]
 2 | macro_rules! implement_lua_push {
 3 |     ($ty:ty, $cb:expr) => {
 4 |         impl<'lua, L> $crate::Push<L> for $ty
 5 |         where
 6 |             L: $crate::AsMutLua<'lua>,
 7 |         {
 8 |             type Err = $crate::Void; // TODO: use ! instead
 9 |             #[inline]
10 |             fn push_to_lua(self, lua: L) -> Result<$crate::PushGuard<L>, ($crate::Void, L)> {
11 |                 Ok($crate::push_userdata(self, lua, $cb))
12 |             }
13 |         }
14 | 
15 |         impl<'lua, L> $crate::PushOne<L> for $ty where L: $crate::AsMutLua<'lua> {}
16 |     };
17 | }
18 | 
19 | #[macro_export]
20 | macro_rules! implement_lua_read {
21 |     ($ty:ty) => {
22 |         impl<'s, 'c> hlua::LuaRead<&'c mut hlua::InsideCallback> for &'s mut $ty {
23 |             #[inline]
24 |             fn lua_read_at_position(
25 |                 lua: &'c mut hlua::InsideCallback,
26 |                 index: i32,
27 |             ) -> Result<&'s mut $ty, &'c mut hlua::InsideCallback> {
28 |                 // FIXME:
29 |                 unsafe { ::std::mem::transmute($crate::read_userdata::<$ty>(lua, index)) }
30 |             }
31 |         }
32 | 
33 |         impl<'s, 'c> hlua::LuaRead<&'c mut hlua::InsideCallback> for &'s $ty {
34 |             #[inline]
35 |             fn lua_read_at_position(
36 |                 lua: &'c mut hlua::InsideCallback,
37 |                 index: i32,
38 |             ) -> Result<&'s $ty, &'c mut hlua::InsideCallback> {
39 |                 // FIXME:
40 |                 unsafe { ::std::mem::transmute($crate::read_userdata::<$ty>(lua, index)) }
41 |             }
42 |         }
43 | 
44 |         impl<'s, 'b, 'c> hlua::LuaRead<&'b mut &'c mut hlua::InsideCallback> for &'s mut $ty {
45 |             #[inline]
46 |             fn lua_read_at_position(
47 |                 lua: &'b mut &'c mut hlua::InsideCallback,
48 |                 index: i32,
49 |             ) -> Result<&'s mut $ty, &'b mut &'c mut hlua::InsideCallback> {
50 |                 let ptr_lua = lua as *mut &mut hlua::InsideCallback;
51 |                 let deref_lua = unsafe { ::std::ptr::read(ptr_lua) };
52 |                 let res = Self::lua_read_at_position(deref_lua, index);
53 |                 match res {
54 |                     Ok(x) => Ok(x),
55 |                     _ => Err(lua),
56 |                 }
57 |             }
58 |         }
59 | 
60 |         impl<'s, 'b, 'c> hlua::LuaRead<&'b mut &'c mut hlua::InsideCallback> for &'s $ty {
61 |             #[inline]
62 |             fn lua_read_at_position(
63 |                 lua: &'b mut &'c mut hlua::InsideCallback,
64 |                 index: i32,
65 |             ) -> Result<&'s $ty, &'b mut &'c mut hlua::InsideCallback> {
66 |                 let ptr_lua = lua as *mut &mut hlua::InsideCallback;
67 |                 let deref_lua = unsafe { ::std::ptr::read(ptr_lua) };
68 |                 let res = Self::lua_read_at_position(deref_lua, index);
69 |                 match res {
70 |                     Ok(x) => Ok(x),
71 |                     _ => Err(lua),
72 |                 }
73 |             }
74 |         }
75 |     };
76 | }
77 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lmem.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lmem.c,v 1.84.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Interface to Memory Manager
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stddef.h>
  9 | 
 10 | #define lmem_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "ldebug.h"
 16 | #include "ldo.h"
 17 | #include "lgc.h"
 18 | #include "lmem.h"
 19 | #include "lobject.h"
 20 | #include "lstate.h"
 21 | 
 22 | 
 23 | 
 24 | /*
 25 | ** About the realloc function:
 26 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
 27 | ** (`osize' is the old size, `nsize' is the new size)
 28 | **
 29 | ** * frealloc(ud, NULL, x, s) creates a new block of size `s' (no
 30 | ** matter 'x').
 31 | **
 32 | ** * frealloc(ud, p, x, 0) frees the block `p'
 33 | ** (in this specific case, frealloc must return NULL);
 34 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing
 35 | ** (which is equivalent to free(NULL) in ANSI C)
 36 | **
 37 | ** frealloc returns NULL if it cannot create or reallocate the area
 38 | ** (any reallocation to an equal or smaller size cannot fail!)
 39 | */
 40 | 
 41 | 
 42 | 
 43 | #define MINSIZEARRAY	4
 44 | 
 45 | 
 46 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
 47 |                      int limit, const char *what) {
 48 |   void *newblock;
 49 |   int newsize;
 50 |   if (*size >= limit/2) {  /* cannot double it? */
 51 |     if (*size >= limit)  /* cannot grow even a little? */
 52 |       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
 53 |     newsize = limit;  /* still have at least one free place */
 54 |   }
 55 |   else {
 56 |     newsize = (*size)*2;
 57 |     if (newsize < MINSIZEARRAY)
 58 |       newsize = MINSIZEARRAY;  /* minimum size */
 59 |   }
 60 |   newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
 61 |   *size = newsize;  /* update only when everything else is OK */
 62 |   return newblock;
 63 | }
 64 | 
 65 | 
 66 | l_noret luaM_toobig (lua_State *L) {
 67 |   luaG_runerror(L, "memory allocation error: block too big");
 68 | }
 69 | 
 70 | 
 71 | 
 72 | /*
 73 | ** generic allocation routine.
 74 | */
 75 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
 76 |   void *newblock;
 77 |   global_State *g = G(L);
 78 |   size_t realosize = (block) ? osize : 0;
 79 |   lua_assert((realosize == 0) == (block == NULL));
 80 | #if defined(HARDMEMTESTS)
 81 |   if (nsize > realosize && g->gcrunning)
 82 |     luaC_fullgc(L, 1);  /* force a GC whenever possible */
 83 | #endif
 84 |   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
 85 |   if (newblock == NULL && nsize > 0) {
 86 |     api_check(L, nsize > realosize,
 87 |                  "realloc cannot fail when shrinking a block");
 88 |     if (g->gcrunning) {
 89 |       luaC_fullgc(L, 1);  /* try to free some memory... */
 90 |       newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
 91 |     }
 92 |     if (newblock == NULL)
 93 |       luaD_throw(L, LUA_ERRMEM);
 94 |   }
 95 |   lua_assert((nsize == 0) == (newblock == NULL));
 96 |   g->GCdebt = (g->GCdebt + nsize) - realosize;
 97 |   return newblock;
 98 | }
 99 | 
100 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lcode.h:
--------------------------------------------------------------------------------
 1 | /*
 2 | ** $Id: lcode.h,v 1.58.1.1 2013/04/12 18:48:47 roberto Exp $
 3 | ** Code generator for Lua
 4 | ** See Copyright Notice in lua.h
 5 | */
 6 | 
 7 | #ifndef lcode_h
 8 | #define lcode_h
 9 | 
10 | #include "llex.h"
11 | #include "lobject.h"
12 | #include "lopcodes.h"
13 | #include "lparser.h"
14 | 
15 | 
16 | /*
17 | ** Marks the end of a patch list. It is an invalid value both as an absolute
18 | ** address, and as a list link (would link an element to itself).
19 | */
20 | #define NO_JUMP (-1)
21 | 
22 | 
23 | /*
24 | ** grep "ORDER OPR" if you change these enums  (ORDER OP)
25 | */
26 | typedef enum BinOpr {
27 |   OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
28 |   OPR_CONCAT,
29 |   OPR_EQ, OPR_LT, OPR_LE,
30 |   OPR_NE, OPR_GT, OPR_GE,
31 |   OPR_AND, OPR_OR,
32 |   OPR_NOBINOPR
33 | } BinOpr;
34 | 
35 | 
36 | typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
37 | 
38 | 
39 | #define getcode(fs,e)	((fs)->f->code[(e)->u.info])
40 | 
41 | #define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
42 | 
43 | #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
44 | 
45 | #define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
46 | 
47 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
48 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
49 | LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
50 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
51 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
52 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
53 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
54 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
55 | LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
56 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
57 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
58 | LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
59 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
60 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
61 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
62 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
63 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
64 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
65 | LUAI_FUNC void luaK_goiffalse (FuncState *fs, expdesc *e);
66 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
67 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
68 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
69 | LUAI_FUNC int luaK_jump (FuncState *fs);
70 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
71 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
72 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
73 | LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
74 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
75 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
76 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
77 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
78 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
79 |                             expdesc *v2, int line);
80 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
81 | 
82 | 
83 | #endif
84 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lopcodes.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lopcodes.c,v 1.49.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Opcodes for Lua virtual machine
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #define lopcodes_c
  9 | #define LUA_CORE
 10 | 
 11 | 
 12 | #include "lopcodes.h"
 13 | 
 14 | 
 15 | /* ORDER OP */
 16 | 
 17 | LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
 18 |   "MOVE",
 19 |   "LOADK",
 20 |   "LOADKX",
 21 |   "LOADBOOL",
 22 |   "LOADNIL",
 23 |   "GETUPVAL",
 24 |   "GETTABUP",
 25 |   "GETTABLE",
 26 |   "SETTABUP",
 27 |   "SETUPVAL",
 28 |   "SETTABLE",
 29 |   "NEWTABLE",
 30 |   "SELF",
 31 |   "ADD",
 32 |   "SUB",
 33 |   "MUL",
 34 |   "DIV",
 35 |   "MOD",
 36 |   "POW",
 37 |   "UNM",
 38 |   "NOT",
 39 |   "LEN",
 40 |   "CONCAT",
 41 |   "JMP",
 42 |   "EQ",
 43 |   "LT",
 44 |   "LE",
 45 |   "TEST",
 46 |   "TESTSET",
 47 |   "CALL",
 48 |   "TAILCALL",
 49 |   "RETURN",
 50 |   "FORLOOP",
 51 |   "FORPREP",
 52 |   "TFORCALL",
 53 |   "TFORLOOP",
 54 |   "SETLIST",
 55 |   "CLOSURE",
 56 |   "VARARG",
 57 |   "EXTRAARG",
 58 |   NULL
 59 | };
 60 | 
 61 | 
 62 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
 63 | 
 64 | LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
 65 | /*       T  A    B       C     mode		   opcode	*/
 66 |   opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_MOVE */
 67 |  ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
 68 |  ,opmode(0, 1, OpArgN, OpArgN, iABx)		/* OP_LOADKX */
 69 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
 70 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_LOADNIL */
 71 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
 72 |  ,opmode(0, 1, OpArgU, OpArgK, iABC)		/* OP_GETTABUP */
 73 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
 74 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABUP */
 75 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
 76 |  ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
 77 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
 78 |  ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
 79 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
 80 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
 81 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
 82 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
 83 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
 84 |  ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
 85 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
 86 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
 87 |  ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
 88 |  ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
 89 |  ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
 90 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
 91 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
 92 |  ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
 93 |  ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TEST */
 94 |  ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
 95 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
 96 |  ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
 97 |  ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
 98 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
 99 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
100 |  ,opmode(0, 0, OpArgN, OpArgU, iABC)		/* OP_TFORCALL */
101 |  ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_TFORLOOP */
102 |  ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
103 |  ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
104 |  ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
105 |  ,opmode(0, 0, OpArgU, OpArgU, iAx)		/* OP_EXTRAARG */
106 | };
107 | 
108 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for installing Lua
  2 | # See doc/readme.html for installation and customization instructions.
  3 | 
  4 | # == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
  5 | 
  6 | # Your platform. See PLATS for possible values.
  7 | PLAT= none
  8 | 
  9 | # Where to install. The installation starts in the src and doc directories,
 10 | # so take care if INSTALL_TOP is not an absolute path. See the local target.
 11 | # You may want to make INSTALL_LMOD and INSTALL_CMOD consistent with
 12 | # LUA_ROOT, LUA_LDIR, and LUA_CDIR in luaconf.h.
 13 | INSTALL_TOP= /usr/local
 14 | INSTALL_BIN= $(INSTALL_TOP)/bin
 15 | INSTALL_INC= $(INSTALL_TOP)/include
 16 | INSTALL_LIB= $(INSTALL_TOP)/lib
 17 | INSTALL_MAN= $(INSTALL_TOP)/man/man1
 18 | INSTALL_LMOD= $(INSTALL_TOP)/share/lua/$V
 19 | INSTALL_CMOD= $(INSTALL_TOP)/lib/lua/$V
 20 | 
 21 | # How to install. If your install program does not support "-p", then
 22 | # you may have to run ranlib on the installed liblua.a.
 23 | INSTALL= install -p
 24 | INSTALL_EXEC= $(INSTALL) -m 0755
 25 | INSTALL_DATA= $(INSTALL) -m 0644
 26 | #
 27 | # If you don't have "install" you can use "cp" instead.
 28 | # INSTALL= cp -p
 29 | # INSTALL_EXEC= $(INSTALL)
 30 | # INSTALL_DATA= $(INSTALL)
 31 | 
 32 | # Other utilities.
 33 | MKDIR= mkdir -p
 34 | RM= rm -f
 35 | 
 36 | # == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
 37 | 
 38 | # Convenience platforms targets.
 39 | PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
 40 | 
 41 | # What to install.
 42 | TO_BIN= lua luac
 43 | TO_INC= lua.h luaconf.h lualib.h lauxlib.h lua.hpp
 44 | TO_LIB= liblua.a
 45 | TO_MAN= lua.1 luac.1
 46 | 
 47 | # Lua version and release.
 48 | V= 5.2
 49 | R= $V.4
 50 | 
 51 | # Targets start here.
 52 | all:	$(PLAT)
 53 | 
 54 | $(PLATS) clean:
 55 | 	cd src && $(MAKE) $@
 56 | 
 57 | test:	dummy
 58 | 	src/lua -v
 59 | 
 60 | install: dummy
 61 | 	cd src && $(MKDIR) $(INSTALL_BIN) $(INSTALL_INC) $(INSTALL_LIB) $(INSTALL_MAN) $(INSTALL_LMOD) $(INSTALL_CMOD)
 62 | 	cd src && $(INSTALL_EXEC) $(TO_BIN) $(INSTALL_BIN)
 63 | 	cd src && $(INSTALL_DATA) $(TO_INC) $(INSTALL_INC)
 64 | 	cd src && $(INSTALL_DATA) $(TO_LIB) $(INSTALL_LIB)
 65 | 	cd doc && $(INSTALL_DATA) $(TO_MAN) $(INSTALL_MAN)
 66 | 
 67 | uninstall:
 68 | 	cd src && cd $(INSTALL_BIN) && $(RM) $(TO_BIN)
 69 | 	cd src && cd $(INSTALL_INC) && $(RM) $(TO_INC)
 70 | 	cd src && cd $(INSTALL_LIB) && $(RM) $(TO_LIB)
 71 | 	cd doc && cd $(INSTALL_MAN) && $(RM) $(TO_MAN)
 72 | 
 73 | local:
 74 | 	$(MAKE) install INSTALL_TOP=../install
 75 | 
 76 | none:
 77 | 	@echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
 78 | 	@echo "   $(PLATS)"
 79 | 	@echo "See doc/readme.html for complete instructions."
 80 | 
 81 | # make may get confused with test/ and install/
 82 | dummy:
 83 | 
 84 | # echo config parameters
 85 | echo:
 86 | 	@cd src && $(MAKE) -s echo
 87 | 	@echo "PLAT= $(PLAT)"
 88 | 	@echo "V= $V"
 89 | 	@echo "R= $R"
 90 | 	@echo "TO_BIN= $(TO_BIN)"
 91 | 	@echo "TO_INC= $(TO_INC)"
 92 | 	@echo "TO_LIB= $(TO_LIB)"
 93 | 	@echo "TO_MAN= $(TO_MAN)"
 94 | 	@echo "INSTALL_TOP= $(INSTALL_TOP)"
 95 | 	@echo "INSTALL_BIN= $(INSTALL_BIN)"
 96 | 	@echo "INSTALL_INC= $(INSTALL_INC)"
 97 | 	@echo "INSTALL_LIB= $(INSTALL_LIB)"
 98 | 	@echo "INSTALL_MAN= $(INSTALL_MAN)"
 99 | 	@echo "INSTALL_LMOD= $(INSTALL_LMOD)"
100 | 	@echo "INSTALL_CMOD= $(INSTALL_CMOD)"
101 | 	@echo "INSTALL_EXEC= $(INSTALL_EXEC)"
102 | 	@echo "INSTALL_DATA= $(INSTALL_DATA)"
103 | 
104 | # echo pkg-config data
105 | pc:
106 | 	@echo "version=$R"
107 | 	@echo "prefix=$(INSTALL_TOP)"
108 | 	@echo "libdir=$(INSTALL_LIB)"
109 | 	@echo "includedir=$(INSTALL_INC)"
110 | 
111 | # list targets that do not create files (but not all makes understand .PHONY)
112 | .PHONY: all $(PLATS) clean test install local none dummy echo pecho lecho
113 | 
114 | # (end of Makefile)
115 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lparser.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lparser.h,v 1.70.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Lua Parser
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lparser_h
  8 | #define lparser_h
  9 | 
 10 | #include "llimits.h"
 11 | #include "lobject.h"
 12 | #include "lzio.h"
 13 | 
 14 | 
 15 | /*
 16 | ** Expression descriptor
 17 | */
 18 | 
 19 | typedef enum {
 20 |   VVOID,	/* no value */
 21 |   VNIL,
 22 |   VTRUE,
 23 |   VFALSE,
 24 |   VK,		/* info = index of constant in `k' */
 25 |   VKNUM,	/* nval = numerical value */
 26 |   VNONRELOC,	/* info = result register */
 27 |   VLOCAL,	/* info = local register */
 28 |   VUPVAL,       /* info = index of upvalue in 'upvalues' */
 29 |   VINDEXED,	/* t = table register/upvalue; idx = index R/K */
 30 |   VJMP,		/* info = instruction pc */
 31 |   VRELOCABLE,	/* info = instruction pc */
 32 |   VCALL,	/* info = instruction pc */
 33 |   VVARARG	/* info = instruction pc */
 34 | } expkind;
 35 | 
 36 | 
 37 | #define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXED)
 38 | #define vkisinreg(k)	((k) == VNONRELOC || (k) == VLOCAL)
 39 | 
 40 | typedef struct expdesc {
 41 |   expkind k;
 42 |   union {
 43 |     struct {  /* for indexed variables (VINDEXED) */
 44 |       short idx;  /* index (R/K) */
 45 |       lu_byte t;  /* table (register or upvalue) */
 46 |       lu_byte vt;  /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
 47 |     } ind;
 48 |     int info;  /* for generic use */
 49 |     lua_Number nval;  /* for VKNUM */
 50 |   } u;
 51 |   int t;  /* patch list of `exit when true' */
 52 |   int f;  /* patch list of `exit when false' */
 53 | } expdesc;
 54 | 
 55 | 
 56 | /* description of active local variable */
 57 | typedef struct Vardesc {
 58 |   short idx;  /* variable index in stack */
 59 | } Vardesc;
 60 | 
 61 | 
 62 | /* description of pending goto statements and label statements */
 63 | typedef struct Labeldesc {
 64 |   TString *name;  /* label identifier */
 65 |   int pc;  /* position in code */
 66 |   int line;  /* line where it appeared */
 67 |   lu_byte nactvar;  /* local level where it appears in current block */
 68 | } Labeldesc;
 69 | 
 70 | 
 71 | /* list of labels or gotos */
 72 | typedef struct Labellist {
 73 |   Labeldesc *arr;  /* array */
 74 |   int n;  /* number of entries in use */
 75 |   int size;  /* array size */
 76 | } Labellist;
 77 | 
 78 | 
 79 | /* dynamic structures used by the parser */
 80 | typedef struct Dyndata {
 81 |   struct {  /* list of active local variables */
 82 |     Vardesc *arr;
 83 |     int n;
 84 |     int size;
 85 |   } actvar;
 86 |   Labellist gt;  /* list of pending gotos */
 87 |   Labellist label;   /* list of active labels */
 88 | } Dyndata;
 89 | 
 90 | 
 91 | /* control of blocks */
 92 | struct BlockCnt;  /* defined in lparser.c */
 93 | 
 94 | 
 95 | /* state needed to generate code for a given function */
 96 | typedef struct FuncState {
 97 |   Proto *f;  /* current function header */
 98 |   Table *h;  /* table to find (and reuse) elements in `k' */
 99 |   struct FuncState *prev;  /* enclosing function */
100 |   struct LexState *ls;  /* lexical state */
101 |   struct BlockCnt *bl;  /* chain of current blocks */
102 |   int pc;  /* next position to code (equivalent to `ncode') */
103 |   int lasttarget;   /* 'label' of last 'jump label' */
104 |   int jpc;  /* list of pending jumps to `pc' */
105 |   int nk;  /* number of elements in `k' */
106 |   int np;  /* number of elements in `p' */
107 |   int firstlocal;  /* index of first local var (in Dyndata array) */
108 |   short nlocvars;  /* number of elements in 'f->locvars' */
109 |   lu_byte nactvar;  /* number of active local variables */
110 |   lu_byte nups;  /* number of upvalues */
111 |   lu_byte freereg;  /* first free register */
112 | } FuncState;
113 | 
114 | 
115 | LUAI_FUNC Closure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
116 |                                 Dyndata *dyd, const char *name, int firstchar);
117 | 
118 | 
119 | #endif
120 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ldump.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ldump.c,v 2.17.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** save precompiled Lua chunks
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <stddef.h>
  8 | 
  9 | #define ldump_c
 10 | #define LUA_CORE
 11 | 
 12 | #include "lua.h"
 13 | 
 14 | #include "lobject.h"
 15 | #include "lstate.h"
 16 | #include "lundump.h"
 17 | 
 18 | typedef struct {
 19 |  lua_State* L;
 20 |  lua_Writer writer;
 21 |  void* data;
 22 |  int strip;
 23 |  int status;
 24 | } DumpState;
 25 | 
 26 | #define DumpMem(b,n,size,D)	DumpBlock(b,(n)*(size),D)
 27 | #define DumpVar(x,D)		DumpMem(&x,1,sizeof(x),D)
 28 | 
 29 | static void DumpBlock(const void* b, size_t size, DumpState* D)
 30 | {
 31 |  if (D->status==0)
 32 |  {
 33 |   lua_unlock(D->L);
 34 |   D->status=(*D->writer)(D->L,b,size,D->data);
 35 |   lua_lock(D->L);
 36 |  }
 37 | }
 38 | 
 39 | static void DumpChar(int y, DumpState* D)
 40 | {
 41 |  char x=(char)y;
 42 |  DumpVar(x,D);
 43 | }
 44 | 
 45 | static void DumpInt(int x, DumpState* D)
 46 | {
 47 |  DumpVar(x,D);
 48 | }
 49 | 
 50 | static void DumpNumber(lua_Number x, DumpState* D)
 51 | {
 52 |  DumpVar(x,D);
 53 | }
 54 | 
 55 | static void DumpVector(const void* b, int n, size_t size, DumpState* D)
 56 | {
 57 |  DumpInt(n,D);
 58 |  DumpMem(b,n,size,D);
 59 | }
 60 | 
 61 | static void DumpString(const TString* s, DumpState* D)
 62 | {
 63 |  if (s==NULL)
 64 |  {
 65 |   size_t size=0;
 66 |   DumpVar(size,D);
 67 |  }
 68 |  else
 69 |  {
 70 |   size_t size=s->tsv.len+1;		/* include trailing '\0' */
 71 |   DumpVar(size,D);
 72 |   DumpBlock(getstr(s),size*sizeof(char),D);
 73 |  }
 74 | }
 75 | 
 76 | #define DumpCode(f,D)	 DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
 77 | 
 78 | static void DumpFunction(const Proto* f, DumpState* D);
 79 | 
 80 | static void DumpConstants(const Proto* f, DumpState* D)
 81 | {
 82 |  int i,n=f->sizek;
 83 |  DumpInt(n,D);
 84 |  for (i=0; i<n; i++)
 85 |  {
 86 |   const TValue* o=&f->k[i];
 87 |   DumpChar(ttypenv(o),D);
 88 |   switch (ttypenv(o))
 89 |   {
 90 |    case LUA_TNIL:
 91 | 	break;
 92 |    case LUA_TBOOLEAN:
 93 | 	DumpChar(bvalue(o),D);
 94 | 	break;
 95 |    case LUA_TNUMBER:
 96 | 	DumpNumber(nvalue(o),D);
 97 | 	break;
 98 |    case LUA_TSTRING:
 99 | 	DumpString(rawtsvalue(o),D);
100 | 	break;
101 |     default: lua_assert(0);
102 |   }
103 |  }
104 |  n=f->sizep;
105 |  DumpInt(n,D);
106 |  for (i=0; i<n; i++) DumpFunction(f->p[i],D);
107 | }
108 | 
109 | static void DumpUpvalues(const Proto* f, DumpState* D)
110 | {
111 |  int i,n=f->sizeupvalues;
112 |  DumpInt(n,D);
113 |  for (i=0; i<n; i++)
114 |  {
115 |   DumpChar(f->upvalues[i].instack,D);
116 |   DumpChar(f->upvalues[i].idx,D);
117 |  }
118 | }
119 | 
120 | static void DumpDebug(const Proto* f, DumpState* D)
121 | {
122 |  int i,n;
123 |  DumpString((D->strip) ? NULL : f->source,D);
124 |  n= (D->strip) ? 0 : f->sizelineinfo;
125 |  DumpVector(f->lineinfo,n,sizeof(int),D);
126 |  n= (D->strip) ? 0 : f->sizelocvars;
127 |  DumpInt(n,D);
128 |  for (i=0; i<n; i++)
129 |  {
130 |   DumpString(f->locvars[i].varname,D);
131 |   DumpInt(f->locvars[i].startpc,D);
132 |   DumpInt(f->locvars[i].endpc,D);
133 |  }
134 |  n= (D->strip) ? 0 : f->sizeupvalues;
135 |  DumpInt(n,D);
136 |  for (i=0; i<n; i++) DumpString(f->upvalues[i].name,D);
137 | }
138 | 
139 | static void DumpFunction(const Proto* f, DumpState* D)
140 | {
141 |  DumpInt(f->linedefined,D);
142 |  DumpInt(f->lastlinedefined,D);
143 |  DumpChar(f->numparams,D);
144 |  DumpChar(f->is_vararg,D);
145 |  DumpChar(f->maxstacksize,D);
146 |  DumpCode(f,D);
147 |  DumpConstants(f,D);
148 |  DumpUpvalues(f,D);
149 |  DumpDebug(f,D);
150 | }
151 | 
152 | static void DumpHeader(DumpState* D)
153 | {
154 |  lu_byte h[LUAC_HEADERSIZE];
155 |  luaU_header(h);
156 |  DumpBlock(h,LUAC_HEADERSIZE,D);
157 | }
158 | 
159 | /*
160 | ** dump Lua function as precompiled chunk
161 | */
162 | int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
163 | {
164 |  DumpState D;
165 |  D.L=L;
166 |  D.writer=w;
167 |  D.data=data;
168 |  D.strip=strip;
169 |  D.status=0;
170 |  DumpHeader(&D);
171 |  DumpFunction(f,&D);
172 |  return D.status;
173 | }
174 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lcorolib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lcorolib.c,v 1.5.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Coroutine Library
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stdlib.h>
  9 | 
 10 | 
 11 | #define lcorolib_c
 12 | #define LUA_LIB
 13 | 
 14 | #include "lua.h"
 15 | 
 16 | #include "lauxlib.h"
 17 | #include "lualib.h"
 18 | 
 19 | 
 20 | static int auxresume (lua_State *L, lua_State *co, int narg) {
 21 |   int status;
 22 |   if (!lua_checkstack(co, narg)) {
 23 |     lua_pushliteral(L, "too many arguments to resume");
 24 |     return -1;  /* error flag */
 25 |   }
 26 |   if (lua_status(co) == LUA_OK && lua_gettop(co) == 0) {
 27 |     lua_pushliteral(L, "cannot resume dead coroutine");
 28 |     return -1;  /* error flag */
 29 |   }
 30 |   lua_xmove(L, co, narg);
 31 |   status = lua_resume(co, L, narg);
 32 |   if (status == LUA_OK || status == LUA_YIELD) {
 33 |     int nres = lua_gettop(co);
 34 |     if (!lua_checkstack(L, nres + 1)) {
 35 |       lua_pop(co, nres);  /* remove results anyway */
 36 |       lua_pushliteral(L, "too many results to resume");
 37 |       return -1;  /* error flag */
 38 |     }
 39 |     lua_xmove(co, L, nres);  /* move yielded values */
 40 |     return nres;
 41 |   }
 42 |   else {
 43 |     lua_xmove(co, L, 1);  /* move error message */
 44 |     return -1;  /* error flag */
 45 |   }
 46 | }
 47 | 
 48 | 
 49 | static int luaB_coresume (lua_State *L) {
 50 |   lua_State *co = lua_tothread(L, 1);
 51 |   int r;
 52 |   luaL_argcheck(L, co, 1, "coroutine expected");
 53 |   r = auxresume(L, co, lua_gettop(L) - 1);
 54 |   if (r < 0) {
 55 |     lua_pushboolean(L, 0);
 56 |     lua_insert(L, -2);
 57 |     return 2;  /* return false + error message */
 58 |   }
 59 |   else {
 60 |     lua_pushboolean(L, 1);
 61 |     lua_insert(L, -(r + 1));
 62 |     return r + 1;  /* return true + `resume' returns */
 63 |   }
 64 | }
 65 | 
 66 | 
 67 | static int luaB_auxwrap (lua_State *L) {
 68 |   lua_State *co = lua_tothread(L, lua_upvalueindex(1));
 69 |   int r = auxresume(L, co, lua_gettop(L));
 70 |   if (r < 0) {
 71 |     if (lua_isstring(L, -1)) {  /* error object is a string? */
 72 |       luaL_where(L, 1);  /* add extra info */
 73 |       lua_insert(L, -2);
 74 |       lua_concat(L, 2);
 75 |     }
 76 |     return lua_error(L);  /* propagate error */
 77 |   }
 78 |   return r;
 79 | }
 80 | 
 81 | 
 82 | static int luaB_cocreate (lua_State *L) {
 83 |   lua_State *NL;
 84 |   luaL_checktype(L, 1, LUA_TFUNCTION);
 85 |   NL = lua_newthread(L);
 86 |   lua_pushvalue(L, 1);  /* move function to top */
 87 |   lua_xmove(L, NL, 1);  /* move function from L to NL */
 88 |   return 1;
 89 | }
 90 | 
 91 | 
 92 | static int luaB_cowrap (lua_State *L) {
 93 |   luaB_cocreate(L);
 94 |   lua_pushcclosure(L, luaB_auxwrap, 1);
 95 |   return 1;
 96 | }
 97 | 
 98 | 
 99 | static int luaB_yield (lua_State *L) {
100 |   return lua_yield(L, lua_gettop(L));
101 | }
102 | 
103 | 
104 | static int luaB_costatus (lua_State *L) {
105 |   lua_State *co = lua_tothread(L, 1);
106 |   luaL_argcheck(L, co, 1, "coroutine expected");
107 |   if (L == co) lua_pushliteral(L, "running");
108 |   else {
109 |     switch (lua_status(co)) {
110 |       case LUA_YIELD:
111 |         lua_pushliteral(L, "suspended");
112 |         break;
113 |       case LUA_OK: {
114 |         lua_Debug ar;
115 |         if (lua_getstack(co, 0, &ar) > 0)  /* does it have frames? */
116 |           lua_pushliteral(L, "normal");  /* it is running */
117 |         else if (lua_gettop(co) == 0)
118 |             lua_pushliteral(L, "dead");
119 |         else
120 |           lua_pushliteral(L, "suspended");  /* initial state */
121 |         break;
122 |       }
123 |       default:  /* some error occurred */
124 |         lua_pushliteral(L, "dead");
125 |         break;
126 |     }
127 |   }
128 |   return 1;
129 | }
130 | 
131 | 
132 | static int luaB_corunning (lua_State *L) {
133 |   int ismain = lua_pushthread(L);
134 |   lua_pushboolean(L, ismain);
135 |   return 2;
136 | }
137 | 
138 | 
139 | static const luaL_Reg co_funcs[] = {
140 |   {"create", luaB_cocreate},
141 |   {"resume", luaB_coresume},
142 |   {"running", luaB_corunning},
143 |   {"status", luaB_costatus},
144 |   {"wrap", luaB_cowrap},
145 |   {"yield", luaB_yield},
146 |   {NULL, NULL}
147 | };
148 | 
149 | 
150 | 
151 | LUAMOD_API int luaopen_coroutine (lua_State *L) {
152 |   luaL_newlib(L, co_funcs);
153 |   return 1;
154 | }
155 | 
156 | 


--------------------------------------------------------------------------------
/hlua/src/tuples.rs:
--------------------------------------------------------------------------------
  1 | use AsLua;
  2 | use AsMutLua;
  3 | 
  4 | use LuaRead;
  5 | use Push;
  6 | use PushGuard;
  7 | use PushOne;
  8 | use Void;
  9 | 
 10 | macro_rules! tuple_impl {
 11 |     ($ty:ident) => (
 12 |         impl<'lua, LU, $ty> Push<LU> for ($ty,) where LU: AsMutLua<'lua>, $ty: Push<LU> {
 13 |             type Err = <$ty as Push<LU>>::Err;
 14 | 
 15 |             #[inline]
 16 |             fn push_to_lua(self, lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)> {
 17 |                 self.0.push_to_lua(lua)
 18 |             }
 19 |         }
 20 | 
 21 |         impl<'lua, LU, $ty> PushOne<LU> for ($ty,) where LU: AsMutLua<'lua>, $ty: PushOne<LU> {
 22 |         }
 23 | 
 24 |         impl<'lua, LU, $ty> LuaRead<LU> for ($ty,) where LU: AsMutLua<'lua>, $ty: LuaRead<LU> {
 25 |             #[inline]
 26 |             fn lua_read_at_position(lua: LU, index: i32) -> Result<($ty,), LU> {
 27 |                 LuaRead::lua_read_at_position(lua, index).map(|v| (v,))
 28 |             }
 29 |         }
 30 |     );
 31 | 
 32 |     ($first:ident, $($other:ident),+) => (
 33 |         #[allow(non_snake_case)]
 34 |         impl<'lua, LU, FE, OE, $first, $($other),+> Push<LU> for ($first, $($other),+)
 35 |             where LU: AsMutLua<'lua>,
 36 |                   $first: for<'a> Push<&'a mut LU, Err = FE>,
 37 |                   ($($other,)+): for<'a> Push<&'a mut LU, Err = OE>
 38 |         {
 39 |             type Err = TuplePushError<FE, OE>;
 40 | 
 41 |             #[inline]
 42 |             fn push_to_lua(self, mut lua: LU) -> Result<PushGuard<LU>, (Self::Err, LU)> {
 43 |                 match self {
 44 |                     ($first, $($other),+) => {
 45 |                         let mut total = 0;
 46 | 
 47 |                         let first_err = match $first.push_to_lua(&mut lua) {
 48 |                             Ok(pushed) => { total += pushed.forget_internal(); None },
 49 |                             Err((err, _)) => Some(err),
 50 |                         };
 51 | 
 52 |                         if let Some(err) = first_err {
 53 |                             return Err((TuplePushError::First(err), lua));
 54 |                         }
 55 | 
 56 |                         let rest = ($($other,)+);
 57 |                         let other_err = match rest.push_to_lua(&mut lua) {
 58 |                             Ok(pushed) => { total += pushed.forget_internal(); None },
 59 |                             Err((err, _)) => Some(err),
 60 |                         };
 61 | 
 62 |                         if let Some(err) = other_err {
 63 |                             return Err((TuplePushError::Other(err), lua));
 64 |                         }
 65 | 
 66 |                         let raw_lua = lua.as_lua();
 67 |                         Ok(PushGuard { lua: lua, size: total, raw_lua: raw_lua })
 68 |                     }
 69 |                 }
 70 |             }
 71 |         }
 72 | 
 73 |         // TODO: what if T or U are also tuples? indices won't match
 74 |         #[allow(unused_assignments)]
 75 |         #[allow(non_snake_case)]
 76 |         impl<'lua, LU, $first: for<'a> LuaRead<&'a mut LU>, $($other: for<'a> LuaRead<&'a mut LU>),+>
 77 |             LuaRead<LU> for ($first, $($other),+) where LU: AsLua<'lua>
 78 |         {
 79 |             #[inline]
 80 |             fn lua_read_at_position(mut lua: LU, index: i32) -> Result<($first, $($other),+), LU> {
 81 |                 let mut i = index;
 82 | 
 83 |                 let $first: $first = match LuaRead::lua_read_at_position(&mut lua, i) {
 84 |                     Ok(v) => v,
 85 |                     Err(_) => return Err(lua)
 86 |                 };
 87 | 
 88 |                 i += 1;
 89 | 
 90 |                 $(
 91 |                     let $other: $other = match LuaRead::lua_read_at_position(&mut lua, i) {
 92 |                         Ok(v) => v,
 93 |                         Err(_) => return Err(lua)
 94 |                     };
 95 |                     i += 1;
 96 |                 )+
 97 | 
 98 |                 Ok(($first, $($other),+))
 99 | 
100 |             }
101 |         }
102 | 
103 |         tuple_impl!($($other),+);
104 |     );
105 | }
106 | 
107 | tuple_impl!(A, B, C, D, E, F, G, H, I, J, K, L, M);
108 | 
109 | /// Error that can happen when pushing multiple values at once.
110 | // TODO: implement Error on that thing
111 | #[derive(Debug, Copy, Clone)]
112 | pub enum TuplePushError<C, O> {
113 |     First(C),
114 |     Other(O),
115 | }
116 | 
117 | impl From<TuplePushError<Void, Void>> for Void {
118 |     #[inline]
119 |     fn from(_: TuplePushError<Void, Void>) -> Void {
120 |         unreachable!()
121 |     }
122 | }
123 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lfunc.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lfunc.c,v 2.30.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Auxiliary functions to manipulate prototypes and closures
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stddef.h>
  9 | 
 10 | #define lfunc_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "lfunc.h"
 16 | #include "lgc.h"
 17 | #include "lmem.h"
 18 | #include "lobject.h"
 19 | #include "lstate.h"
 20 | 
 21 | 
 22 | 
 23 | Closure *luaF_newCclosure (lua_State *L, int n) {
 24 |   Closure *c = &luaC_newobj(L, LUA_TCCL, sizeCclosure(n), NULL, 0)->cl;
 25 |   c->c.nupvalues = cast_byte(n);
 26 |   return c;
 27 | }
 28 | 
 29 | 
 30 | Closure *luaF_newLclosure (lua_State *L, int n) {
 31 |   Closure *c = &luaC_newobj(L, LUA_TLCL, sizeLclosure(n), NULL, 0)->cl;
 32 |   c->l.p = NULL;
 33 |   c->l.nupvalues = cast_byte(n);
 34 |   while (n--) c->l.upvals[n] = NULL;
 35 |   return c;
 36 | }
 37 | 
 38 | 
 39 | UpVal *luaF_newupval (lua_State *L) {
 40 |   UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;
 41 |   uv->v = &uv->u.value;
 42 |   setnilvalue(uv->v);
 43 |   return uv;
 44 | }
 45 | 
 46 | 
 47 | UpVal *luaF_findupval (lua_State *L, StkId level) {
 48 |   global_State *g = G(L);
 49 |   GCObject **pp = &L->openupval;
 50 |   UpVal *p;
 51 |   UpVal *uv;
 52 |   while (*pp != NULL && (p = gco2uv(*pp))->v >= level) {
 53 |     GCObject *o = obj2gco(p);
 54 |     lua_assert(p->v != &p->u.value);
 55 |     lua_assert(!isold(o) || isold(obj2gco(L)));
 56 |     if (p->v == level) {  /* found a corresponding upvalue? */
 57 |       if (isdead(g, o))  /* is it dead? */
 58 |         changewhite(o);  /* resurrect it */
 59 |       return p;
 60 |     }
 61 |     pp = &p->next;
 62 |   }
 63 |   /* not found: create a new one */
 64 |   uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), pp, 0)->uv;
 65 |   uv->v = level;  /* current value lives in the stack */
 66 |   uv->u.l.prev = &g->uvhead;  /* double link it in `uvhead' list */
 67 |   uv->u.l.next = g->uvhead.u.l.next;
 68 |   uv->u.l.next->u.l.prev = uv;
 69 |   g->uvhead.u.l.next = uv;
 70 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 71 |   return uv;
 72 | }
 73 | 
 74 | 
 75 | static void unlinkupval (UpVal *uv) {
 76 |   lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
 77 |   uv->u.l.next->u.l.prev = uv->u.l.prev;  /* remove from `uvhead' list */
 78 |   uv->u.l.prev->u.l.next = uv->u.l.next;
 79 | }
 80 | 
 81 | 
 82 | void luaF_freeupval (lua_State *L, UpVal *uv) {
 83 |   if (uv->v != &uv->u.value)  /* is it open? */
 84 |     unlinkupval(uv);  /* remove from open list */
 85 |   luaM_free(L, uv);  /* free upvalue */
 86 | }
 87 | 
 88 | 
 89 | void luaF_close (lua_State *L, StkId level) {
 90 |   UpVal *uv;
 91 |   global_State *g = G(L);
 92 |   while (L->openupval != NULL && (uv = gco2uv(L->openupval))->v >= level) {
 93 |     GCObject *o = obj2gco(uv);
 94 |     lua_assert(!isblack(o) && uv->v != &uv->u.value);
 95 |     L->openupval = uv->next;  /* remove from `open' list */
 96 |     if (isdead(g, o))
 97 |       luaF_freeupval(L, uv);  /* free upvalue */
 98 |     else {
 99 |       unlinkupval(uv);  /* remove upvalue from 'uvhead' list */
100 |       setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
101 |       uv->v = &uv->u.value;  /* now current value lives here */
102 |       gch(o)->next = g->allgc;  /* link upvalue into 'allgc' list */
103 |       g->allgc = o;
104 |       luaC_checkupvalcolor(g, uv);
105 |     }
106 |   }
107 | }
108 | 
109 | 
110 | Proto *luaF_newproto (lua_State *L) {
111 |   Proto *f = &luaC_newobj(L, LUA_TPROTO, sizeof(Proto), NULL, 0)->p;
112 |   f->k = NULL;
113 |   f->sizek = 0;
114 |   f->p = NULL;
115 |   f->sizep = 0;
116 |   f->code = NULL;
117 |   f->cache = NULL;
118 |   f->sizecode = 0;
119 |   f->lineinfo = NULL;
120 |   f->sizelineinfo = 0;
121 |   f->upvalues = NULL;
122 |   f->sizeupvalues = 0;
123 |   f->numparams = 0;
124 |   f->is_vararg = 0;
125 |   f->maxstacksize = 0;
126 |   f->locvars = NULL;
127 |   f->sizelocvars = 0;
128 |   f->linedefined = 0;
129 |   f->lastlinedefined = 0;
130 |   f->source = NULL;
131 |   return f;
132 | }
133 | 
134 | 
135 | void luaF_freeproto (lua_State *L, Proto *f) {
136 |   luaM_freearray(L, f->code, f->sizecode);
137 |   luaM_freearray(L, f->p, f->sizep);
138 |   luaM_freearray(L, f->k, f->sizek);
139 |   luaM_freearray(L, f->lineinfo, f->sizelineinfo);
140 |   luaM_freearray(L, f->locvars, f->sizelocvars);
141 |   luaM_freearray(L, f->upvalues, f->sizeupvalues);
142 |   luaM_free(L, f);
143 | }
144 | 
145 | 
146 | /*
147 | ** Look for n-th local variable at line `line' in function `func'.
148 | ** Returns NULL if not found.
149 | */
150 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
151 |   int i;
152 |   for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
153 |     if (pc < f->locvars[i].endpc) {  /* is variable active? */
154 |       local_number--;
155 |       if (local_number == 0)
156 |         return getstr(f->locvars[i].varname);
157 |     }
158 |   }
159 |   return NULL;  /* not found */
160 | }
161 | 
162 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lbitlib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lbitlib.c,v 1.18.1.2 2013/07/09 18:01:41 roberto Exp $
  3 | ** Standard library for bitwise operations
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #define lbitlib_c
  8 | #define LUA_LIB
  9 | 
 10 | #include "lua.h"
 11 | 
 12 | #include "lauxlib.h"
 13 | #include "lualib.h"
 14 | 
 15 | 
 16 | /* number of bits to consider in a number */
 17 | #if !defined(LUA_NBITS)
 18 | #define LUA_NBITS	32
 19 | #endif
 20 | 
 21 | 
 22 | #define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
 23 | 
 24 | /* macro to trim extra bits */
 25 | #define trim(x)		((x) & ALLONES)
 26 | 
 27 | 
 28 | /* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
 29 | #define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
 30 | 
 31 | 
 32 | typedef lua_Unsigned b_uint;
 33 | 
 34 | 
 35 | 
 36 | static b_uint andaux (lua_State *L) {
 37 |   int i, n = lua_gettop(L);
 38 |   b_uint r = ~(b_uint)0;
 39 |   for (i = 1; i <= n; i++)
 40 |     r &= luaL_checkunsigned(L, i);
 41 |   return trim(r);
 42 | }
 43 | 
 44 | 
 45 | static int b_and (lua_State *L) {
 46 |   b_uint r = andaux(L);
 47 |   lua_pushunsigned(L, r);
 48 |   return 1;
 49 | }
 50 | 
 51 | 
 52 | static int b_test (lua_State *L) {
 53 |   b_uint r = andaux(L);
 54 |   lua_pushboolean(L, r != 0);
 55 |   return 1;
 56 | }
 57 | 
 58 | 
 59 | static int b_or (lua_State *L) {
 60 |   int i, n = lua_gettop(L);
 61 |   b_uint r = 0;
 62 |   for (i = 1; i <= n; i++)
 63 |     r |= luaL_checkunsigned(L, i);
 64 |   lua_pushunsigned(L, trim(r));
 65 |   return 1;
 66 | }
 67 | 
 68 | 
 69 | static int b_xor (lua_State *L) {
 70 |   int i, n = lua_gettop(L);
 71 |   b_uint r = 0;
 72 |   for (i = 1; i <= n; i++)
 73 |     r ^= luaL_checkunsigned(L, i);
 74 |   lua_pushunsigned(L, trim(r));
 75 |   return 1;
 76 | }
 77 | 
 78 | 
 79 | static int b_not (lua_State *L) {
 80 |   b_uint r = ~luaL_checkunsigned(L, 1);
 81 |   lua_pushunsigned(L, trim(r));
 82 |   return 1;
 83 | }
 84 | 
 85 | 
 86 | static int b_shift (lua_State *L, b_uint r, int i) {
 87 |   if (i < 0) {  /* shift right? */
 88 |     i = -i;
 89 |     r = trim(r);
 90 |     if (i >= LUA_NBITS) r = 0;
 91 |     else r >>= i;
 92 |   }
 93 |   else {  /* shift left */
 94 |     if (i >= LUA_NBITS) r = 0;
 95 |     else r <<= i;
 96 |     r = trim(r);
 97 |   }
 98 |   lua_pushunsigned(L, r);
 99 |   return 1;
100 | }
101 | 
102 | 
103 | static int b_lshift (lua_State *L) {
104 |   return b_shift(L, luaL_checkunsigned(L, 1), luaL_checkint(L, 2));
105 | }
106 | 
107 | 
108 | static int b_rshift (lua_State *L) {
109 |   return b_shift(L, luaL_checkunsigned(L, 1), -luaL_checkint(L, 2));
110 | }
111 | 
112 | 
113 | static int b_arshift (lua_State *L) {
114 |   b_uint r = luaL_checkunsigned(L, 1);
115 |   int i = luaL_checkint(L, 2);
116 |   if (i < 0 || !(r & ((b_uint)1 << (LUA_NBITS - 1))))
117 |     return b_shift(L, r, -i);
118 |   else {  /* arithmetic shift for 'negative' number */
119 |     if (i >= LUA_NBITS) r = ALLONES;
120 |     else
121 |       r = trim((r >> i) | ~(~(b_uint)0 >> i));  /* add signal bit */
122 |     lua_pushunsigned(L, r);
123 |     return 1;
124 |   }
125 | }
126 | 
127 | 
128 | static int b_rot (lua_State *L, int i) {
129 |   b_uint r = luaL_checkunsigned(L, 1);
130 |   i &= (LUA_NBITS - 1);  /* i = i % NBITS */
131 |   r = trim(r);
132 |   if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
133 |     r = (r << i) | (r >> (LUA_NBITS - i));
134 |   lua_pushunsigned(L, trim(r));
135 |   return 1;
136 | }
137 | 
138 | 
139 | static int b_lrot (lua_State *L) {
140 |   return b_rot(L, luaL_checkint(L, 2));
141 | }
142 | 
143 | 
144 | static int b_rrot (lua_State *L) {
145 |   return b_rot(L, -luaL_checkint(L, 2));
146 | }
147 | 
148 | 
149 | /*
150 | ** get field and width arguments for field-manipulation functions,
151 | ** checking whether they are valid.
152 | ** ('luaL_error' called without 'return' to avoid later warnings about
153 | ** 'width' being used uninitialized.)
154 | */
155 | static int fieldargs (lua_State *L, int farg, int *width) {
156 |   int f = luaL_checkint(L, farg);
157 |   int w = luaL_optint(L, farg + 1, 1);
158 |   luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
159 |   luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
160 |   if (f + w > LUA_NBITS)
161 |     luaL_error(L, "trying to access non-existent bits");
162 |   *width = w;
163 |   return f;
164 | }
165 | 
166 | 
167 | static int b_extract (lua_State *L) {
168 |   int w;
169 |   b_uint r = luaL_checkunsigned(L, 1);
170 |   int f = fieldargs(L, 2, &w);
171 |   r = (r >> f) & mask(w);
172 |   lua_pushunsigned(L, r);
173 |   return 1;
174 | }
175 | 
176 | 
177 | static int b_replace (lua_State *L) {
178 |   int w;
179 |   b_uint r = luaL_checkunsigned(L, 1);
180 |   b_uint v = luaL_checkunsigned(L, 2);
181 |   int f = fieldargs(L, 3, &w);
182 |   int m = mask(w);
183 |   v &= m;  /* erase bits outside given width */
184 |   r = (r & ~(m << f)) | (v << f);
185 |   lua_pushunsigned(L, r);
186 |   return 1;
187 | }
188 | 
189 | 
190 | static const luaL_Reg bitlib[] = {
191 |   {"arshift", b_arshift},
192 |   {"band", b_and},
193 |   {"bnot", b_not},
194 |   {"bor", b_or},
195 |   {"bxor", b_xor},
196 |   {"btest", b_test},
197 |   {"extract", b_extract},
198 |   {"lrotate", b_lrot},
199 |   {"lshift", b_lshift},
200 |   {"replace", b_replace},
201 |   {"rrotate", b_rrot},
202 |   {"rshift", b_rshift},
203 |   {NULL, NULL}
204 | };
205 | 
206 | 
207 | 
208 | LUAMOD_API int luaopen_bit32 (lua_State *L) {
209 |   luaL_newlib(L, bitlib);
210 |   return 1;
211 | }
212 | 
213 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lstring.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lstring.c,v 2.26.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** String table (keeps all strings handled by Lua)
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <string.h>
  9 | 
 10 | #define lstring_c
 11 | #define LUA_CORE
 12 | 
 13 | #include "lua.h"
 14 | 
 15 | #include "lmem.h"
 16 | #include "lobject.h"
 17 | #include "lstate.h"
 18 | #include "lstring.h"
 19 | 
 20 | 
 21 | /*
 22 | ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
 23 | ** compute its hash
 24 | */
 25 | #if !defined(LUAI_HASHLIMIT)
 26 | #define LUAI_HASHLIMIT		5
 27 | #endif
 28 | 
 29 | 
 30 | /*
 31 | ** equality for long strings
 32 | */
 33 | int luaS_eqlngstr (TString *a, TString *b) {
 34 |   size_t len = a->tsv.len;
 35 |   lua_assert(a->tsv.tt == LUA_TLNGSTR && b->tsv.tt == LUA_TLNGSTR);
 36 |   return (a == b) ||  /* same instance or... */
 37 |     ((len == b->tsv.len) &&  /* equal length and ... */
 38 |      (memcmp(getstr(a), getstr(b), len) == 0));  /* equal contents */
 39 | }
 40 | 
 41 | 
 42 | /*
 43 | ** equality for strings
 44 | */
 45 | int luaS_eqstr (TString *a, TString *b) {
 46 |   return (a->tsv.tt == b->tsv.tt) &&
 47 |          (a->tsv.tt == LUA_TSHRSTR ? eqshrstr(a, b) : luaS_eqlngstr(a, b));
 48 | }
 49 | 
 50 | 
 51 | unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
 52 |   unsigned int h = seed ^ cast(unsigned int, l);
 53 |   size_t l1;
 54 |   size_t step = (l >> LUAI_HASHLIMIT) + 1;
 55 |   for (l1 = l; l1 >= step; l1 -= step)
 56 |     h = h ^ ((h<<5) + (h>>2) + cast_byte(str[l1 - 1]));
 57 |   return h;
 58 | }
 59 | 
 60 | 
 61 | /*
 62 | ** resizes the string table
 63 | */
 64 | void luaS_resize (lua_State *L, int newsize) {
 65 |   int i;
 66 |   stringtable *tb = &G(L)->strt;
 67 |   /* cannot resize while GC is traversing strings */
 68 |   luaC_runtilstate(L, ~bitmask(GCSsweepstring));
 69 |   if (newsize > tb->size) {
 70 |     luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
 71 |     for (i = tb->size; i < newsize; i++) tb->hash[i] = NULL;
 72 |   }
 73 |   /* rehash */
 74 |   for (i=0; i<tb->size; i++) {
 75 |     GCObject *p = tb->hash[i];
 76 |     tb->hash[i] = NULL;
 77 |     while (p) {  /* for each node in the list */
 78 |       GCObject *next = gch(p)->next;  /* save next */
 79 |       unsigned int h = lmod(gco2ts(p)->hash, newsize);  /* new position */
 80 |       gch(p)->next = tb->hash[h];  /* chain it */
 81 |       tb->hash[h] = p;
 82 |       resetoldbit(p);  /* see MOVE OLD rule */
 83 |       p = next;
 84 |     }
 85 |   }
 86 |   if (newsize < tb->size) {
 87 |     /* shrinking slice must be empty */
 88 |     lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
 89 |     luaM_reallocvector(L, tb->hash, tb->size, newsize, GCObject *);
 90 |   }
 91 |   tb->size = newsize;
 92 | }
 93 | 
 94 | 
 95 | /*
 96 | ** creates a new string object
 97 | */
 98 | static TString *createstrobj (lua_State *L, const char *str, size_t l,
 99 |                               int tag, unsigned int h, GCObject **list) {
100 |   TString *ts;
101 |   size_t totalsize;  /* total size of TString object */
102 |   totalsize = sizeof(TString) + ((l + 1) * sizeof(char));
103 |   ts = &luaC_newobj(L, tag, totalsize, list, 0)->ts;
104 |   ts->tsv.len = l;
105 |   ts->tsv.hash = h;
106 |   ts->tsv.extra = 0;
107 |   memcpy(ts+1, str, l*sizeof(char));
108 |   ((char *)(ts+1))[l] = '\0';  /* ending 0 */
109 |   return ts;
110 | }
111 | 
112 | 
113 | /*
114 | ** creates a new short string, inserting it into string table
115 | */
116 | static TString *newshrstr (lua_State *L, const char *str, size_t l,
117 |                                        unsigned int h) {
118 |   GCObject **list;  /* (pointer to) list where it will be inserted */
119 |   stringtable *tb = &G(L)->strt;
120 |   TString *s;
121 |   if (tb->nuse >= cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
122 |     luaS_resize(L, tb->size*2);  /* too crowded */
123 |   list = &tb->hash[lmod(h, tb->size)];
124 |   s = createstrobj(L, str, l, LUA_TSHRSTR, h, list);
125 |   tb->nuse++;
126 |   return s;
127 | }
128 | 
129 | 
130 | /*
131 | ** checks whether short string exists and reuses it or creates a new one
132 | */
133 | static TString *internshrstr (lua_State *L, const char *str, size_t l) {
134 |   GCObject *o;
135 |   global_State *g = G(L);
136 |   unsigned int h = luaS_hash(str, l, g->seed);
137 |   for (o = g->strt.hash[lmod(h, g->strt.size)];
138 |        o != NULL;
139 |        o = gch(o)->next) {
140 |     TString *ts = rawgco2ts(o);
141 |     if (h == ts->tsv.hash &&
142 |         l == ts->tsv.len &&
143 |         (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
144 |       if (isdead(G(L), o))  /* string is dead (but was not collected yet)? */
145 |         changewhite(o);  /* resurrect it */
146 |       return ts;
147 |     }
148 |   }
149 |   return newshrstr(L, str, l, h);  /* not found; create a new string */
150 | }
151 | 
152 | 
153 | /*
154 | ** new string (with explicit length)
155 | */
156 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
157 |   if (l <= LUAI_MAXSHORTLEN)  /* short string? */
158 |     return internshrstr(L, str, l);
159 |   else {
160 |     if (l + 1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
161 |       luaM_toobig(L);
162 |     return createstrobj(L, str, l, LUA_TLNGSTR, G(L)->seed, NULL);
163 |   }
164 | }
165 | 
166 | 
167 | /*
168 | ** new zero-terminated string
169 | */
170 | TString *luaS_new (lua_State *L, const char *str) {
171 |   return luaS_newlstr(L, str, strlen(str));
172 | }
173 | 
174 | 
175 | Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
176 |   Udata *u;
177 |   if (s > MAX_SIZET - sizeof(Udata))
178 |     luaM_toobig(L);
179 |   u = &luaC_newobj(L, LUA_TUSERDATA, sizeof(Udata) + s, NULL, 0)->u;
180 |   u->uv.len = s;
181 |   u->uv.metatable = NULL;
182 |   u->uv.env = e;
183 |   return u;
184 | }
185 | 
186 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lgc.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lgc.h,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Garbage Collector
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lgc_h
  8 | #define lgc_h
  9 | 
 10 | 
 11 | #include "lobject.h"
 12 | #include "lstate.h"
 13 | 
 14 | /*
 15 | ** Collectable objects may have one of three colors: white, which
 16 | ** means the object is not marked; gray, which means the
 17 | ** object is marked, but its references may be not marked; and
 18 | ** black, which means that the object and all its references are marked.
 19 | ** The main invariant of the garbage collector, while marking objects,
 20 | ** is that a black object can never point to a white one. Moreover,
 21 | ** any gray object must be in a "gray list" (gray, grayagain, weak,
 22 | ** allweak, ephemeron) so that it can be visited again before finishing
 23 | ** the collection cycle. These lists have no meaning when the invariant
 24 | ** is not being enforced (e.g., sweep phase).
 25 | */
 26 | 
 27 | 
 28 | 
 29 | /* how much to allocate before next GC step */
 30 | #if !defined(GCSTEPSIZE)
 31 | /* ~100 small strings */
 32 | #define GCSTEPSIZE	(cast_int(100 * sizeof(TString)))
 33 | #endif
 34 | 
 35 | 
 36 | /*
 37 | ** Possible states of the Garbage Collector
 38 | */
 39 | #define GCSpropagate	0
 40 | #define GCSatomic	1
 41 | #define GCSsweepstring	2
 42 | #define GCSsweepudata	3
 43 | #define GCSsweep	4
 44 | #define GCSpause	5
 45 | 
 46 | 
 47 | #define issweepphase(g)  \
 48 | 	(GCSsweepstring <= (g)->gcstate && (g)->gcstate <= GCSsweep)
 49 | 
 50 | #define isgenerational(g)	((g)->gckind == KGC_GEN)
 51 | 
 52 | /*
 53 | ** macros to tell when main invariant (white objects cannot point to black
 54 | ** ones) must be kept. During a non-generational collection, the sweep
 55 | ** phase may break the invariant, as objects turned white may point to
 56 | ** still-black objects. The invariant is restored when sweep ends and
 57 | ** all objects are white again. During a generational collection, the
 58 | ** invariant must be kept all times.
 59 | */
 60 | 
 61 | #define keepinvariant(g)	(isgenerational(g) || g->gcstate <= GCSatomic)
 62 | 
 63 | 
 64 | /*
 65 | ** Outside the collector, the state in generational mode is kept in
 66 | ** 'propagate', so 'keepinvariant' is always true.
 67 | */
 68 | #define keepinvariantout(g)  \
 69 |   check_exp(g->gcstate == GCSpropagate || !isgenerational(g),  \
 70 |             g->gcstate <= GCSatomic)
 71 | 
 72 | 
 73 | /*
 74 | ** some useful bit tricks
 75 | */
 76 | #define resetbits(x,m)		((x) &= cast(lu_byte, ~(m)))
 77 | #define setbits(x,m)		((x) |= (m))
 78 | #define testbits(x,m)		((x) & (m))
 79 | #define bitmask(b)		(1<<(b))
 80 | #define bit2mask(b1,b2)		(bitmask(b1) | bitmask(b2))
 81 | #define l_setbit(x,b)		setbits(x, bitmask(b))
 82 | #define resetbit(x,b)		resetbits(x, bitmask(b))
 83 | #define testbit(x,b)		testbits(x, bitmask(b))
 84 | 
 85 | 
 86 | /* Layout for bit use in `marked' field: */
 87 | #define WHITE0BIT	0  /* object is white (type 0) */
 88 | #define WHITE1BIT	1  /* object is white (type 1) */
 89 | #define BLACKBIT	2  /* object is black */
 90 | #define FINALIZEDBIT	3  /* object has been separated for finalization */
 91 | #define SEPARATED	4  /* object is in 'finobj' list or in 'tobefnz' */
 92 | #define FIXEDBIT	5  /* object is fixed (should not be collected) */
 93 | #define OLDBIT		6  /* object is old (only in generational mode) */
 94 | /* bit 7 is currently used by tests (luaL_checkmemory) */
 95 | 
 96 | #define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
 97 | 
 98 | 
 99 | #define iswhite(x)      testbits((x)->gch.marked, WHITEBITS)
100 | #define isblack(x)      testbit((x)->gch.marked, BLACKBIT)
101 | #define isgray(x)  /* neither white nor black */  \
102 | 	(!testbits((x)->gch.marked, WHITEBITS | bitmask(BLACKBIT)))
103 | 
104 | #define isold(x)	testbit((x)->gch.marked, OLDBIT)
105 | 
106 | /* MOVE OLD rule: whenever an object is moved to the beginning of
107 |    a GC list, its old bit must be cleared */
108 | #define resetoldbit(o)	resetbit((o)->gch.marked, OLDBIT)
109 | 
110 | #define otherwhite(g)	(g->currentwhite ^ WHITEBITS)
111 | #define isdeadm(ow,m)	(!(((m) ^ WHITEBITS) & (ow)))
112 | #define isdead(g,v)	isdeadm(otherwhite(g), (v)->gch.marked)
113 | 
114 | #define changewhite(x)	((x)->gch.marked ^= WHITEBITS)
115 | #define gray2black(x)	l_setbit((x)->gch.marked, BLACKBIT)
116 | 
117 | #define valiswhite(x)	(iscollectable(x) && iswhite(gcvalue(x)))
118 | 
119 | #define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
120 | 
121 | 
122 | #define luaC_condGC(L,c) \
123 | 	{if (G(L)->GCdebt > 0) {c;}; condchangemem(L);}
124 | #define luaC_checkGC(L)		luaC_condGC(L, luaC_step(L);)
125 | 
126 | 
127 | #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
128 | 	luaC_barrier_(L,obj2gco(p),gcvalue(v)); }
129 | 
130 | #define luaC_barrierback(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p)))  \
131 | 	luaC_barrierback_(L,p); }
132 | 
133 | #define luaC_objbarrier(L,p,o)  \
134 | 	{ if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
135 | 		luaC_barrier_(L,obj2gco(p),obj2gco(o)); }
136 | 
137 | #define luaC_objbarrierback(L,p,o)  \
138 |    { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) luaC_barrierback_(L,p); }
139 | 
140 | #define luaC_barrierproto(L,p,c) \
141 |    { if (isblack(obj2gco(p))) luaC_barrierproto_(L,p,c); }
142 | 
143 | LUAI_FUNC void luaC_freeallobjects (lua_State *L);
144 | LUAI_FUNC void luaC_step (lua_State *L);
145 | LUAI_FUNC void luaC_forcestep (lua_State *L);
146 | LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
147 | LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
148 | LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz,
149 |                                  GCObject **list, int offset);
150 | LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
151 | LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
152 | LUAI_FUNC void luaC_barrierproto_ (lua_State *L, Proto *p, Closure *c);
153 | LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
154 | LUAI_FUNC void luaC_checkupvalcolor (global_State *g, UpVal *uv);
155 | LUAI_FUNC void luaC_changemode (lua_State *L, int mode);
156 | 
157 | #endif
158 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lundump.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lundump.c,v 2.22.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** load precompiled Lua chunks
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <string.h>
  8 | 
  9 | #define lundump_c
 10 | #define LUA_CORE
 11 | 
 12 | #include "lua.h"
 13 | 
 14 | #include "ldebug.h"
 15 | #include "ldo.h"
 16 | #include "lfunc.h"
 17 | #include "lmem.h"
 18 | #include "lobject.h"
 19 | #include "lstring.h"
 20 | #include "lundump.h"
 21 | #include "lzio.h"
 22 | 
 23 | typedef struct {
 24 |  lua_State* L;
 25 |  ZIO* Z;
 26 |  Mbuffer* b;
 27 |  const char* name;
 28 | } LoadState;
 29 | 
 30 | static l_noret error(LoadState* S, const char* why)
 31 | {
 32 |  luaO_pushfstring(S->L,"%s: %s precompiled chunk",S->name,why);
 33 |  luaD_throw(S->L,LUA_ERRSYNTAX);
 34 | }
 35 | 
 36 | #define LoadMem(S,b,n,size)	LoadBlock(S,b,(n)*(size))
 37 | #define LoadByte(S)		(lu_byte)LoadChar(S)
 38 | #define LoadVar(S,x)		LoadMem(S,&x,1,sizeof(x))
 39 | #define LoadVector(S,b,n,size)	LoadMem(S,b,n,size)
 40 | 
 41 | #if !defined(luai_verifycode)
 42 | #define luai_verifycode(L,b,f)	/* empty */
 43 | #endif
 44 | 
 45 | static void LoadBlock(LoadState* S, void* b, size_t size)
 46 | {
 47 |  if (luaZ_read(S->Z,b,size)!=0) error(S,"truncated");
 48 | }
 49 | 
 50 | static int LoadChar(LoadState* S)
 51 | {
 52 |  char x;
 53 |  LoadVar(S,x);
 54 |  return x;
 55 | }
 56 | 
 57 | static int LoadInt(LoadState* S)
 58 | {
 59 |  int x;
 60 |  LoadVar(S,x);
 61 |  if (x<0) error(S,"corrupted");
 62 |  return x;
 63 | }
 64 | 
 65 | static lua_Number LoadNumber(LoadState* S)
 66 | {
 67 |  lua_Number x;
 68 |  LoadVar(S,x);
 69 |  return x;
 70 | }
 71 | 
 72 | static TString* LoadString(LoadState* S)
 73 | {
 74 |  size_t size;
 75 |  LoadVar(S,size);
 76 |  if (size==0)
 77 |   return NULL;
 78 |  else
 79 |  {
 80 |   char* s=luaZ_openspace(S->L,S->b,size);
 81 |   LoadBlock(S,s,size*sizeof(char));
 82 |   return luaS_newlstr(S->L,s,size-1);		/* remove trailing '\0' */
 83 |  }
 84 | }
 85 | 
 86 | static void LoadCode(LoadState* S, Proto* f)
 87 | {
 88 |  int n=LoadInt(S);
 89 |  f->code=luaM_newvector(S->L,n,Instruction);
 90 |  f->sizecode=n;
 91 |  LoadVector(S,f->code,n,sizeof(Instruction));
 92 | }
 93 | 
 94 | static void LoadFunction(LoadState* S, Proto* f);
 95 | 
 96 | static void LoadConstants(LoadState* S, Proto* f)
 97 | {
 98 |  int i,n;
 99 |  n=LoadInt(S);
100 |  f->k=luaM_newvector(S->L,n,TValue);
101 |  f->sizek=n;
102 |  for (i=0; i<n; i++) setnilvalue(&f->k[i]);
103 |  for (i=0; i<n; i++)
104 |  {
105 |   TValue* o=&f->k[i];
106 |   int t=LoadChar(S);
107 |   switch (t)
108 |   {
109 |    case LUA_TNIL:
110 | 	setnilvalue(o);
111 | 	break;
112 |    case LUA_TBOOLEAN:
113 | 	setbvalue(o,LoadChar(S));
114 | 	break;
115 |    case LUA_TNUMBER:
116 | 	setnvalue(o,LoadNumber(S));
117 | 	break;
118 |    case LUA_TSTRING:
119 | 	setsvalue2n(S->L,o,LoadString(S));
120 | 	break;
121 |     default: lua_assert(0);
122 |   }
123 |  }
124 |  n=LoadInt(S);
125 |  f->p=luaM_newvector(S->L,n,Proto*);
126 |  f->sizep=n;
127 |  for (i=0; i<n; i++) f->p[i]=NULL;
128 |  for (i=0; i<n; i++)
129 |  {
130 |   f->p[i]=luaF_newproto(S->L);
131 |   LoadFunction(S,f->p[i]);
132 |  }
133 | }
134 | 
135 | static void LoadUpvalues(LoadState* S, Proto* f)
136 | {
137 |  int i,n;
138 |  n=LoadInt(S);
139 |  f->upvalues=luaM_newvector(S->L,n,Upvaldesc);
140 |  f->sizeupvalues=n;
141 |  for (i=0; i<n; i++) f->upvalues[i].name=NULL;
142 |  for (i=0; i<n; i++)
143 |  {
144 |   f->upvalues[i].instack=LoadByte(S);
145 |   f->upvalues[i].idx=LoadByte(S);
146 |  }
147 | }
148 | 
149 | static void LoadDebug(LoadState* S, Proto* f)
150 | {
151 |  int i,n;
152 |  f->source=LoadString(S);
153 |  n=LoadInt(S);
154 |  f->lineinfo=luaM_newvector(S->L,n,int);
155 |  f->sizelineinfo=n;
156 |  LoadVector(S,f->lineinfo,n,sizeof(int));
157 |  n=LoadInt(S);
158 |  f->locvars=luaM_newvector(S->L,n,LocVar);
159 |  f->sizelocvars=n;
160 |  for (i=0; i<n; i++) f->locvars[i].varname=NULL;
161 |  for (i=0; i<n; i++)
162 |  {
163 |   f->locvars[i].varname=LoadString(S);
164 |   f->locvars[i].startpc=LoadInt(S);
165 |   f->locvars[i].endpc=LoadInt(S);
166 |  }
167 |  n=LoadInt(S);
168 |  for (i=0; i<n; i++) f->upvalues[i].name=LoadString(S);
169 | }
170 | 
171 | static void LoadFunction(LoadState* S, Proto* f)
172 | {
173 |  f->linedefined=LoadInt(S);
174 |  f->lastlinedefined=LoadInt(S);
175 |  f->numparams=LoadByte(S);
176 |  f->is_vararg=LoadByte(S);
177 |  f->maxstacksize=LoadByte(S);
178 |  LoadCode(S,f);
179 |  LoadConstants(S,f);
180 |  LoadUpvalues(S,f);
181 |  LoadDebug(S,f);
182 | }
183 | 
184 | /* the code below must be consistent with the code in luaU_header */
185 | #define N0	LUAC_HEADERSIZE
186 | #define N1	(sizeof(LUA_SIGNATURE)-sizeof(char))
187 | #define N2	N1+2
188 | #define N3	N2+6
189 | 
190 | static void LoadHeader(LoadState* S)
191 | {
192 |  lu_byte h[LUAC_HEADERSIZE];
193 |  lu_byte s[LUAC_HEADERSIZE];
194 |  luaU_header(h);
195 |  memcpy(s,h,sizeof(char));			/* first char already read */
196 |  LoadBlock(S,s+sizeof(char),LUAC_HEADERSIZE-sizeof(char));
197 |  if (memcmp(h,s,N0)==0) return;
198 |  if (memcmp(h,s,N1)!=0) error(S,"not a");
199 |  if (memcmp(h,s,N2)!=0) error(S,"version mismatch in");
200 |  if (memcmp(h,s,N3)!=0) error(S,"incompatible"); else error(S,"corrupted");
201 | }
202 | 
203 | /*
204 | ** load precompiled chunk
205 | */
206 | Closure* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
207 | {
208 |  LoadState S;
209 |  Closure* cl;
210 |  if (*name=='@' || *name=='=')
211 |   S.name=name+1;
212 |  else if (*name==LUA_SIGNATURE[0])
213 |   S.name="binary string";
214 |  else
215 |   S.name=name;
216 |  S.L=L;
217 |  S.Z=Z;
218 |  S.b=buff;
219 |  LoadHeader(&S);
220 |  cl=luaF_newLclosure(L,1);
221 |  setclLvalue(L,L->top,cl); incr_top(L);
222 |  cl->l.p=luaF_newproto(L);
223 |  LoadFunction(&S,cl->l.p);
224 |  if (cl->l.p->sizeupvalues != 1)
225 |  {
226 |   Proto* p=cl->l.p;
227 |   cl=luaF_newLclosure(L,cl->l.p->sizeupvalues);
228 |   cl->l.p=p;
229 |   setclLvalue(L,L->top-1,cl);
230 |  }
231 |  luai_verifycode(L,buff,cl->l.p);
232 |  return cl;
233 | }
234 | 
235 | #define MYINT(s)	(s[0]-'0')
236 | #define VERSION		MYINT(LUA_VERSION_MAJOR)*16+MYINT(LUA_VERSION_MINOR)
237 | #define FORMAT		0		/* this is the official format */
238 | 
239 | /*
240 | * make header for precompiled chunks
241 | * if you change the code below be sure to update LoadHeader and FORMAT above
242 | * and LUAC_HEADERSIZE in lundump.h
243 | */
244 | void luaU_header (lu_byte* h)
245 | {
246 |  int x=1;
247 |  memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-sizeof(char));
248 |  h+=sizeof(LUA_SIGNATURE)-sizeof(char);
249 |  *h++=cast_byte(VERSION);
250 |  *h++=cast_byte(FORMAT);
251 |  *h++=cast_byte(*(char*)&x);			/* endianness */
252 |  *h++=cast_byte(sizeof(int));
253 |  *h++=cast_byte(sizeof(size_t));
254 |  *h++=cast_byte(sizeof(Instruction));
255 |  *h++=cast_byte(sizeof(lua_Number));
256 |  *h++=cast_byte(((lua_Number)0.5)==0);		/* is lua_Number integral? */
257 |  memcpy(h,LUAC_TAIL,sizeof(LUAC_TAIL)-sizeof(char));
258 | }
259 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/Makefile:
--------------------------------------------------------------------------------
  1 | # Makefile for building Lua
  2 | # See ../doc/readme.html for installation and customization instructions.
  3 | 
  4 | # == CHANGE THE SETTINGS BELOW TO SUIT YOUR ENVIRONMENT =======================
  5 | 
  6 | # Your platform. See PLATS for possible values.
  7 | PLAT= none
  8 | 
  9 | CC= gcc
 10 | CFLAGS= -O2 -Wall -DLUA_COMPAT_ALL $(SYSCFLAGS) $(MYCFLAGS)
 11 | LDFLAGS= $(SYSLDFLAGS) $(MYLDFLAGS)
 12 | LIBS= -lm $(SYSLIBS) $(MYLIBS)
 13 | 
 14 | AR= ar rcu
 15 | RANLIB= ranlib
 16 | RM= rm -f
 17 | 
 18 | SYSCFLAGS=
 19 | SYSLDFLAGS=
 20 | SYSLIBS=
 21 | 
 22 | MYCFLAGS=
 23 | MYLDFLAGS=
 24 | MYLIBS=
 25 | MYOBJS=
 26 | 
 27 | # == END OF USER SETTINGS -- NO NEED TO CHANGE ANYTHING BELOW THIS LINE =======
 28 | 
 29 | PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
 30 | 
 31 | LUA_A=	liblua.a
 32 | CORE_O=	lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o \
 33 | 	lmem.o lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o \
 34 | 	ltm.o lundump.o lvm.o lzio.o
 35 | LIB_O=	lauxlib.o lbaselib.o lbitlib.o lcorolib.o ldblib.o liolib.o \
 36 | 	lmathlib.o loslib.o lstrlib.o ltablib.o loadlib.o linit.o
 37 | BASE_O= $(CORE_O) $(LIB_O) $(MYOBJS)
 38 | 
 39 | LUA_T=	lua
 40 | LUA_O=	lua.o
 41 | 
 42 | LUAC_T=	luac
 43 | LUAC_O=	luac.o
 44 | 
 45 | ALL_O= $(BASE_O) $(LUA_O) $(LUAC_O)
 46 | ALL_T= $(LUA_A) $(LUA_T) $(LUAC_T)
 47 | ALL_A= $(LUA_A)
 48 | 
 49 | # Targets start here.
 50 | default: $(PLAT)
 51 | 
 52 | all:	$(ALL_T)
 53 | 
 54 | o:	$(ALL_O)
 55 | 
 56 | a:	$(ALL_A)
 57 | 
 58 | $(LUA_A): $(BASE_O)
 59 | 	$(AR) $@ $(BASE_O)
 60 | 	$(RANLIB) $@
 61 | 
 62 | $(LUA_T): $(LUA_O) $(LUA_A)
 63 | 	$(CC) -o $@ $(LDFLAGS) $(LUA_O) $(LUA_A) $(LIBS)
 64 | 
 65 | $(LUAC_T): $(LUAC_O) $(LUA_A)
 66 | 	$(CC) -o $@ $(LDFLAGS) $(LUAC_O) $(LUA_A) $(LIBS)
 67 | 
 68 | clean:
 69 | 	$(RM) $(ALL_T) $(ALL_O)
 70 | 
 71 | depend:
 72 | 	@$(CC) $(CFLAGS) -MM l*.c
 73 | 
 74 | echo:
 75 | 	@echo "PLAT= $(PLAT)"
 76 | 	@echo "CC= $(CC)"
 77 | 	@echo "CFLAGS= $(CFLAGS)"
 78 | 	@echo "LDFLAGS= $(SYSLDFLAGS)"
 79 | 	@echo "LIBS= $(LIBS)"
 80 | 	@echo "AR= $(AR)"
 81 | 	@echo "RANLIB= $(RANLIB)"
 82 | 	@echo "RM= $(RM)"
 83 | 
 84 | # Convenience targets for popular platforms
 85 | ALL= all
 86 | 
 87 | none:
 88 | 	@echo "Please do 'make PLATFORM' where PLATFORM is one of these:"
 89 | 	@echo "   $(PLATS)"
 90 | 
 91 | aix:
 92 | 	$(MAKE) $(ALL) CC="xlc" CFLAGS="-O2 -DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl" SYSLDFLAGS="-brtl -bexpall"
 93 | 
 94 | ansi:
 95 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_ANSI"
 96 | 
 97 | bsd:
 98 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-Wl,-E"
 99 | 
100 | freebsd:
101 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -lreadline"
102 | 
103 | generic: $(ALL)
104 | 
105 | linux:
106 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_LINUX" SYSLIBS="-Wl,-E -ldl -lreadline"
107 | 
108 | macosx:
109 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_MACOSX" SYSLIBS="-lreadline" CC=cc
110 | 
111 | mingw:
112 | 	$(MAKE) "LUA_A=lua52.dll" "LUA_T=lua.exe" \
113 | 	"AR=$(CC) -shared -o" "RANLIB=strip --strip-unneeded" \
114 | 	"SYSCFLAGS=-DLUA_BUILD_AS_DLL" "SYSLIBS=" "SYSLDFLAGS=-s" lua.exe
115 | 	$(MAKE) "LUAC_T=luac.exe" luac.exe
116 | 
117 | posix:
118 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX"
119 | 
120 | solaris:
121 | 	$(MAKE) $(ALL) SYSCFLAGS="-DLUA_USE_POSIX -DLUA_USE_DLOPEN" SYSLIBS="-ldl"
122 | 
123 | # list targets that do not create files (but not all makes understand .PHONY)
124 | .PHONY: all $(PLATS) default o a clean depend echo none
125 | 
126 | # DO NOT DELETE
127 | 
128 | lapi.o: lapi.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h ltm.h \
129 |  lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lstring.h ltable.h lundump.h \
130 |  lvm.h
131 | lauxlib.o: lauxlib.c lua.h luaconf.h lauxlib.h
132 | lbaselib.o: lbaselib.c lua.h luaconf.h lauxlib.h lualib.h
133 | lbitlib.o: lbitlib.c lua.h luaconf.h lauxlib.h lualib.h
134 | lcode.o: lcode.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
135 |  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lgc.h \
136 |  lstring.h ltable.h lvm.h
137 | lcorolib.o: lcorolib.c lua.h luaconf.h lauxlib.h lualib.h
138 | lctype.o: lctype.c lctype.h lua.h luaconf.h llimits.h
139 | ldblib.o: ldblib.c lua.h luaconf.h lauxlib.h lualib.h
140 | ldebug.o: ldebug.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h \
141 |  ltm.h lzio.h lmem.h lcode.h llex.h lopcodes.h lparser.h ldebug.h ldo.h \
142 |  lfunc.h lstring.h lgc.h ltable.h lvm.h
143 | ldo.o: ldo.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h ltm.h \
144 |  lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h lopcodes.h lparser.h \
145 |  lstring.h ltable.h lundump.h lvm.h
146 | ldump.o: ldump.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h \
147 |  lzio.h lmem.h lundump.h
148 | lfunc.o: lfunc.c lua.h luaconf.h lfunc.h lobject.h llimits.h lgc.h \
149 |  lstate.h ltm.h lzio.h lmem.h
150 | lgc.o: lgc.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
151 |  lzio.h lmem.h ldo.h lfunc.h lgc.h lstring.h ltable.h
152 | linit.o: linit.c lua.h luaconf.h lualib.h lauxlib.h
153 | liolib.o: liolib.c lua.h luaconf.h lauxlib.h lualib.h
154 | llex.o: llex.c lua.h luaconf.h lctype.h llimits.h ldo.h lobject.h \
155 |  lstate.h ltm.h lzio.h lmem.h llex.h lparser.h lstring.h lgc.h ltable.h
156 | lmathlib.o: lmathlib.c lua.h luaconf.h lauxlib.h lualib.h
157 | lmem.o: lmem.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
158 |  ltm.h lzio.h lmem.h ldo.h lgc.h
159 | loadlib.o: loadlib.c lua.h luaconf.h lauxlib.h lualib.h
160 | lobject.o: lobject.c lua.h luaconf.h lctype.h llimits.h ldebug.h lstate.h \
161 |  lobject.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h lvm.h
162 | lopcodes.o: lopcodes.c lopcodes.h llimits.h lua.h luaconf.h
163 | loslib.o: loslib.c lua.h luaconf.h lauxlib.h lualib.h
164 | lparser.o: lparser.c lua.h luaconf.h lcode.h llex.h lobject.h llimits.h \
165 |  lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h ldo.h lfunc.h \
166 |  lstring.h lgc.h ltable.h
167 | lstate.o: lstate.c lua.h luaconf.h lapi.h llimits.h lstate.h lobject.h \
168 |  ltm.h lzio.h lmem.h ldebug.h ldo.h lfunc.h lgc.h llex.h lstring.h \
169 |  ltable.h
170 | lstring.o: lstring.c lua.h luaconf.h lmem.h llimits.h lobject.h lstate.h \
171 |  ltm.h lzio.h lstring.h lgc.h
172 | lstrlib.o: lstrlib.c lua.h luaconf.h lauxlib.h lualib.h
173 | ltable.o: ltable.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h \
174 |  ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
175 | ltablib.o: ltablib.c lua.h luaconf.h lauxlib.h lualib.h
176 | ltm.o: ltm.c lua.h luaconf.h lobject.h llimits.h lstate.h ltm.h lzio.h \
177 |  lmem.h lstring.h lgc.h ltable.h
178 | lua.o: lua.c lua.h luaconf.h lauxlib.h lualib.h
179 | luac.o: luac.c lua.h luaconf.h lauxlib.h lobject.h llimits.h lstate.h \
180 |  ltm.h lzio.h lmem.h lundump.h ldebug.h lopcodes.h
181 | lundump.o: lundump.c lua.h luaconf.h ldebug.h lstate.h lobject.h \
182 |  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h lundump.h
183 | lvm.o: lvm.c lua.h luaconf.h ldebug.h lstate.h lobject.h llimits.h ltm.h \
184 |  lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h lvm.h
185 | lzio.o: lzio.c lua.h luaconf.h llimits.h lmem.h lstate.h lobject.h ltm.h \
186 |  lzio.h
187 | 
188 | 


--------------------------------------------------------------------------------
/hlua/src/userdata.rs:
--------------------------------------------------------------------------------
  1 | use std::any::{Any, TypeId};
  2 | use std::marker::PhantomData;
  3 | use std::mem;
  4 | use std::ops::{Deref, DerefMut};
  5 | use std::ptr;
  6 | 
  7 | use ffi;
  8 | use libc;
  9 | 
 10 | use AsLua;
 11 | use AsMutLua;
 12 | use LuaContext;
 13 | use LuaRead;
 14 | use Push;
 15 | use PushGuard;
 16 | 
 17 | use InsideCallback;
 18 | use LuaTable;
 19 | 
 20 | // Called when an object inside Lua is being dropped.
 21 | #[inline]
 22 | extern "C" fn destructor_wrapper<T>(lua: *mut ffi::lua_State) -> libc::c_int {
 23 |     unsafe {
 24 |         let obj = ffi::lua_touserdata(lua, -1);
 25 |         ptr::drop_in_place(obj as *mut TypeId);
 26 |         ptr::drop_in_place((obj as *mut u8).offset(mem::size_of::<TypeId>() as isize) as *mut T);
 27 |         0
 28 |     }
 29 | }
 30 | 
 31 | /// Pushes an object as a user data.
 32 | ///
 33 | /// In Lua, a user data is anything that is not recognized by Lua. When the script attempts to
 34 | /// copy a user data, instead only a reference to the data is copied.
 35 | ///
 36 | /// The way a Lua script can use the user data depends on the content of the **metatable**, which
 37 | /// is a Lua table linked to the object.
 38 | ///
 39 | /// [See this link for more infos.](http://www.lua.org/manual/5.2/manual.html#2.4)
 40 | ///
 41 | /// # About the Drop trait
 42 | ///
 43 | /// When the Lua context detects that a userdata is no longer needed it calls the function at the
 44 | /// `__gc` index in the userdata's metatable, if any. The hlua library will automatically fill this
 45 | /// index with a function that invokes the `Drop` trait of the userdata.
 46 | ///
 47 | /// You can replace the function if you wish so, although you are strongly discouraged to do it.
 48 | /// It is no unsafe to leak data in Rust, so there is no safety issue in doing so.
 49 | ///
 50 | /// # Arguments
 51 | ///
 52 | ///  - `metatable`: Function that fills the metatable of the object.
 53 | ///
 54 | #[inline]
 55 | pub fn push_userdata<'lua, L, T, F>(data: T, mut lua: L, metatable: F) -> PushGuard<L>
 56 | where
 57 |     F: FnOnce(LuaTable<&mut PushGuard<&mut L>>),
 58 |     L: AsMutLua<'lua>,
 59 |     T: Send + 'static + Any,
 60 | {
 61 |     unsafe {
 62 |         let typeid = TypeId::of::<T>();
 63 | 
 64 |         let lua_data = {
 65 |             let tot_size = mem::size_of_val(&typeid) + mem::size_of_val(&data);
 66 |             ffi::lua_newuserdata(lua.as_mut_lua().0, tot_size as libc::size_t)
 67 |         };
 68 | 
 69 |         // We check the alignment requirements.
 70 |         debug_assert_eq!(lua_data as usize % mem::align_of_val(&data), 0);
 71 |         // Since the size of a `TypeId` should always be a usize, this assert should pass every
 72 |         // time as well.
 73 |         debug_assert_eq!(mem::size_of_val(&typeid) % mem::align_of_val(&data), 0);
 74 | 
 75 |         // We write the `TypeId` first, and the data right next to it.
 76 |         ptr::write(lua_data as *mut TypeId, typeid);
 77 |         let data_loc = (lua_data as *const u8).offset(mem::size_of_val(&typeid) as isize);
 78 |         ptr::write(data_loc as *mut _, data);
 79 | 
 80 |         let lua_raw = lua.as_mut_lua();
 81 | 
 82 |         // Creating a metatable.
 83 |         ffi::lua_newtable(lua.as_mut_lua().0);
 84 | 
 85 |         // Index "__gc" in the metatable calls the object's destructor.
 86 | 
 87 |         // TODO: Could use std::intrinsics::needs_drop to avoid that if not needed.
 88 |         // After some discussion on IRC, it would be acceptable to add a reexport in libcore
 89 |         // without going through the RFC process.
 90 |         {
 91 |             match "__gc".push_to_lua(&mut lua) {
 92 |                 Ok(p) => p.forget(),
 93 |                 Err(_) => unreachable!(),
 94 |             };
 95 | 
 96 |             ffi::lua_pushcfunction(lua.as_mut_lua().0, destructor_wrapper::<T>);
 97 |             ffi::lua_settable(lua.as_mut_lua().0, -3);
 98 |         }
 99 | 
100 |         // Calling the metatable closure.
101 |         {
102 |             let raw_lua = lua.as_lua();
103 |             let mut guard = PushGuard {
104 |                 lua: &mut lua,
105 |                 size: 1,
106 |                 raw_lua: raw_lua,
107 |             };
108 |             metatable(LuaRead::lua_read(&mut guard).ok().unwrap());
109 |             guard.forget();
110 |         }
111 | 
112 |         ffi::lua_setmetatable(lua_raw.0, -2);
113 |     }
114 | 
115 |     let raw_lua = lua.as_lua();
116 |     PushGuard {
117 |         lua: lua,
118 |         size: 1,
119 |         raw_lua: raw_lua,
120 |     }
121 | }
122 | 
123 | ///
124 | #[inline]
125 | pub fn read_userdata<'t, 'c, T>(
126 |     lua: &'c mut InsideCallback,
127 |     index: i32,
128 | ) -> Result<&'t mut T, &'c mut InsideCallback>
129 | where
130 |     T: 'static + Any,
131 | {
132 |     unsafe {
133 |         let data_ptr = ffi::lua_touserdata(lua.as_lua().0, index);
134 |         if data_ptr.is_null() {
135 |             return Err(lua);
136 |         }
137 | 
138 |         let actual_typeid = data_ptr as *const TypeId;
139 |         if ptr::read_unaligned(actual_typeid) != TypeId::of::<T>() {
140 |             return Err(lua);
141 |         }
142 | 
143 |         let data = (data_ptr as *const u8).offset(mem::size_of::<TypeId>() as isize);
144 |         Ok(&mut *(data as *mut T))
145 |     }
146 | }
147 | 
148 | /// Represents a user data located inside the Lua context.
149 | #[derive(Debug)]
150 | pub struct UserdataOnStack<T, L> {
151 |     variable: L,
152 |     index: i32,
153 |     marker: PhantomData<T>,
154 | }
155 | 
156 | impl<'lua, T, L> LuaRead<L> for UserdataOnStack<T, L>
157 | where
158 |     L: AsMutLua<'lua>,
159 |     T: 'lua + Any,
160 | {
161 |     #[inline]
162 |     fn lua_read_at_position(lua: L, index: i32) -> Result<UserdataOnStack<T, L>, L> {
163 |         unsafe {
164 |             let data_ptr = ffi::lua_touserdata(lua.as_lua().0, index);
165 |             if data_ptr.is_null() {
166 |                 return Err(lua);
167 |             }
168 | 
169 |             let actual_typeid = data_ptr as *const TypeId;
170 |             if ptr::read_unaligned(actual_typeid) != TypeId::of::<T>() {
171 |                 return Err(lua);
172 |             }
173 | 
174 |             Ok(UserdataOnStack {
175 |                 variable: lua,
176 |                 index: index,
177 |                 marker: PhantomData,
178 |             })
179 |         }
180 |     }
181 | }
182 | 
183 | unsafe impl<'lua, T, L> AsLua<'lua> for UserdataOnStack<T, L>
184 | where
185 |     L: AsLua<'lua>,
186 |     T: 'lua + Any,
187 | {
188 |     #[inline]
189 |     fn as_lua(&self) -> LuaContext {
190 |         self.variable.as_lua()
191 |     }
192 | }
193 | 
194 | unsafe impl<'lua, T, L> AsMutLua<'lua> for UserdataOnStack<T, L>
195 | where
196 |     L: AsMutLua<'lua>,
197 |     T: 'lua + Any,
198 | {
199 |     #[inline]
200 |     fn as_mut_lua(&mut self) -> LuaContext {
201 |         self.variable.as_mut_lua()
202 |     }
203 | }
204 | 
205 | impl<'lua, T, L> Deref for UserdataOnStack<T, L>
206 | where
207 |     L: AsLua<'lua>,
208 |     T: 'lua + Any,
209 | {
210 |     type Target = T;
211 | 
212 |     #[inline]
213 |     fn deref(&self) -> &T {
214 |         unsafe {
215 |             let base = ffi::lua_touserdata(self.variable.as_lua().0, self.index);
216 |             let data = (base as *const u8).offset(mem::size_of::<TypeId>() as isize);
217 |             &*(data as *const T)
218 |         }
219 |     }
220 | }
221 | 
222 | impl<'lua, T, L> DerefMut for UserdataOnStack<T, L>
223 | where
224 |     L: AsMutLua<'lua>,
225 |     T: 'lua + Any,
226 | {
227 |     #[inline]
228 |     fn deref_mut(&mut self) -> &mut T {
229 |         unsafe {
230 |             let base = ffi::lua_touserdata(self.variable.as_mut_lua().0, self.index);
231 |             let data = (base as *const u8).offset(mem::size_of::<TypeId>() as isize);
232 |             &mut *(data as *mut T)
233 |         }
234 |     }
235 | }
236 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lmathlib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lmathlib.c,v 1.83.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Standard mathematical library
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stdlib.h>
  9 | #include <math.h>
 10 | 
 11 | #define lmathlib_c
 12 | #define LUA_LIB
 13 | 
 14 | #include "lua.h"
 15 | 
 16 | #include "lauxlib.h"
 17 | #include "lualib.h"
 18 | 
 19 | 
 20 | #undef PI
 21 | #define PI	((lua_Number)(3.1415926535897932384626433832795))
 22 | #define RADIANS_PER_DEGREE	((lua_Number)(PI/180.0))
 23 | 
 24 | 
 25 | 
 26 | static int math_abs (lua_State *L) {
 27 |   lua_pushnumber(L, l_mathop(fabs)(luaL_checknumber(L, 1)));
 28 |   return 1;
 29 | }
 30 | 
 31 | static int math_sin (lua_State *L) {
 32 |   lua_pushnumber(L, l_mathop(sin)(luaL_checknumber(L, 1)));
 33 |   return 1;
 34 | }
 35 | 
 36 | static int math_sinh (lua_State *L) {
 37 |   lua_pushnumber(L, l_mathop(sinh)(luaL_checknumber(L, 1)));
 38 |   return 1;
 39 | }
 40 | 
 41 | static int math_cos (lua_State *L) {
 42 |   lua_pushnumber(L, l_mathop(cos)(luaL_checknumber(L, 1)));
 43 |   return 1;
 44 | }
 45 | 
 46 | static int math_cosh (lua_State *L) {
 47 |   lua_pushnumber(L, l_mathop(cosh)(luaL_checknumber(L, 1)));
 48 |   return 1;
 49 | }
 50 | 
 51 | static int math_tan (lua_State *L) {
 52 |   lua_pushnumber(L, l_mathop(tan)(luaL_checknumber(L, 1)));
 53 |   return 1;
 54 | }
 55 | 
 56 | static int math_tanh (lua_State *L) {
 57 |   lua_pushnumber(L, l_mathop(tanh)(luaL_checknumber(L, 1)));
 58 |   return 1;
 59 | }
 60 | 
 61 | static int math_asin (lua_State *L) {
 62 |   lua_pushnumber(L, l_mathop(asin)(luaL_checknumber(L, 1)));
 63 |   return 1;
 64 | }
 65 | 
 66 | static int math_acos (lua_State *L) {
 67 |   lua_pushnumber(L, l_mathop(acos)(luaL_checknumber(L, 1)));
 68 |   return 1;
 69 | }
 70 | 
 71 | static int math_atan (lua_State *L) {
 72 |   lua_pushnumber(L, l_mathop(atan)(luaL_checknumber(L, 1)));
 73 |   return 1;
 74 | }
 75 | 
 76 | static int math_atan2 (lua_State *L) {
 77 |   lua_pushnumber(L, l_mathop(atan2)(luaL_checknumber(L, 1),
 78 |                                 luaL_checknumber(L, 2)));
 79 |   return 1;
 80 | }
 81 | 
 82 | static int math_ceil (lua_State *L) {
 83 |   lua_pushnumber(L, l_mathop(ceil)(luaL_checknumber(L, 1)));
 84 |   return 1;
 85 | }
 86 | 
 87 | static int math_floor (lua_State *L) {
 88 |   lua_pushnumber(L, l_mathop(floor)(luaL_checknumber(L, 1)));
 89 |   return 1;
 90 | }
 91 | 
 92 | static int math_fmod (lua_State *L) {
 93 |   lua_pushnumber(L, l_mathop(fmod)(luaL_checknumber(L, 1),
 94 |                                luaL_checknumber(L, 2)));
 95 |   return 1;
 96 | }
 97 | 
 98 | static int math_modf (lua_State *L) {
 99 |   lua_Number ip;
100 |   lua_Number fp = l_mathop(modf)(luaL_checknumber(L, 1), &ip);
101 |   lua_pushnumber(L, ip);
102 |   lua_pushnumber(L, fp);
103 |   return 2;
104 | }
105 | 
106 | static int math_sqrt (lua_State *L) {
107 |   lua_pushnumber(L, l_mathop(sqrt)(luaL_checknumber(L, 1)));
108 |   return 1;
109 | }
110 | 
111 | static int math_pow (lua_State *L) {
112 |   lua_Number x = luaL_checknumber(L, 1);
113 |   lua_Number y = luaL_checknumber(L, 2);
114 |   lua_pushnumber(L, l_mathop(pow)(x, y));
115 |   return 1;
116 | }
117 | 
118 | static int math_log (lua_State *L) {
119 |   lua_Number x = luaL_checknumber(L, 1);
120 |   lua_Number res;
121 |   if (lua_isnoneornil(L, 2))
122 |     res = l_mathop(log)(x);
123 |   else {
124 |     lua_Number base = luaL_checknumber(L, 2);
125 |     if (base == (lua_Number)10.0) res = l_mathop(log10)(x);
126 |     else res = l_mathop(log)(x)/l_mathop(log)(base);
127 |   }
128 |   lua_pushnumber(L, res);
129 |   return 1;
130 | }
131 | 
132 | #if defined(LUA_COMPAT_LOG10)
133 | static int math_log10 (lua_State *L) {
134 |   lua_pushnumber(L, l_mathop(log10)(luaL_checknumber(L, 1)));
135 |   return 1;
136 | }
137 | #endif
138 | 
139 | static int math_exp (lua_State *L) {
140 |   lua_pushnumber(L, l_mathop(exp)(luaL_checknumber(L, 1)));
141 |   return 1;
142 | }
143 | 
144 | static int math_deg (lua_State *L) {
145 |   lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
146 |   return 1;
147 | }
148 | 
149 | static int math_rad (lua_State *L) {
150 |   lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
151 |   return 1;
152 | }
153 | 
154 | static int math_frexp (lua_State *L) {
155 |   int e;
156 |   lua_pushnumber(L, l_mathop(frexp)(luaL_checknumber(L, 1), &e));
157 |   lua_pushinteger(L, e);
158 |   return 2;
159 | }
160 | 
161 | static int math_ldexp (lua_State *L) {
162 |   lua_Number x = luaL_checknumber(L, 1);
163 |   int ep = luaL_checkint(L, 2);
164 |   lua_pushnumber(L, l_mathop(ldexp)(x, ep));
165 |   return 1;
166 | }
167 | 
168 | 
169 | 
170 | static int math_min (lua_State *L) {
171 |   int n = lua_gettop(L);  /* number of arguments */
172 |   lua_Number dmin = luaL_checknumber(L, 1);
173 |   int i;
174 |   for (i=2; i<=n; i++) {
175 |     lua_Number d = luaL_checknumber(L, i);
176 |     if (d < dmin)
177 |       dmin = d;
178 |   }
179 |   lua_pushnumber(L, dmin);
180 |   return 1;
181 | }
182 | 
183 | 
184 | static int math_max (lua_State *L) {
185 |   int n = lua_gettop(L);  /* number of arguments */
186 |   lua_Number dmax = luaL_checknumber(L, 1);
187 |   int i;
188 |   for (i=2; i<=n; i++) {
189 |     lua_Number d = luaL_checknumber(L, i);
190 |     if (d > dmax)
191 |       dmax = d;
192 |   }
193 |   lua_pushnumber(L, dmax);
194 |   return 1;
195 | }
196 | 
197 | 
198 | static int math_random (lua_State *L) {
199 |   /* the `%' avoids the (rare) case of r==1, and is needed also because on
200 |      some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
201 |   lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
202 |   switch (lua_gettop(L)) {  /* check number of arguments */
203 |     case 0: {  /* no arguments */
204 |       lua_pushnumber(L, r);  /* Number between 0 and 1 */
205 |       break;
206 |     }
207 |     case 1: {  /* only upper limit */
208 |       lua_Number u = luaL_checknumber(L, 1);
209 |       luaL_argcheck(L, (lua_Number)1.0 <= u, 1, "interval is empty");
210 |       lua_pushnumber(L, l_mathop(floor)(r*u) + (lua_Number)(1.0));  /* [1, u] */
211 |       break;
212 |     }
213 |     case 2: {  /* lower and upper limits */
214 |       lua_Number l = luaL_checknumber(L, 1);
215 |       lua_Number u = luaL_checknumber(L, 2);
216 |       luaL_argcheck(L, l <= u, 2, "interval is empty");
217 |       lua_pushnumber(L, l_mathop(floor)(r*(u-l+1)) + l);  /* [l, u] */
218 |       break;
219 |     }
220 |     default: return luaL_error(L, "wrong number of arguments");
221 |   }
222 |   return 1;
223 | }
224 | 
225 | 
226 | static int math_randomseed (lua_State *L) {
227 |   srand(luaL_checkunsigned(L, 1));
228 |   (void)rand(); /* discard first value to avoid undesirable correlations */
229 |   return 0;
230 | }
231 | 
232 | 
233 | static const luaL_Reg mathlib[] = {
234 |   {"abs",   math_abs},
235 |   {"acos",  math_acos},
236 |   {"asin",  math_asin},
237 |   {"atan2", math_atan2},
238 |   {"atan",  math_atan},
239 |   {"ceil",  math_ceil},
240 |   {"cosh",   math_cosh},
241 |   {"cos",   math_cos},
242 |   {"deg",   math_deg},
243 |   {"exp",   math_exp},
244 |   {"floor", math_floor},
245 |   {"fmod",   math_fmod},
246 |   {"frexp", math_frexp},
247 |   {"ldexp", math_ldexp},
248 | #if defined(LUA_COMPAT_LOG10)
249 |   {"log10", math_log10},
250 | #endif
251 |   {"log",   math_log},
252 |   {"max",   math_max},
253 |   {"min",   math_min},
254 |   {"modf",   math_modf},
255 |   {"pow",   math_pow},
256 |   {"rad",   math_rad},
257 |   {"random",     math_random},
258 |   {"randomseed", math_randomseed},
259 |   {"sinh",   math_sinh},
260 |   {"sin",   math_sin},
261 |   {"sqrt",  math_sqrt},
262 |   {"tanh",   math_tanh},
263 |   {"tan",   math_tan},
264 |   {NULL, NULL}
265 | };
266 | 
267 | 
268 | /*
269 | ** Open math library
270 | */
271 | LUAMOD_API int luaopen_math (lua_State *L) {
272 |   luaL_newlib(L, mathlib);
273 |   lua_pushnumber(L, PI);
274 |   lua_setfield(L, -2, "pi");
275 |   lua_pushnumber(L, HUGE_VAL);
276 |   lua_setfield(L, -2, "huge");
277 |   return 1;
278 | }
279 | 
280 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ## hlua
  2 | 
  3 | This library is a high-level binding for Lua 5.2. You don't have access to the Lua stack, all you can do is read/write variables (including callbacks) and execute Lua code.
  4 | 
  5 | [![Build Status](https://travis-ci.org/tomaka/hlua.svg?branch=master)](https://travis-ci.org/tomaka/hlua)
  6 | 
  7 | ### How to install it?
  8 | 
  9 | Add this to the `Cargo.toml` file of your project
 10 | 
 11 | ```toml
 12 | [dependencies]
 13 | hlua = "0.3"
 14 | ```
 15 | 
 16 | ### How to use it?
 17 | 
 18 | ```rust
 19 | extern crate hlua;
 20 | use hlua::Lua;
 21 | ```
 22 | 
 23 | The `Lua` struct is the main element of this library. It represents a context in which you can execute Lua code.
 24 | 
 25 | ```rust
 26 | let mut lua = Lua::new();     // mutable is mandatory
 27 | ```
 28 | 
 29 | **[You can check the documentation here](http://docs.rs/hlua)**.
 30 | 
 31 | #### Reading and writing variables
 32 | 
 33 | ```rust
 34 | lua.set("x", 2);
 35 | lua.execute::<()>("x = x + 1").unwrap();
 36 | let x: i32 = lua.get("x").unwrap();  // x is equal to 3
 37 | ```
 38 | 
 39 | Reading and writing global variables of the Lua context can be done with `set` and `get`.
 40 | The `get` function returns an `Option<T>` and does a copy of the value.
 41 | 
 42 | The base types that can be read and written are: `i8`, `i16`, `i32`, `u8`, `u16`, `u32`, `f32`, `f64`, `bool`, `String`. `&str` can be written but not read.
 43 | 
 44 | If you wish so, you can also add other types by implementing the `Push` and `LuaRead` traits.
 45 | 
 46 | #### Executing Lua
 47 | 
 48 | ```rust
 49 | let x: u32 = lua.execute("return 6 * 2;").unwrap();    // equals 12
 50 | ```
 51 | 
 52 | The `execute` function takes a `&str` and returns a `Result<T, ExecutionError>` where `T: LuaRead`.
 53 | 
 54 | You can also call `execute_from_reader` which takes a `std::io::Read` as parameter.
 55 | For example you can easily execute the content of a file like this:
 56 | 
 57 | ```rust
 58 | lua.execute_from_reader::<()>(File::open(&Path::new("script.lua")).unwrap())
 59 | ```
 60 | 
 61 | #### Writing functions
 62 | 
 63 | In order to write a function, you must wrap it around `hlua::functionX` where `X` is the number of parameters. This is for the moment a limitation of Rust's inferrence system.
 64 | 
 65 | ```rust
 66 | fn add(a: i32, b: i32) -> i32 {
 67 |     a + b
 68 | }
 69 | 
 70 | lua.set("add", hlua::function2(add));
 71 | lua.execute::<()>("local c = add(2, 4)");   // calls the `add` function above
 72 | let c: i32 = lua.get("c").unwrap();   // returns 6
 73 | ```
 74 | 
 75 | In Lua, functions are exactly like regular variables.
 76 | 
 77 | You can write regular functions as well as closures:
 78 | 
 79 | ```rust
 80 | lua.set("mul", hlua::function2(|a: i32, b: i32| a * b));
 81 | ```
 82 | 
 83 | Note that the lifetime of the Lua context must be equal to or shorter than the lifetime of closures. This is enforced at compile-time.
 84 | 
 85 | ```rust
 86 | let mut a = 5i;
 87 | 
 88 | {
 89 |     let mut lua = Lua::new();
 90 | 
 91 |     lua.set("inc", || a += 1);    // borrows 'a'
 92 |     for i in (0 .. 15) {
 93 |         lua.execute::<()>("inc()").unwrap();
 94 |     }
 95 | } // unborrows `a`
 96 | 
 97 | assert_eq!(a, 20)
 98 | ```
 99 | 
100 | ##### Error handling
101 | 
102 | If your Rust function returns a `Result` object which contains an error, then a Lua error will be triggered.
103 | 
104 | #### Manipulating Lua tables
105 | 
106 | Manipulating a Lua table can be done by reading a `LuaTable` object. This can be achieved easily by reading a `LuaTable` object.
107 | 
108 | ```rust
109 | let mut table: hlua::LuaTable<_> = lua.get("a").unwrap();
110 | ```
111 | 
112 | You can then iterate through the table with the `.iter()` function. Note that the value returned by the iterator is an `Option<(Key, Value)>`, the `Option` being empty when either the key or the value is not convertible to the requested type. The `filter_map` function (provided by the standard `Iterator` trait) is very useful when dealing with this.
113 | 
114 | ```rust
115 | for (key, value) in table.iter().filter_map(|e| e) {
116 |     ...
117 | }
118 | ```
119 | 
120 | You can also retreive and modify individual indices:
121 | 
122 | ```rust
123 | let x = table.get("a").unwrap();
124 | table.set("b", "hello");
125 | ```
126 | 
127 | #### Calling Lua functions
128 | 
129 | You can call Lua functions by reading a `functions_read::LuaFunction`.
130 | 
131 | ```rust
132 | lua.execute::<()>("
133 |     function get_five() 
134 |         return 5
135 |     end");
136 | 
137 | let get_five: hlua::LuaFunction<_> = lua.get("get_five").unwrap();
138 | let value: i32 = get_five.call().unwrap();
139 | assert_eq!(value, 5);
140 | ```
141 | 
142 | This object holds a mutable reference of `Lua`, so you can't read or modify anything in the Lua context while the `get_five` variable exists.
143 | It is not possible to store the function for the moment, but it may be in the future.
144 | 
145 | #### Reading and writing Rust containers
146 | 
147 | *(note: not yet possible to read all containers, see below)*
148 | 
149 | It is possible to read and write whole Rust containers at once:
150 | 
151 | ```rust
152 | lua.set("a", [ 12, 13, 14, 15 ]);
153 | let hashmap: HashMap<i32, f64> = [1., 2., 3.].into_iter().enumerate().map(|(k, v)| (k as i32, *v as f64)).collect();
154 | lua.set("v", hashmap);
155 | ```
156 | 
157 | If the container has single elements, then the indices will be numerical. For example in the code above, the `12` will be at index `1`, the `13` at index `2`, etc.
158 | 
159 | If the container has tuples of two elements, then the first one will be considered as the key and the second one as the value.
160 | 
161 | This can be useful to create APIs:
162 | 
163 | ```rust
164 | fn foo() { }
165 | fn bar() { }
166 | 
167 | lua.set("mylib", [
168 |     ("foo", hlua::function0(foo)),
169 |     ("bar", hlua::function0(bar))
170 | ]);
171 | 
172 | lua.execute::<()>("mylib.foo()");
173 | ```
174 | 
175 | It is possible to read a `Vec<AnyLuaValue>`:
176 | 
177 | ```rust
178 |         let mut lua = Lua::new();
179 | 
180 |         lua.execute::<()>(r#"v = { 1, 2, 3 }"#).unwrap();
181 | 
182 |         let read: Vec<_> = lua.get("v").unwrap();
183 |         assert_eq!(
184 |             read,
185 |             [1., 2., 3.].iter()
186 |                 .map(|x| AnyLuaValue::LuaNumber(*x)).collect::<Vec<_>>());
187 | ```
188 | 
189 | In case table represents sparse array, has non-numeric keys, or
190 | indices not starting at 1, `.get()` will return `None`, as Rust's
191 | `Vec` doesn't support these features.
192 | 
193 | It is possible to read a `HashMap<AnyHashableLuaValue, AnyLuaValue>`:
194 | 
195 | ```rust
196 | let mut lua = Lua::new();
197 | 
198 | lua.execute::<()>(r#"v = { [-1] = -1, ["foo"] = 2, [2.] = 42 }"#).unwrap();
199 | 
200 | let read: HashMap<_, _> = lua.get("v").unwrap();
201 | assert_eq!(read[&AnyHashableLuaValue::LuaNumber(-1)], AnyLuaValue::LuaNumber(-1.));
202 | assert_eq!(read[&AnyHashableLuaValue::LuaString("foo".to_owned())], AnyLuaValue::LuaNumber(2.));
203 | assert_eq!(read[&AnyHashableLuaValue::LuaNumber(2)], AnyLuaValue::LuaNumber(42.));
204 | assert_eq!(read.len(), 3);
205 | ```
206 | 
207 | #### User data
208 | 
209 | **(note: the API here is very unstable for the moment)**
210 | 
211 | When you expose functions to Lua, you may wish to read or write more elaborate objects. This is called a **user data**.
212 | 
213 | To do so, you should implement the `Push`, `CopyRead` and `ConsumeRead` for your types.
214 | This is usually done by redirecting the call to `userdata::push_userdata`.
215 | 
216 | ```rust
217 | struct Foo;
218 | 
219 | impl<L> hlua::Push<L> for Foo where L: hlua::AsMutLua<'lua> {
220 |     fn push_to_lua(self, lua: L) -> hlua::PushGuard<L> {
221 |         lua::userdata::push_userdata(self, lua,
222 |             |mut metatable| {
223 |                 // you can define all the member functions of Foo here
224 |                 // see the official Lua documentation for metatables
225 |                 metatable.set("__call", hlua::function0(|| println!("hello from foo")))
226 |             })
227 |     }
228 | }
229 | 
230 | fn main() {
231 |     let mut lua = lua::Lua::new();
232 |     lua.set("foo", Foo);
233 |     lua.execute::<()>("foo()");       // prints "hello from foo"
234 | }
235 | ```
236 | 
237 | ### Contributing
238 | 
239 | Contributions are welcome!
240 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lauxlib.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lauxlib.h,v 1.120.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Auxiliary functions for building Lua libraries
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #ifndef lauxlib_h
  9 | #define lauxlib_h
 10 | 
 11 | 
 12 | #include <stddef.h>
 13 | #include <stdio.h>
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | 
 18 | 
 19 | /* extra error code for `luaL_load' */
 20 | #define LUA_ERRFILE     (LUA_ERRERR+1)
 21 | 
 22 | 
 23 | typedef struct luaL_Reg {
 24 |   const char *name;
 25 |   lua_CFunction func;
 26 | } luaL_Reg;
 27 | 
 28 | 
 29 | LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
 30 | #define luaL_checkversion(L)	luaL_checkversion_(L, LUA_VERSION_NUM)
 31 | 
 32 | LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
 33 | LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
 34 | LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
 35 | LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
 36 | LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
 37 |                                                           size_t *l);
 38 | LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
 39 |                                           const char *def, size_t *l);
 40 | LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
 41 | LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
 42 | 
 43 | LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
 44 | LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
 45 |                                           lua_Integer def);
 46 | LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
 47 | LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
 48 |                                             lua_Unsigned def);
 49 | 
 50 | LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
 51 | LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
 52 | LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
 53 | 
 54 | LUALIB_API int   (luaL_newmetatable) (lua_State *L, const char *tname);
 55 | LUALIB_API void  (luaL_setmetatable) (lua_State *L, const char *tname);
 56 | LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
 57 | LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
 58 | 
 59 | LUALIB_API void (luaL_where) (lua_State *L, int lvl);
 60 | LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
 61 | 
 62 | LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
 63 |                                    const char *const lst[]);
 64 | 
 65 | LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
 66 | LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
 67 | 
 68 | /* pre-defined references */
 69 | #define LUA_NOREF       (-2)
 70 | #define LUA_REFNIL      (-1)
 71 | 
 72 | LUALIB_API int (luaL_ref) (lua_State *L, int t);
 73 | LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
 74 | 
 75 | LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
 76 |                                                const char *mode);
 77 | 
 78 | #define luaL_loadfile(L,f)	luaL_loadfilex(L,f,NULL)
 79 | 
 80 | LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
 81 |                                    const char *name, const char *mode);
 82 | LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
 83 | 
 84 | LUALIB_API lua_State *(luaL_newstate) (void);
 85 | 
 86 | LUALIB_API int (luaL_len) (lua_State *L, int idx);
 87 | 
 88 | LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
 89 |                                                   const char *r);
 90 | 
 91 | LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
 92 | 
 93 | LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
 94 | 
 95 | LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
 96 |                                   const char *msg, int level);
 97 | 
 98 | LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
 99 |                                  lua_CFunction openf, int glb);
100 | 
101 | /*
102 | ** ===============================================================
103 | ** some useful macros
104 | ** ===============================================================
105 | */
106 | 
107 | 
108 | #define luaL_newlibtable(L,l)	\
109 |   lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
110 | 
111 | #define luaL_newlib(L,l)	(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
112 | 
113 | #define luaL_argcheck(L, cond,numarg,extramsg)	\
114 | 		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
115 | #define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
116 | #define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
117 | #define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))
118 | #define luaL_optint(L,n,d)	((int)luaL_optinteger(L, (n), (d)))
119 | #define luaL_checklong(L,n)	((long)luaL_checkinteger(L, (n)))
120 | #define luaL_optlong(L,n,d)	((long)luaL_optinteger(L, (n), (d)))
121 | 
122 | #define luaL_typename(L,i)	lua_typename(L, lua_type(L,(i)))
123 | 
124 | #define luaL_dofile(L, fn) \
125 | 	(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
126 | 
127 | #define luaL_dostring(L, s) \
128 | 	(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
129 | 
130 | #define luaL_getmetatable(L,n)	(lua_getfield(L, LUA_REGISTRYINDEX, (n)))
131 | 
132 | #define luaL_opt(L,f,n,d)	(lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
133 | 
134 | #define luaL_loadbuffer(L,s,sz,n)	luaL_loadbufferx(L,s,sz,n,NULL)
135 | 
136 | 
137 | /*
138 | ** {======================================================
139 | ** Generic Buffer manipulation
140 | ** =======================================================
141 | */
142 | 
143 | typedef struct luaL_Buffer {
144 |   char *b;  /* buffer address */
145 |   size_t size;  /* buffer size */
146 |   size_t n;  /* number of characters in buffer */
147 |   lua_State *L;
148 |   char initb[LUAL_BUFFERSIZE];  /* initial buffer */
149 | } luaL_Buffer;
150 | 
151 | 
152 | #define luaL_addchar(B,c) \
153 |   ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
154 |    ((B)->b[(B)->n++] = (c)))
155 | 
156 | #define luaL_addsize(B,s)	((B)->n += (s))
157 | 
158 | LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
159 | LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
160 | LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
161 | LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
162 | LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
163 | LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
164 | LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
165 | LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
166 | 
167 | #define luaL_prepbuffer(B)	luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
168 | 
169 | /* }====================================================== */
170 | 
171 | 
172 | 
173 | /*
174 | ** {======================================================
175 | ** File handles for IO library
176 | ** =======================================================
177 | */
178 | 
179 | /*
180 | ** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
181 | ** initial structure 'luaL_Stream' (it may contain other fields
182 | ** after that initial structure).
183 | */
184 | 
185 | #define LUA_FILEHANDLE          "FILE*"
186 | 
187 | 
188 | typedef struct luaL_Stream {
189 |   FILE *f;  /* stream (NULL for incompletely created streams) */
190 |   lua_CFunction closef;  /* to close stream (NULL for closed streams) */
191 | } luaL_Stream;
192 | 
193 | /* }====================================================== */
194 | 
195 | 
196 | 
197 | /* compatibility with old module system */
198 | #if defined(LUA_COMPAT_MODULE)
199 | 
200 | LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
201 |                                    int sizehint);
202 | LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
203 |                                 const luaL_Reg *l, int nup);
204 | 
205 | #define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
206 | 
207 | #endif
208 | 
209 | 
210 | #endif
211 | 
212 | 
213 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lstate.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lstate.h,v 2.82.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Global State
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lstate_h
  8 | #define lstate_h
  9 | 
 10 | #include "lua.h"
 11 | 
 12 | #include "lobject.h"
 13 | #include "ltm.h"
 14 | #include "lzio.h"
 15 | 
 16 | 
 17 | /*
 18 | 
 19 | ** Some notes about garbage-collected objects:  All objects in Lua must
 20 | ** be kept somehow accessible until being freed.
 21 | **
 22 | ** Lua keeps most objects linked in list g->allgc. The link uses field
 23 | ** 'next' of the CommonHeader.
 24 | **
 25 | ** Strings are kept in several lists headed by the array g->strt.hash.
 26 | **
 27 | ** Open upvalues are not subject to independent garbage collection. They
 28 | ** are collected together with their respective threads. Lua keeps a
 29 | ** double-linked list with all open upvalues (g->uvhead) so that it can
 30 | ** mark objects referred by them. (They are always gray, so they must
 31 | ** be remarked in the atomic step. Usually their contents would be marked
 32 | ** when traversing the respective threads, but the thread may already be
 33 | ** dead, while the upvalue is still accessible through closures.)
 34 | **
 35 | ** Objects with finalizers are kept in the list g->finobj.
 36 | **
 37 | ** The list g->tobefnz links all objects being finalized.
 38 | 
 39 | */
 40 | 
 41 | 
 42 | struct lua_longjmp;  /* defined in ldo.c */
 43 | 
 44 | 
 45 | 
 46 | /* extra stack space to handle TM calls and some other extras */
 47 | #define EXTRA_STACK   5
 48 | 
 49 | 
 50 | #define BASIC_STACK_SIZE        (2*LUA_MINSTACK)
 51 | 
 52 | 
 53 | /* kinds of Garbage Collection */
 54 | #define KGC_NORMAL	0
 55 | #define KGC_EMERGENCY	1	/* gc was forced by an allocation failure */
 56 | #define KGC_GEN		2	/* generational collection */
 57 | 
 58 | 
 59 | typedef struct stringtable {
 60 |   GCObject **hash;
 61 |   lu_int32 nuse;  /* number of elements */
 62 |   int size;
 63 | } stringtable;
 64 | 
 65 | 
 66 | /*
 67 | ** information about a call
 68 | */
 69 | typedef struct CallInfo {
 70 |   StkId func;  /* function index in the stack */
 71 |   StkId	top;  /* top for this function */
 72 |   struct CallInfo *previous, *next;  /* dynamic call link */
 73 |   short nresults;  /* expected number of results from this function */
 74 |   lu_byte callstatus;
 75 |   ptrdiff_t extra;
 76 |   union {
 77 |     struct {  /* only for Lua functions */
 78 |       StkId base;  /* base for this function */
 79 |       const Instruction *savedpc;
 80 |     } l;
 81 |     struct {  /* only for C functions */
 82 |       int ctx;  /* context info. in case of yields */
 83 |       lua_CFunction k;  /* continuation in case of yields */
 84 |       ptrdiff_t old_errfunc;
 85 |       lu_byte old_allowhook;
 86 |       lu_byte status;
 87 |     } c;
 88 |   } u;
 89 | } CallInfo;
 90 | 
 91 | 
 92 | /*
 93 | ** Bits in CallInfo status
 94 | */
 95 | #define CIST_LUA	(1<<0)	/* call is running a Lua function */
 96 | #define CIST_HOOKED	(1<<1)	/* call is running a debug hook */
 97 | #define CIST_REENTRY	(1<<2)	/* call is running on same invocation of
 98 |                                    luaV_execute of previous call */
 99 | #define CIST_YIELDED	(1<<3)	/* call reentered after suspension */
100 | #define CIST_YPCALL	(1<<4)	/* call is a yieldable protected call */
101 | #define CIST_STAT	(1<<5)	/* call has an error status (pcall) */
102 | #define CIST_TAIL	(1<<6)	/* call was tail called */
103 | #define CIST_HOOKYIELD	(1<<7)	/* last hook called yielded */
104 | 
105 | 
106 | #define isLua(ci)	((ci)->callstatus & CIST_LUA)
107 | 
108 | 
109 | /*
110 | ** `global state', shared by all threads of this state
111 | */
112 | typedef struct global_State {
113 |   lua_Alloc frealloc;  /* function to reallocate memory */
114 |   void *ud;         /* auxiliary data to `frealloc' */
115 |   lu_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
116 |   l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */
117 |   lu_mem GCmemtrav;  /* memory traversed by the GC */
118 |   lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */
119 |   stringtable strt;  /* hash table for strings */
120 |   TValue l_registry;
121 |   unsigned int seed;  /* randomized seed for hashes */
122 |   lu_byte currentwhite;
123 |   lu_byte gcstate;  /* state of garbage collector */
124 |   lu_byte gckind;  /* kind of GC running */
125 |   lu_byte gcrunning;  /* true if GC is running */
126 |   int sweepstrgc;  /* position of sweep in `strt' */
127 |   GCObject *allgc;  /* list of all collectable objects */
128 |   GCObject *finobj;  /* list of collectable objects with finalizers */
129 |   GCObject **sweepgc;  /* current position of sweep in list 'allgc' */
130 |   GCObject **sweepfin;  /* current position of sweep in list 'finobj' */
131 |   GCObject *gray;  /* list of gray objects */
132 |   GCObject *grayagain;  /* list of objects to be traversed atomically */
133 |   GCObject *weak;  /* list of tables with weak values */
134 |   GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
135 |   GCObject *allweak;  /* list of all-weak tables */
136 |   GCObject *tobefnz;  /* list of userdata to be GC */
137 |   UpVal uvhead;  /* head of double-linked list of all open upvalues */
138 |   Mbuffer buff;  /* temporary buffer for string concatenation */
139 |   int gcpause;  /* size of pause between successive GCs */
140 |   int gcmajorinc;  /* pause between major collections (only in gen. mode) */
141 |   int gcstepmul;  /* GC `granularity' */
142 |   lua_CFunction panic;  /* to be called in unprotected errors */
143 |   struct lua_State *mainthread;
144 |   const lua_Number *version;  /* pointer to version number */
145 |   TString *memerrmsg;  /* memory-error message */
146 |   TString *tmname[TM_N];  /* array with tag-method names */
147 |   struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */
148 | } global_State;
149 | 
150 | 
151 | /*
152 | ** `per thread' state
153 | */
154 | struct lua_State {
155 |   CommonHeader;
156 |   lu_byte status;
157 |   StkId top;  /* first free slot in the stack */
158 |   global_State *l_G;
159 |   CallInfo *ci;  /* call info for current function */
160 |   const Instruction *oldpc;  /* last pc traced */
161 |   StkId stack_last;  /* last free slot in the stack */
162 |   StkId stack;  /* stack base */
163 |   int stacksize;
164 |   unsigned short nny;  /* number of non-yieldable calls in stack */
165 |   unsigned short nCcalls;  /* number of nested C calls */
166 |   lu_byte hookmask;
167 |   lu_byte allowhook;
168 |   int basehookcount;
169 |   int hookcount;
170 |   lua_Hook hook;
171 |   GCObject *openupval;  /* list of open upvalues in this stack */
172 |   GCObject *gclist;
173 |   struct lua_longjmp *errorJmp;  /* current error recover point */
174 |   ptrdiff_t errfunc;  /* current error handling function (stack index) */
175 |   CallInfo base_ci;  /* CallInfo for first level (C calling Lua) */
176 | };
177 | 
178 | 
179 | #define G(L)	(L->l_G)
180 | 
181 | 
182 | /*
183 | ** Union of all collectable objects
184 | */
185 | union GCObject {
186 |   GCheader gch;  /* common header */
187 |   union TString ts;
188 |   union Udata u;
189 |   union Closure cl;
190 |   struct Table h;
191 |   struct Proto p;
192 |   struct UpVal uv;
193 |   struct lua_State th;  /* thread */
194 | };
195 | 
196 | 
197 | #define gch(o)		(&(o)->gch)
198 | 
199 | /* macros to convert a GCObject into a specific value */
200 | #define rawgco2ts(o)  \
201 | 	check_exp(novariant((o)->gch.tt) == LUA_TSTRING, &((o)->ts))
202 | #define gco2ts(o)	(&rawgco2ts(o)->tsv)
203 | #define rawgco2u(o)	check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
204 | #define gco2u(o)	(&rawgco2u(o)->uv)
205 | #define gco2lcl(o)	check_exp((o)->gch.tt == LUA_TLCL, &((o)->cl.l))
206 | #define gco2ccl(o)	check_exp((o)->gch.tt == LUA_TCCL, &((o)->cl.c))
207 | #define gco2cl(o)  \
208 | 	check_exp(novariant((o)->gch.tt) == LUA_TFUNCTION, &((o)->cl))
209 | #define gco2t(o)	check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
210 | #define gco2p(o)	check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
211 | #define gco2uv(o)	check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
212 | #define gco2th(o)	check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
213 | 
214 | /* macro to convert any Lua object into a GCObject */
215 | #define obj2gco(v)	(cast(GCObject *, (v)))
216 | 
217 | 
218 | /* actual number of total bytes allocated */
219 | #define gettotalbytes(g)	((g)->totalbytes + (g)->GCdebt)
220 | 
221 | LUAI_FUNC void luaE_setdebt (global_State *g, l_mem debt);
222 | LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
223 | LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
224 | LUAI_FUNC void luaE_freeCI (lua_State *L);
225 | 
226 | 
227 | #endif
228 | 
229 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/llimits.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: llimits.h,v 1.103.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Limits, basic types, and some other `installation-dependent' definitions
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef llimits_h
  8 | #define llimits_h
  9 | 
 10 | 
 11 | #include <limits.h>
 12 | #include <stddef.h>
 13 | 
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | 
 18 | typedef unsigned LUA_INT32 lu_int32;
 19 | 
 20 | typedef LUAI_UMEM lu_mem;
 21 | 
 22 | typedef LUAI_MEM l_mem;
 23 | 
 24 | 
 25 | 
 26 | /* chars used as small naturals (so that `char' is reserved for characters) */
 27 | typedef unsigned char lu_byte;
 28 | 
 29 | 
 30 | #define MAX_SIZET	((size_t)(~(size_t)0)-2)
 31 | 
 32 | #define MAX_LUMEM	((lu_mem)(~(lu_mem)0)-2)
 33 | 
 34 | #define MAX_LMEM	((l_mem) ((MAX_LUMEM >> 1) - 2))
 35 | 
 36 | 
 37 | #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
 38 | 
 39 | /*
 40 | ** conversion of pointer to integer
 41 | ** this is for hashing only; there is no problem if the integer
 42 | ** cannot hold the whole pointer value
 43 | */
 44 | #define IntPoint(p)  ((unsigned int)(lu_mem)(p))
 45 | 
 46 | 
 47 | 
 48 | /* type to ensure maximum alignment */
 49 | #if !defined(LUAI_USER_ALIGNMENT_T)
 50 | #define LUAI_USER_ALIGNMENT_T	union { double u; void *s; long l; }
 51 | #endif
 52 | 
 53 | typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
 54 | 
 55 | 
 56 | /* result of a `usual argument conversion' over lua_Number */
 57 | typedef LUAI_UACNUMBER l_uacNumber;
 58 | 
 59 | 
 60 | /* internal assertions for in-house debugging */
 61 | #if defined(lua_assert)
 62 | #define check_exp(c,e)		(lua_assert(c), (e))
 63 | /* to avoid problems with conditions too long */
 64 | #define lua_longassert(c)	{ if (!(c)) lua_assert(0); }
 65 | #else
 66 | #define lua_assert(c)		((void)0)
 67 | #define check_exp(c,e)		(e)
 68 | #define lua_longassert(c)	((void)0)
 69 | #endif
 70 | 
 71 | /*
 72 | ** assertion for checking API calls
 73 | */
 74 | #if !defined(luai_apicheck)
 75 | 
 76 | #if defined(LUA_USE_APICHECK)
 77 | #include <assert.h>
 78 | #define luai_apicheck(L,e)	assert(e)
 79 | #else
 80 | #define luai_apicheck(L,e)	lua_assert(e)
 81 | #endif
 82 | 
 83 | #endif
 84 | 
 85 | #define api_check(l,e,msg)	luai_apicheck(l,(e) && msg)
 86 | 
 87 | 
 88 | #if !defined(UNUSED)
 89 | #define UNUSED(x)	((void)(x))	/* to avoid warnings */
 90 | #endif
 91 | 
 92 | 
 93 | #define cast(t, exp)	((t)(exp))
 94 | 
 95 | #define cast_byte(i)	cast(lu_byte, (i))
 96 | #define cast_num(i)	cast(lua_Number, (i))
 97 | #define cast_int(i)	cast(int, (i))
 98 | #define cast_uchar(i)	cast(unsigned char, (i))
 99 | 
100 | 
101 | /*
102 | ** non-return type
103 | */
104 | #if defined(__GNUC__)
105 | #define l_noret		void __attribute__((noreturn))
106 | #elif defined(_MSC_VER)
107 | #define l_noret		void __declspec(noreturn)
108 | #else
109 | #define l_noret		void
110 | #endif
111 | 
112 | 
113 | 
114 | /*
115 | ** maximum depth for nested C calls and syntactical nested non-terminals
116 | ** in a program. (Value must fit in an unsigned short int.)
117 | */
118 | #if !defined(LUAI_MAXCCALLS)
119 | #define LUAI_MAXCCALLS		200
120 | #endif
121 | 
122 | /*
123 | ** maximum number of upvalues in a closure (both C and Lua). (Value
124 | ** must fit in an unsigned char.)
125 | */
126 | #define MAXUPVAL	UCHAR_MAX
127 | 
128 | 
129 | /*
130 | ** type for virtual-machine instructions
131 | ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
132 | */
133 | typedef lu_int32 Instruction;
134 | 
135 | 
136 | 
137 | /* maximum stack for a Lua function */
138 | #define MAXSTACK	250
139 | 
140 | 
141 | 
142 | /* minimum size for the string table (must be power of 2) */
143 | #if !defined(MINSTRTABSIZE)
144 | #define MINSTRTABSIZE	32
145 | #endif
146 | 
147 | 
148 | /* minimum size for string buffer */
149 | #if !defined(LUA_MINBUFFER)
150 | #define LUA_MINBUFFER	32
151 | #endif
152 | 
153 | 
154 | #if !defined(lua_lock)
155 | #define lua_lock(L)     ((void) 0)
156 | #define lua_unlock(L)   ((void) 0)
157 | #endif
158 | 
159 | #if !defined(luai_threadyield)
160 | #define luai_threadyield(L)     {lua_unlock(L); lua_lock(L);}
161 | #endif
162 | 
163 | 
164 | /*
165 | ** these macros allow user-specific actions on threads when you defined
166 | ** LUAI_EXTRASPACE and need to do something extra when a thread is
167 | ** created/deleted/resumed/yielded.
168 | */
169 | #if !defined(luai_userstateopen)
170 | #define luai_userstateopen(L)		((void)L)
171 | #endif
172 | 
173 | #if !defined(luai_userstateclose)
174 | #define luai_userstateclose(L)		((void)L)
175 | #endif
176 | 
177 | #if !defined(luai_userstatethread)
178 | #define luai_userstatethread(L,L1)	((void)L)
179 | #endif
180 | 
181 | #if !defined(luai_userstatefree)
182 | #define luai_userstatefree(L,L1)	((void)L)
183 | #endif
184 | 
185 | #if !defined(luai_userstateresume)
186 | #define luai_userstateresume(L,n)       ((void)L)
187 | #endif
188 | 
189 | #if !defined(luai_userstateyield)
190 | #define luai_userstateyield(L,n)        ((void)L)
191 | #endif
192 | 
193 | /*
194 | ** lua_number2int is a macro to convert lua_Number to int.
195 | ** lua_number2integer is a macro to convert lua_Number to lua_Integer.
196 | ** lua_number2unsigned is a macro to convert a lua_Number to a lua_Unsigned.
197 | ** lua_unsigned2number is a macro to convert a lua_Unsigned to a lua_Number.
198 | ** luai_hashnum is a macro to hash a lua_Number value into an integer.
199 | ** The hash must be deterministic and give reasonable values for
200 | ** both small and large values (outside the range of integers).
201 | */
202 | 
203 | #if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK)	/* { */
204 | /* trick with Microsoft assembler for X86 */
205 | 
206 | #define lua_number2int(i,n)  __asm {__asm fld n   __asm fistp i}
207 | #define lua_number2integer(i,n)		lua_number2int(i, n)
208 | #define lua_number2unsigned(i,n)  \
209 |   {__int64 l; __asm {__asm fld n   __asm fistp l} i = (unsigned int)l;}
210 | 
211 | 
212 | #elif defined(LUA_IEEE754TRICK)		/* }{ */
213 | /* the next trick should work on any machine using IEEE754 with
214 |    a 32-bit int type */
215 | 
216 | union luai_Cast { double l_d; LUA_INT32 l_p[2]; };
217 | 
218 | #if !defined(LUA_IEEEENDIAN)	/* { */
219 | #define LUAI_EXTRAIEEE	\
220 |   static const union luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
221 | #define LUA_IEEEENDIANLOC	(ieeeendian.l_p[1] == 33)
222 | #else
223 | #define LUA_IEEEENDIANLOC	LUA_IEEEENDIAN
224 | #define LUAI_EXTRAIEEE		/* empty */
225 | #endif				/* } */
226 | 
227 | #define lua_number2int32(i,n,t) \
228 |   { LUAI_EXTRAIEEE \
229 |     volatile union luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
230 |     (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; }
231 | 
232 | #define luai_hashnum(i,n)  \
233 |   { volatile union luai_Cast u; u.l_d = (n) + 1.0;  /* avoid -0 */ \
234 |     (i) = u.l_p[0]; (i) += u.l_p[1]; }  /* add double bits for his hash */
235 | 
236 | #define lua_number2int(i,n)		lua_number2int32(i, n, int)
237 | #define lua_number2unsigned(i,n)	lua_number2int32(i, n, lua_Unsigned)
238 | 
239 | /* the trick can be expanded to lua_Integer when it is a 32-bit value */
240 | #if defined(LUA_IEEELL)
241 | #define lua_number2integer(i,n)		lua_number2int32(i, n, lua_Integer)
242 | #endif
243 | 
244 | #endif				/* } */
245 | 
246 | 
247 | /* the following definitions always work, but may be slow */
248 | 
249 | #if !defined(lua_number2int)
250 | #define lua_number2int(i,n)	((i)=(int)(n))
251 | #endif
252 | 
253 | #if !defined(lua_number2integer)
254 | #define lua_number2integer(i,n)	((i)=(lua_Integer)(n))
255 | #endif
256 | 
257 | #if !defined(lua_number2unsigned)	/* { */
258 | /* the following definition assures proper modulo behavior */
259 | #if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
260 | #include <math.h>
261 | #define SUPUNSIGNED	((lua_Number)(~(lua_Unsigned)0) + 1)
262 | #define lua_number2unsigned(i,n)  \
263 | 	((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
264 | #else
265 | #define lua_number2unsigned(i,n)	((i)=(lua_Unsigned)(n))
266 | #endif
267 | #endif				/* } */
268 | 
269 | 
270 | #if !defined(lua_unsigned2number)
271 | /* on several machines, coercion from unsigned to double is slow,
272 |    so it may be worth to avoid */
273 | #define lua_unsigned2number(u)  \
274 |     (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
275 | #endif
276 | 
277 | 
278 | 
279 | #if defined(ltable_c) && !defined(luai_hashnum)
280 | 
281 | #include <float.h>
282 | #include <math.h>
283 | 
284 | #define luai_hashnum(i,n) { int e;  \
285 |   n = l_mathop(frexp)(n, &e) * (lua_Number)(INT_MAX - DBL_MAX_EXP);  \
286 |   lua_number2int(i, n); i += e; }
287 | 
288 | #endif
289 | 
290 | 
291 | 
292 | /*
293 | ** macro to control inclusion of some hard tests on stack reallocation
294 | */
295 | #if !defined(HARDSTACKTESTS)
296 | #define condmovestack(L)	((void)0)
297 | #else
298 | /* realloc stack keeping its size */
299 | #define condmovestack(L)	luaD_reallocstack((L), (L)->stacksize)
300 | #endif
301 | 
302 | #if !defined(HARDMEMTESTS)
303 | #define condchangemem(L)	condmovestack(L)
304 | #else
305 | #define condchangemem(L)  \
306 | 	((void)(!(G(L)->gcrunning) || (luaC_fullgc(L, 0), 1)))
307 | #endif
308 | 
309 | #endif
310 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/ltablib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: ltablib.c,v 1.65.1.2 2014/05/07 16:32:55 roberto Exp $
  3 | ** Library for Table Manipulation
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <limits.h>
  9 | #include <stddef.h>
 10 | 
 11 | #define ltablib_c
 12 | #define LUA_LIB
 13 | 
 14 | #include "lua.h"
 15 | 
 16 | #include "lauxlib.h"
 17 | #include "lualib.h"
 18 | 
 19 | 
 20 | #define aux_getn(L,n)	(luaL_checktype(L, n, LUA_TTABLE), luaL_len(L, n))
 21 | 
 22 | 
 23 | 
 24 | #if defined(LUA_COMPAT_MAXN)
 25 | static int maxn (lua_State *L) {
 26 |   lua_Number max = 0;
 27 |   luaL_checktype(L, 1, LUA_TTABLE);
 28 |   lua_pushnil(L);  /* first key */
 29 |   while (lua_next(L, 1)) {
 30 |     lua_pop(L, 1);  /* remove value */
 31 |     if (lua_type(L, -1) == LUA_TNUMBER) {
 32 |       lua_Number v = lua_tonumber(L, -1);
 33 |       if (v > max) max = v;
 34 |     }
 35 |   }
 36 |   lua_pushnumber(L, max);
 37 |   return 1;
 38 | }
 39 | #endif
 40 | 
 41 | 
 42 | static int tinsert (lua_State *L) {
 43 |   int e = aux_getn(L, 1) + 1;  /* first empty element */
 44 |   int pos;  /* where to insert new element */
 45 |   switch (lua_gettop(L)) {
 46 |     case 2: {  /* called with only 2 arguments */
 47 |       pos = e;  /* insert new element at the end */
 48 |       break;
 49 |     }
 50 |     case 3: {
 51 |       int i;
 52 |       pos = luaL_checkint(L, 2);  /* 2nd argument is the position */
 53 |       luaL_argcheck(L, 1 <= pos && pos <= e, 2, "position out of bounds");
 54 |       for (i = e; i > pos; i--) {  /* move up elements */
 55 |         lua_rawgeti(L, 1, i-1);
 56 |         lua_rawseti(L, 1, i);  /* t[i] = t[i-1] */
 57 |       }
 58 |       break;
 59 |     }
 60 |     default: {
 61 |       return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
 62 |     }
 63 |   }
 64 |   lua_rawseti(L, 1, pos);  /* t[pos] = v */
 65 |   return 0;
 66 | }
 67 | 
 68 | 
 69 | static int tremove (lua_State *L) {
 70 |   int size = aux_getn(L, 1);
 71 |   int pos = luaL_optint(L, 2, size);
 72 |   if (pos != size)  /* validate 'pos' if given */
 73 |     luaL_argcheck(L, 1 <= pos && pos <= size + 1, 1, "position out of bounds");
 74 |   lua_rawgeti(L, 1, pos);  /* result = t[pos] */
 75 |   for ( ; pos < size; pos++) {
 76 |     lua_rawgeti(L, 1, pos+1);
 77 |     lua_rawseti(L, 1, pos);  /* t[pos] = t[pos+1] */
 78 |   }
 79 |   lua_pushnil(L);
 80 |   lua_rawseti(L, 1, pos);  /* t[pos] = nil */
 81 |   return 1;
 82 | }
 83 | 
 84 | 
 85 | static void addfield (lua_State *L, luaL_Buffer *b, int i) {
 86 |   lua_rawgeti(L, 1, i);
 87 |   if (!lua_isstring(L, -1))
 88 |     luaL_error(L, "invalid value (%s) at index %d in table for "
 89 |                   LUA_QL("concat"), luaL_typename(L, -1), i);
 90 |   luaL_addvalue(b);
 91 | }
 92 | 
 93 | 
 94 | static int tconcat (lua_State *L) {
 95 |   luaL_Buffer b;
 96 |   size_t lsep;
 97 |   int i, last;
 98 |   const char *sep = luaL_optlstring(L, 2, "", &lsep);
 99 |   luaL_checktype(L, 1, LUA_TTABLE);
100 |   i = luaL_optint(L, 3, 1);
101 |   last = luaL_opt(L, luaL_checkint, 4, luaL_len(L, 1));
102 |   luaL_buffinit(L, &b);
103 |   for (; i < last; i++) {
104 |     addfield(L, &b, i);
105 |     luaL_addlstring(&b, sep, lsep);
106 |   }
107 |   if (i == last)  /* add last value (if interval was not empty) */
108 |     addfield(L, &b, i);
109 |   luaL_pushresult(&b);
110 |   return 1;
111 | }
112 | 
113 | 
114 | /*
115 | ** {======================================================
116 | ** Pack/unpack
117 | ** =======================================================
118 | */
119 | 
120 | static int pack (lua_State *L) {
121 |   int n = lua_gettop(L);  /* number of elements to pack */
122 |   lua_createtable(L, n, 1);  /* create result table */
123 |   lua_pushinteger(L, n);
124 |   lua_setfield(L, -2, "n");  /* t.n = number of elements */
125 |   if (n > 0) {  /* at least one element? */
126 |     int i;
127 |     lua_pushvalue(L, 1);
128 |     lua_rawseti(L, -2, 1);  /* insert first element */
129 |     lua_replace(L, 1);  /* move table into index 1 */
130 |     for (i = n; i >= 2; i--)  /* assign other elements */
131 |       lua_rawseti(L, 1, i);
132 |   }
133 |   return 1;  /* return table */
134 | }
135 | 
136 | 
137 | static int unpack (lua_State *L) {
138 |   int i, e;
139 |   unsigned int n;
140 |   luaL_checktype(L, 1, LUA_TTABLE);
141 |   i = luaL_optint(L, 2, 1);
142 |   e = luaL_opt(L, luaL_checkint, 3, luaL_len(L, 1));
143 |   if (i > e) return 0;  /* empty range */
144 |   n = (unsigned int)e - (unsigned int)i;  /* number of elements minus 1 */
145 |   if (n > (INT_MAX - 10) || !lua_checkstack(L, ++n))
146 |     return luaL_error(L, "too many results to unpack");
147 |   lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
148 |   while (i++ < e)  /* push arg[i + 1...e] */
149 |     lua_rawgeti(L, 1, i);
150 |   return n;
151 | }
152 | 
153 | /* }====================================================== */
154 | 
155 | 
156 | 
157 | /*
158 | ** {======================================================
159 | ** Quicksort
160 | ** (based on `Algorithms in MODULA-3', Robert Sedgewick;
161 | **  Addison-Wesley, 1993.)
162 | ** =======================================================
163 | */
164 | 
165 | 
166 | static void set2 (lua_State *L, int i, int j) {
167 |   lua_rawseti(L, 1, i);
168 |   lua_rawseti(L, 1, j);
169 | }
170 | 
171 | static int sort_comp (lua_State *L, int a, int b) {
172 |   if (!lua_isnil(L, 2)) {  /* function? */
173 |     int res;
174 |     lua_pushvalue(L, 2);
175 |     lua_pushvalue(L, a-1);  /* -1 to compensate function */
176 |     lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
177 |     lua_call(L, 2, 1);
178 |     res = lua_toboolean(L, -1);
179 |     lua_pop(L, 1);
180 |     return res;
181 |   }
182 |   else  /* a < b? */
183 |     return lua_compare(L, a, b, LUA_OPLT);
184 | }
185 | 
186 | static void auxsort (lua_State *L, int l, int u) {
187 |   while (l < u) {  /* for tail recursion */
188 |     int i, j;
189 |     /* sort elements a[l], a[(l+u)/2] and a[u] */
190 |     lua_rawgeti(L, 1, l);
191 |     lua_rawgeti(L, 1, u);
192 |     if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
193 |       set2(L, l, u);  /* swap a[l] - a[u] */
194 |     else
195 |       lua_pop(L, 2);
196 |     if (u-l == 1) break;  /* only 2 elements */
197 |     i = (l+u)/2;
198 |     lua_rawgeti(L, 1, i);
199 |     lua_rawgeti(L, 1, l);
200 |     if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
201 |       set2(L, i, l);
202 |     else {
203 |       lua_pop(L, 1);  /* remove a[l] */
204 |       lua_rawgeti(L, 1, u);
205 |       if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
206 |         set2(L, i, u);
207 |       else
208 |         lua_pop(L, 2);
209 |     }
210 |     if (u-l == 2) break;  /* only 3 elements */
211 |     lua_rawgeti(L, 1, i);  /* Pivot */
212 |     lua_pushvalue(L, -1);
213 |     lua_rawgeti(L, 1, u-1);
214 |     set2(L, i, u-1);
215 |     /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
216 |     i = l; j = u-1;
217 |     for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
218 |       /* repeat ++i until a[i] >= P */
219 |       while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
220 |         if (i>=u) luaL_error(L, "invalid order function for sorting");
221 |         lua_pop(L, 1);  /* remove a[i] */
222 |       }
223 |       /* repeat --j until a[j] <= P */
224 |       while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
225 |         if (j<=l) luaL_error(L, "invalid order function for sorting");
226 |         lua_pop(L, 1);  /* remove a[j] */
227 |       }
228 |       if (j<i) {
229 |         lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
230 |         break;
231 |       }
232 |       set2(L, i, j);
233 |     }
234 |     lua_rawgeti(L, 1, u-1);
235 |     lua_rawgeti(L, 1, i);
236 |     set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
237 |     /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
238 |     /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
239 |     if (i-l < u-i) {
240 |       j=l; i=i-1; l=i+2;
241 |     }
242 |     else {
243 |       j=i+1; i=u; u=j-2;
244 |     }
245 |     auxsort(L, j, i);  /* call recursively the smaller one */
246 |   }  /* repeat the routine for the larger one */
247 | }
248 | 
249 | static int sort (lua_State *L) {
250 |   int n = aux_getn(L, 1);
251 |   luaL_checkstack(L, 40, "");  /* assume array is smaller than 2^40 */
252 |   if (!lua_isnoneornil(L, 2))  /* is there a 2nd argument? */
253 |     luaL_checktype(L, 2, LUA_TFUNCTION);
254 |   lua_settop(L, 2);  /* make sure there is two arguments */
255 |   auxsort(L, 1, n);
256 |   return 0;
257 | }
258 | 
259 | /* }====================================================== */
260 | 
261 | 
262 | static const luaL_Reg tab_funcs[] = {
263 |   {"concat", tconcat},
264 | #if defined(LUA_COMPAT_MAXN)
265 |   {"maxn", maxn},
266 | #endif
267 |   {"insert", tinsert},
268 |   {"pack", pack},
269 |   {"unpack", unpack},
270 |   {"remove", tremove},
271 |   {"sort", sort},
272 |   {NULL, NULL}
273 | };
274 | 
275 | 
276 | LUAMOD_API int luaopen_table (lua_State *L) {
277 |   luaL_newlib(L, tab_funcs);
278 | #if defined(LUA_COMPAT_UNPACK)
279 |   /* _G.unpack = table.unpack */
280 |   lua_getfield(L, -1, "unpack");
281 |   lua_setglobal(L, "unpack");
282 | #endif
283 |   return 1;
284 | }
285 | 
286 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lobject.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lobject.c,v 2.58.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Some generic functions over Lua objects
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <stdarg.h>
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 11 | 
 12 | #define lobject_c
 13 | #define LUA_CORE
 14 | 
 15 | #include "lua.h"
 16 | 
 17 | #include "lctype.h"
 18 | #include "ldebug.h"
 19 | #include "ldo.h"
 20 | #include "lmem.h"
 21 | #include "lobject.h"
 22 | #include "lstate.h"
 23 | #include "lstring.h"
 24 | #include "lvm.h"
 25 | 
 26 | 
 27 | 
 28 | LUAI_DDEF const TValue luaO_nilobject_ = {NILCONSTANT};
 29 | 
 30 | 
 31 | /*
 32 | ** converts an integer to a "floating point byte", represented as
 33 | ** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
 34 | ** eeeee != 0 and (xxx) otherwise.
 35 | */
 36 | int luaO_int2fb (unsigned int x) {
 37 |   int e = 0;  /* exponent */
 38 |   if (x < 8) return x;
 39 |   while (x >= 0x10) {
 40 |     x = (x+1) >> 1;
 41 |     e++;
 42 |   }
 43 |   return ((e+1) << 3) | (cast_int(x) - 8);
 44 | }
 45 | 
 46 | 
 47 | /* converts back */
 48 | int luaO_fb2int (int x) {
 49 |   int e = (x >> 3) & 0x1f;
 50 |   if (e == 0) return x;
 51 |   else return ((x & 7) + 8) << (e - 1);
 52 | }
 53 | 
 54 | 
 55 | int luaO_ceillog2 (unsigned int x) {
 56 |   static const lu_byte log_2[256] = {
 57 |     0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
 58 |     6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
 59 |     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 60 |     7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
 61 |     8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 62 |     8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 63 |     8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
 64 |     8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
 65 |   };
 66 |   int l = 0;
 67 |   x--;
 68 |   while (x >= 256) { l += 8; x >>= 8; }
 69 |   return l + log_2[x];
 70 | }
 71 | 
 72 | 
 73 | lua_Number luaO_arith (int op, lua_Number v1, lua_Number v2) {
 74 |   switch (op) {
 75 |     case LUA_OPADD: return luai_numadd(NULL, v1, v2);
 76 |     case LUA_OPSUB: return luai_numsub(NULL, v1, v2);
 77 |     case LUA_OPMUL: return luai_nummul(NULL, v1, v2);
 78 |     case LUA_OPDIV: return luai_numdiv(NULL, v1, v2);
 79 |     case LUA_OPMOD: return luai_nummod(NULL, v1, v2);
 80 |     case LUA_OPPOW: return luai_numpow(NULL, v1, v2);
 81 |     case LUA_OPUNM: return luai_numunm(NULL, v1);
 82 |     default: lua_assert(0); return 0;
 83 |   }
 84 | }
 85 | 
 86 | 
 87 | int luaO_hexavalue (int c) {
 88 |   if (lisdigit(c)) return c - '0';
 89 |   else return ltolower(c) - 'a' + 10;
 90 | }
 91 | 
 92 | 
 93 | #if !defined(lua_strx2number)
 94 | 
 95 | #include <math.h>
 96 | 
 97 | 
 98 | static int isneg (const char **s) {
 99 |   if (**s == '-') { (*s)++; return 1; }
100 |   else if (**s == '+') (*s)++;
101 |   return 0;
102 | }
103 | 
104 | 
105 | static lua_Number readhexa (const char **s, lua_Number r, int *count) {
106 |   for (; lisxdigit(cast_uchar(**s)); (*s)++) {  /* read integer part */
107 |     r = (r * cast_num(16.0)) + cast_num(luaO_hexavalue(cast_uchar(**s)));
108 |     (*count)++;
109 |   }
110 |   return r;
111 | }
112 | 
113 | 
114 | /*
115 | ** convert an hexadecimal numeric string to a number, following
116 | ** C99 specification for 'strtod'
117 | */
118 | static lua_Number lua_strx2number (const char *s, char **endptr) {
119 |   lua_Number r = 0.0;
120 |   int e = 0, i = 0;
121 |   int neg = 0;  /* 1 if number is negative */
122 |   *endptr = cast(char *, s);  /* nothing is valid yet */
123 |   while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
124 |   neg = isneg(&s);  /* check signal */
125 |   if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')))  /* check '0x' */
126 |     return 0.0;  /* invalid format (no '0x') */
127 |   s += 2;  /* skip '0x' */
128 |   r = readhexa(&s, r, &i);  /* read integer part */
129 |   if (*s == '.') {
130 |     s++;  /* skip dot */
131 |     r = readhexa(&s, r, &e);  /* read fractional part */
132 |   }
133 |   if (i == 0 && e == 0)
134 |     return 0.0;  /* invalid format (no digit) */
135 |   e *= -4;  /* each fractional digit divides value by 2^-4 */
136 |   *endptr = cast(char *, s);  /* valid up to here */
137 |   if (*s == 'p' || *s == 'P') {  /* exponent part? */
138 |     int exp1 = 0;
139 |     int neg1;
140 |     s++;  /* skip 'p' */
141 |     neg1 = isneg(&s);  /* signal */
142 |     if (!lisdigit(cast_uchar(*s)))
143 |       goto ret;  /* must have at least one digit */
144 |     while (lisdigit(cast_uchar(*s)))  /* read exponent */
145 |       exp1 = exp1 * 10 + *(s++) - '0';
146 |     if (neg1) exp1 = -exp1;
147 |     e += exp1;
148 |   }
149 |   *endptr = cast(char *, s);  /* valid up to here */
150 |  ret:
151 |   if (neg) r = -r;
152 |   return l_mathop(ldexp)(r, e);
153 | }
154 | 
155 | #endif
156 | 
157 | 
158 | int luaO_str2d (const char *s, size_t len, lua_Number *result) {
159 |   char *endptr;
160 |   if (strpbrk(s, "nN"))  /* reject 'inf' and 'nan' */
161 |     return 0;
162 |   else if (strpbrk(s, "xX"))  /* hexa? */
163 |     *result = lua_strx2number(s, &endptr);
164 |   else
165 |     *result = lua_str2number(s, &endptr);
166 |   if (endptr == s) return 0;  /* nothing recognized */
167 |   while (lisspace(cast_uchar(*endptr))) endptr++;
168 |   return (endptr == s + len);  /* OK if no trailing characters */
169 | }
170 | 
171 | 
172 | 
173 | static void pushstr (lua_State *L, const char *str, size_t l) {
174 |   setsvalue2s(L, L->top++, luaS_newlstr(L, str, l));
175 | }
176 | 
177 | 
178 | /* this function handles only `%d', `%c', %f, %p, and `%s' formats */
179 | const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
180 |   int n = 0;
181 |   for (;;) {
182 |     const char *e = strchr(fmt, '%');
183 |     if (e == NULL) break;
184 |     luaD_checkstack(L, 2);  /* fmt + item */
185 |     pushstr(L, fmt, e - fmt);
186 |     switch (*(e+1)) {
187 |       case 's': {
188 |         const char *s = va_arg(argp, char *);
189 |         if (s == NULL) s = "(null)";
190 |         pushstr(L, s, strlen(s));
191 |         break;
192 |       }
193 |       case 'c': {
194 |         char buff;
195 |         buff = cast(char, va_arg(argp, int));
196 |         pushstr(L, &buff, 1);
197 |         break;
198 |       }
199 |       case 'd': {
200 |         setnvalue(L->top++, cast_num(va_arg(argp, int)));
201 |         break;
202 |       }
203 |       case 'f': {
204 |         setnvalue(L->top++, cast_num(va_arg(argp, l_uacNumber)));
205 |         break;
206 |       }
207 |       case 'p': {
208 |         char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
209 |         int l = sprintf(buff, "%p", va_arg(argp, void *));
210 |         pushstr(L, buff, l);
211 |         break;
212 |       }
213 |       case '%': {
214 |         pushstr(L, "%", 1);
215 |         break;
216 |       }
217 |       default: {
218 |         luaG_runerror(L,
219 |             "invalid option " LUA_QL("%%%c") " to " LUA_QL("lua_pushfstring"),
220 |             *(e + 1));
221 |       }
222 |     }
223 |     n += 2;
224 |     fmt = e+2;
225 |   }
226 |   luaD_checkstack(L, 1);
227 |   pushstr(L, fmt, strlen(fmt));
228 |   if (n > 0) luaV_concat(L, n + 1);
229 |   return svalue(L->top - 1);
230 | }
231 | 
232 | 
233 | const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
234 |   const char *msg;
235 |   va_list argp;
236 |   va_start(argp, fmt);
237 |   msg = luaO_pushvfstring(L, fmt, argp);
238 |   va_end(argp);
239 |   return msg;
240 | }
241 | 
242 | 
243 | /* number of chars of a literal string without the ending \0 */
244 | #define LL(x)	(sizeof(x)/sizeof(char) - 1)
245 | 
246 | #define RETS	"..."
247 | #define PRE	"[string \""
248 | #define POS	"\"]"
249 | 
250 | #define addstr(a,b,l)	( memcpy(a,b,(l) * sizeof(char)), a += (l) )
251 | 
252 | void luaO_chunkid (char *out, const char *source, size_t bufflen) {
253 |   size_t l = strlen(source);
254 |   if (*source == '=') {  /* 'literal' source */
255 |     if (l <= bufflen)  /* small enough? */
256 |       memcpy(out, source + 1, l * sizeof(char));
257 |     else {  /* truncate it */
258 |       addstr(out, source + 1, bufflen - 1);
259 |       *out = '\0';
260 |     }
261 |   }
262 |   else if (*source == '@') {  /* file name */
263 |     if (l <= bufflen)  /* small enough? */
264 |       memcpy(out, source + 1, l * sizeof(char));
265 |     else {  /* add '...' before rest of name */
266 |       addstr(out, RETS, LL(RETS));
267 |       bufflen -= LL(RETS);
268 |       memcpy(out, source + 1 + l - bufflen, bufflen * sizeof(char));
269 |     }
270 |   }
271 |   else {  /* string; format as [string "source"] */
272 |     const char *nl = strchr(source, '\n');  /* find first new line (if any) */
273 |     addstr(out, PRE, LL(PRE));  /* add prefix */
274 |     bufflen -= LL(PRE RETS POS) + 1;  /* save space for prefix+suffix+'\0' */
275 |     if (l < bufflen && nl == NULL) {  /* small one-line source? */
276 |       addstr(out, source, l);  /* keep it */
277 |     }
278 |     else {
279 |       if (nl != NULL) l = nl - source;  /* stop at first newline */
280 |       if (l > bufflen) l = bufflen;
281 |       addstr(out, source, l);
282 |       addstr(out, RETS, LL(RETS));
283 |     }
284 |     memcpy(out, POS, (LL(POS) + 1) * sizeof(char));
285 |   }
286 | }
287 | 
288 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lstate.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lstate.c,v 2.99.1.2 2013/11/08 17:45:31 roberto Exp $
  3 | ** Global State
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <stddef.h>
  9 | #include <string.h>
 10 | 
 11 | #define lstate_c
 12 | #define LUA_CORE
 13 | 
 14 | #include "lua.h"
 15 | 
 16 | #include "lapi.h"
 17 | #include "ldebug.h"
 18 | #include "ldo.h"
 19 | #include "lfunc.h"
 20 | #include "lgc.h"
 21 | #include "llex.h"
 22 | #include "lmem.h"
 23 | #include "lstate.h"
 24 | #include "lstring.h"
 25 | #include "ltable.h"
 26 | #include "ltm.h"
 27 | 
 28 | 
 29 | #if !defined(LUAI_GCPAUSE)
 30 | #define LUAI_GCPAUSE	200  /* 200% */
 31 | #endif
 32 | 
 33 | #if !defined(LUAI_GCMAJOR)
 34 | #define LUAI_GCMAJOR	200  /* 200% */
 35 | #endif
 36 | 
 37 | #if !defined(LUAI_GCMUL)
 38 | #define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
 39 | #endif
 40 | 
 41 | 
 42 | #define MEMERRMSG	"not enough memory"
 43 | 
 44 | 
 45 | /*
 46 | ** a macro to help the creation of a unique random seed when a state is
 47 | ** created; the seed is used to randomize hashes.
 48 | */
 49 | #if !defined(luai_makeseed)
 50 | #include <time.h>
 51 | #define luai_makeseed()		cast(unsigned int, time(NULL))
 52 | #endif
 53 | 
 54 | 
 55 | 
 56 | /*
 57 | ** thread state + extra space
 58 | */
 59 | typedef struct LX {
 60 | #if defined(LUAI_EXTRASPACE)
 61 |   char buff[LUAI_EXTRASPACE];
 62 | #endif
 63 |   lua_State l;
 64 | } LX;
 65 | 
 66 | 
 67 | /*
 68 | ** Main thread combines a thread state and the global state
 69 | */
 70 | typedef struct LG {
 71 |   LX l;
 72 |   global_State g;
 73 | } LG;
 74 | 
 75 | 
 76 | 
 77 | #define fromstate(L)	(cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l)))
 78 | 
 79 | 
 80 | /*
 81 | ** Compute an initial seed as random as possible. In ANSI, rely on
 82 | ** Address Space Layout Randomization (if present) to increase
 83 | ** randomness..
 84 | */
 85 | #define addbuff(b,p,e) \
 86 |   { size_t t = cast(size_t, e); \
 87 |     memcpy(buff + p, &t, sizeof(t)); p += sizeof(t); }
 88 | 
 89 | static unsigned int makeseed (lua_State *L) {
 90 |   char buff[4 * sizeof(size_t)];
 91 |   unsigned int h = luai_makeseed();
 92 |   int p = 0;
 93 |   addbuff(buff, p, L);  /* heap variable */
 94 |   addbuff(buff, p, &h);  /* local variable */
 95 |   addbuff(buff, p, luaO_nilobject);  /* global variable */
 96 |   addbuff(buff, p, &lua_newstate);  /* public function */
 97 |   lua_assert(p == sizeof(buff));
 98 |   return luaS_hash(buff, p, h);
 99 | }
100 | 
101 | 
102 | /*
103 | ** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
104 | ** invariant
105 | */
106 | void luaE_setdebt (global_State *g, l_mem debt) {
107 |   g->totalbytes -= (debt - g->GCdebt);
108 |   g->GCdebt = debt;
109 | }
110 | 
111 | 
112 | CallInfo *luaE_extendCI (lua_State *L) {
113 |   CallInfo *ci = luaM_new(L, CallInfo);
114 |   lua_assert(L->ci->next == NULL);
115 |   L->ci->next = ci;
116 |   ci->previous = L->ci;
117 |   ci->next = NULL;
118 |   return ci;
119 | }
120 | 
121 | 
122 | void luaE_freeCI (lua_State *L) {
123 |   CallInfo *ci = L->ci;
124 |   CallInfo *next = ci->next;
125 |   ci->next = NULL;
126 |   while ((ci = next) != NULL) {
127 |     next = ci->next;
128 |     luaM_free(L, ci);
129 |   }
130 | }
131 | 
132 | 
133 | static void stack_init (lua_State *L1, lua_State *L) {
134 |   int i; CallInfo *ci;
135 |   /* initialize stack array */
136 |   L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
137 |   L1->stacksize = BASIC_STACK_SIZE;
138 |   for (i = 0; i < BASIC_STACK_SIZE; i++)
139 |     setnilvalue(L1->stack + i);  /* erase new stack */
140 |   L1->top = L1->stack;
141 |   L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
142 |   /* initialize first ci */
143 |   ci = &L1->base_ci;
144 |   ci->next = ci->previous = NULL;
145 |   ci->callstatus = 0;
146 |   ci->func = L1->top;
147 |   setnilvalue(L1->top++);  /* 'function' entry for this 'ci' */
148 |   ci->top = L1->top + LUA_MINSTACK;
149 |   L1->ci = ci;
150 | }
151 | 
152 | 
153 | static void freestack (lua_State *L) {
154 |   if (L->stack == NULL)
155 |     return;  /* stack not completely built yet */
156 |   L->ci = &L->base_ci;  /* free the entire 'ci' list */
157 |   luaE_freeCI(L);
158 |   luaM_freearray(L, L->stack, L->stacksize);  /* free stack array */
159 | }
160 | 
161 | 
162 | /*
163 | ** Create registry table and its predefined values
164 | */
165 | static void init_registry (lua_State *L, global_State *g) {
166 |   TValue mt;
167 |   /* create registry */
168 |   Table *registry = luaH_new(L);
169 |   sethvalue(L, &g->l_registry, registry);
170 |   luaH_resize(L, registry, LUA_RIDX_LAST, 0);
171 |   /* registry[LUA_RIDX_MAINTHREAD] = L */
172 |   setthvalue(L, &mt, L);
173 |   luaH_setint(L, registry, LUA_RIDX_MAINTHREAD, &mt);
174 |   /* registry[LUA_RIDX_GLOBALS] = table of globals */
175 |   sethvalue(L, &mt, luaH_new(L));
176 |   luaH_setint(L, registry, LUA_RIDX_GLOBALS, &mt);
177 | }
178 | 
179 | 
180 | /*
181 | ** open parts of the state that may cause memory-allocation errors
182 | */
183 | static void f_luaopen (lua_State *L, void *ud) {
184 |   global_State *g = G(L);
185 |   UNUSED(ud);
186 |   stack_init(L, L);  /* init stack */
187 |   init_registry(L, g);
188 |   luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
189 |   luaT_init(L);
190 |   luaX_init(L);
191 |   /* pre-create memory-error message */
192 |   g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
193 |   luaS_fix(g->memerrmsg);  /* it should never be collected */
194 |   g->gcrunning = 1;  /* allow gc */
195 |   g->version = lua_version(NULL);
196 |   luai_userstateopen(L);
197 | }
198 | 
199 | 
200 | /*
201 | ** preinitialize a state with consistent values without allocating
202 | ** any memory (to avoid errors)
203 | */
204 | static void preinit_state (lua_State *L, global_State *g) {
205 |   G(L) = g;
206 |   L->stack = NULL;
207 |   L->ci = NULL;
208 |   L->stacksize = 0;
209 |   L->errorJmp = NULL;
210 |   L->nCcalls = 0;
211 |   L->hook = NULL;
212 |   L->hookmask = 0;
213 |   L->basehookcount = 0;
214 |   L->allowhook = 1;
215 |   resethookcount(L);
216 |   L->openupval = NULL;
217 |   L->nny = 1;
218 |   L->status = LUA_OK;
219 |   L->errfunc = 0;
220 | }
221 | 
222 | 
223 | static void close_state (lua_State *L) {
224 |   global_State *g = G(L);
225 |   luaF_close(L, L->stack);  /* close all upvalues for this thread */
226 |   luaC_freeallobjects(L);  /* collect all objects */
227 |   if (g->version)  /* closing a fully built state? */
228 |     luai_userstateclose(L);
229 |   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
230 |   luaZ_freebuffer(L, &g->buff);
231 |   freestack(L);
232 |   lua_assert(gettotalbytes(g) == sizeof(LG));
233 |   (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0);  /* free main block */
234 | }
235 | 
236 | 
237 | LUA_API lua_State *lua_newthread (lua_State *L) {
238 |   lua_State *L1;
239 |   lua_lock(L);
240 |   luaC_checkGC(L);
241 |   L1 = &luaC_newobj(L, LUA_TTHREAD, sizeof(LX), NULL, offsetof(LX, l))->th;
242 |   setthvalue(L, L->top, L1);
243 |   api_incr_top(L);
244 |   preinit_state(L1, G(L));
245 |   L1->hookmask = L->hookmask;
246 |   L1->basehookcount = L->basehookcount;
247 |   L1->hook = L->hook;
248 |   resethookcount(L1);
249 |   luai_userstatethread(L, L1);
250 |   stack_init(L1, L);  /* init stack */
251 |   lua_unlock(L);
252 |   return L1;
253 | }
254 | 
255 | 
256 | void luaE_freethread (lua_State *L, lua_State *L1) {
257 |   LX *l = fromstate(L1);
258 |   luaF_close(L1, L1->stack);  /* close all upvalues for this thread */
259 |   lua_assert(L1->openupval == NULL);
260 |   luai_userstatefree(L, L1);
261 |   freestack(L1);
262 |   luaM_free(L, l);
263 | }
264 | 
265 | 
266 | LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
267 |   int i;
268 |   lua_State *L;
269 |   global_State *g;
270 |   LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
271 |   if (l == NULL) return NULL;
272 |   L = &l->l.l;
273 |   g = &l->g;
274 |   L->next = NULL;
275 |   L->tt = LUA_TTHREAD;
276 |   g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
277 |   L->marked = luaC_white(g);
278 |   g->gckind = KGC_NORMAL;
279 |   preinit_state(L, g);
280 |   g->frealloc = f;
281 |   g->ud = ud;
282 |   g->mainthread = L;
283 |   g->seed = makeseed(L);
284 |   g->uvhead.u.l.prev = &g->uvhead;
285 |   g->uvhead.u.l.next = &g->uvhead;
286 |   g->gcrunning = 0;  /* no GC while building state */
287 |   g->GCestimate = 0;
288 |   g->strt.size = 0;
289 |   g->strt.nuse = 0;
290 |   g->strt.hash = NULL;
291 |   setnilvalue(&g->l_registry);
292 |   luaZ_initbuffer(L, &g->buff);
293 |   g->panic = NULL;
294 |   g->version = NULL;
295 |   g->gcstate = GCSpause;
296 |   g->allgc = NULL;
297 |   g->finobj = NULL;
298 |   g->tobefnz = NULL;
299 |   g->sweepgc = g->sweepfin = NULL;
300 |   g->gray = g->grayagain = NULL;
301 |   g->weak = g->ephemeron = g->allweak = NULL;
302 |   g->totalbytes = sizeof(LG);
303 |   g->GCdebt = 0;
304 |   g->gcpause = LUAI_GCPAUSE;
305 |   g->gcmajorinc = LUAI_GCMAJOR;
306 |   g->gcstepmul = LUAI_GCMUL;
307 |   for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
308 |   if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
309 |     /* memory allocation error: free partial state */
310 |     close_state(L);
311 |     L = NULL;
312 |   }
313 |   return L;
314 | }
315 | 
316 | 
317 | LUA_API void lua_close (lua_State *L) {
318 |   L = G(L)->mainthread;  /* only the main thread can be closed */
319 |   lua_lock(L);
320 |   close_state(L);
321 | }
322 | 
323 | 
324 | 


--------------------------------------------------------------------------------
/hlua/tests/userdata.rs:
--------------------------------------------------------------------------------
  1 | extern crate hlua;
  2 | 
  3 | #[test]
  4 | fn readwrite() {
  5 |     #[derive(Clone)]
  6 |     struct Foo;
  7 |     impl<'lua, L> hlua::Push<L> for Foo
  8 |     where
  9 |         L: hlua::AsMutLua<'lua>,
 10 |     {
 11 |         type Err = hlua::Void;
 12 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
 13 |             Ok(hlua::push_userdata(self, lua, |_| {}))
 14 |         }
 15 |     }
 16 |     impl<'lua, L> hlua::PushOne<L> for Foo where L: hlua::AsMutLua<'lua> {}
 17 |     impl<'lua, L> hlua::LuaRead<L> for Foo
 18 |     where
 19 |         L: hlua::AsMutLua<'lua>,
 20 |     {
 21 |         fn lua_read_at_position(lua: L, index: i32) -> Result<Foo, L> {
 22 |             let val: Result<hlua::UserdataOnStack<Foo, _>, _> =
 23 |                 hlua::LuaRead::lua_read_at_position(lua, index);
 24 |             val.map(|d| d.clone())
 25 |         }
 26 |     }
 27 | 
 28 |     let mut lua = hlua::Lua::new();
 29 | 
 30 |     lua.set("a", Foo);
 31 |     let _: Foo = lua.get("a").unwrap();
 32 | }
 33 | 
 34 | #[test]
 35 | fn destructor_called() {
 36 |     use std::sync::{Arc, Mutex};
 37 | 
 38 |     let called = Arc::new(Mutex::new(false));
 39 | 
 40 |     struct Foo {
 41 |         called: Arc<Mutex<bool>>,
 42 |     }
 43 | 
 44 |     impl Drop for Foo {
 45 |         fn drop(&mut self) {
 46 |             let mut called = self.called.lock().unwrap();
 47 |             (*called) = true;
 48 |         }
 49 |     }
 50 | 
 51 |     impl<'lua, L> hlua::Push<L> for Foo
 52 |     where
 53 |         L: hlua::AsMutLua<'lua>,
 54 |     {
 55 |         type Err = hlua::Void;
 56 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
 57 |             Ok(hlua::push_userdata(self, lua, |_| {}))
 58 |         }
 59 |     }
 60 |     impl<'lua, L> hlua::PushOne<L> for Foo where L: hlua::AsMutLua<'lua> {}
 61 | 
 62 |     {
 63 |         let mut lua = hlua::Lua::new();
 64 |         lua.set(
 65 |             "a",
 66 |             Foo {
 67 |                 called: called.clone(),
 68 |             },
 69 |         );
 70 |     }
 71 | 
 72 |     let locked = called.lock().unwrap();
 73 |     assert!(*locked);
 74 | }
 75 | 
 76 | #[test]
 77 | fn type_check() {
 78 |     #[derive(Clone)]
 79 |     struct Foo;
 80 |     impl<'lua, L> hlua::Push<L> for Foo
 81 |     where
 82 |         L: hlua::AsMutLua<'lua>,
 83 |     {
 84 |         type Err = hlua::Void;
 85 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
 86 |             Ok(hlua::push_userdata(self, lua, |_| {}))
 87 |         }
 88 |     }
 89 |     impl<'lua, L> hlua::PushOne<L> for Foo where L: hlua::AsMutLua<'lua> {}
 90 |     impl<'lua, L> hlua::LuaRead<L> for Foo
 91 |     where
 92 |         L: hlua::AsMutLua<'lua>,
 93 |     {
 94 |         fn lua_read_at_position(lua: L, index: i32) -> Result<Foo, L> {
 95 |             let val: Result<hlua::UserdataOnStack<Foo, _>, _> =
 96 |                 hlua::LuaRead::lua_read_at_position(lua, index);
 97 |             val.map(|d| d.clone())
 98 |         }
 99 |     }
100 | 
101 |     #[derive(Clone)]
102 |     struct Bar;
103 |     impl<'lua, L> hlua::Push<L> for Bar
104 |     where
105 |         L: hlua::AsMutLua<'lua>,
106 |     {
107 |         type Err = hlua::Void;
108 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
109 |             Ok(hlua::push_userdata(self, lua, |_| {}))
110 |         }
111 |     }
112 |     impl<'lua, L> hlua::PushOne<L> for Bar where L: hlua::AsMutLua<'lua> {}
113 |     impl<'lua, L> hlua::LuaRead<L> for Bar
114 |     where
115 |         L: hlua::AsMutLua<'lua>,
116 |     {
117 |         fn lua_read_at_position(lua: L, index: i32) -> Result<Bar, L> {
118 |             let val: Result<hlua::UserdataOnStack<Bar, _>, _> =
119 |                 hlua::LuaRead::lua_read_at_position(lua, index);
120 |             val.map(|d| d.clone())
121 |         }
122 |     }
123 | 
124 |     let mut lua = hlua::Lua::new();
125 | 
126 |     lua.set("a", Foo);
127 | 
128 |     let x: Option<Bar> = lua.get("a");
129 |     assert!(x.is_none())
130 | }
131 | 
132 | #[test]
133 | fn metatables() {
134 |     #[derive(Clone)]
135 |     struct Foo;
136 |     impl<'lua, L> hlua::Push<L> for Foo
137 |     where
138 |         L: hlua::AsMutLua<'lua>,
139 |     {
140 |         type Err = hlua::Void;
141 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
142 |             Ok(hlua::push_userdata(self, lua, |mut table| {
143 |                 table.set(
144 |                     "__index".to_string(),
145 |                     vec![("test".to_string(), hlua::function0(|| 5))],
146 |                 );
147 |             }))
148 |         }
149 |     }
150 |     impl<'lua, L> hlua::PushOne<L> for Foo where L: hlua::AsMutLua<'lua> {}
151 | 
152 |     let mut lua = hlua::Lua::new();
153 | 
154 |     lua.set("a", Foo);
155 | 
156 |     let x: i32 = lua.execute("return a.test()").unwrap();
157 |     assert_eq!(x, 5);
158 | }
159 | 
160 | #[test]
161 | fn multiple_userdata() {
162 |     #[derive(Clone)]
163 |     struct Integer(u32);
164 |     impl<'lua, L> hlua::Push<L> for Integer
165 |     where
166 |         L: hlua::AsMutLua<'lua>,
167 |     {
168 |         type Err = hlua::Void;
169 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
170 |             Ok(hlua::push_userdata(self, lua, |_| {}))
171 |         }
172 |     }
173 |     impl<'lua, L> hlua::PushOne<L> for Integer where L: hlua::AsMutLua<'lua> {}
174 |     impl<'lua, L> hlua::LuaRead<L> for Integer
175 |     where
176 |         L: hlua::AsMutLua<'lua>,
177 |     {
178 |         fn lua_read_at_position(lua: L, index: i32) -> Result<Integer, L> {
179 |             let val: Result<hlua::UserdataOnStack<Integer, _>, _> =
180 |                 hlua::LuaRead::lua_read_at_position(lua, index);
181 |             val.map(|d| d.clone())
182 |         }
183 |     }
184 | 
185 |     #[derive(Debug, Clone, PartialEq, Eq)]
186 |     struct BigInteger(u32, u32, u32, u32);
187 |     impl<'lua, L> hlua::Push<L> for BigInteger
188 |     where
189 |         L: hlua::AsMutLua<'lua>,
190 |     {
191 |         type Err = hlua::Void;
192 |         fn push_to_lua(self, lua: L) -> Result<hlua::PushGuard<L>, (hlua::Void, L)> {
193 |             Ok(hlua::push_userdata(self, lua, |_| {}))
194 |         }
195 |     }
196 |     impl<'lua, L> hlua::PushOne<L> for BigInteger where L: hlua::AsMutLua<'lua> {}
197 |     impl<'lua, L> hlua::LuaRead<L> for BigInteger
198 |     where
199 |         L: hlua::AsMutLua<'lua>,
200 |     {
201 |         fn lua_read_at_position(lua: L, index: i32) -> Result<BigInteger, L> {
202 |             let val: Result<hlua::UserdataOnStack<BigInteger, _>, _> =
203 |                 hlua::LuaRead::lua_read_at_position(lua, index);
204 |             val.map(|d| d.clone())
205 |         }
206 |     }
207 | 
208 |     let axpy_float = |a: f64, x: Integer, y: Integer| a * x.0 as f64 + y.0 as f64;
209 |     let axpy_float_2 = |a: f64, x: Integer, y: f64| a * x.0 as f64 + y;
210 |     let broadcast_mul =
211 |         |k: Integer, v: BigInteger| BigInteger(k.0 * v.0, k.0 * v.1, k.0 * v.2, k.0 * v.3);
212 |     let collapse = |a: f32, k: Integer, v: BigInteger| {
213 |         (k.0 * v.0) as f32 * a
214 |             + (k.0 * v.1) as f32 * a
215 |             + (k.0 * v.2) as f32 * a
216 |             + (k.0 * v.3) as f32 * a
217 |     };
218 |     let mut lua = hlua::Lua::new();
219 | 
220 |     let big_integer = BigInteger(531, 246, 1, 953);
221 |     lua.set("a", Integer(19));
222 |     lua.set("b", Integer(114));
223 |     lua.set("c", Integer(96));
224 |     lua.set("d", Integer(313));
225 |     lua.set("v", big_integer.clone());
226 |     lua.set(
227 |         "add",
228 |         hlua::function2(|x: Integer, y: Integer| Integer(x.0 + y.0)),
229 |     );
230 |     lua.set(
231 |         "axpy",
232 |         hlua::function3(|a: Integer, x: Integer, y: Integer| Integer(a.0 * x.0 + y.0)),
233 |     );
234 |     lua.set("axpy_float", hlua::function3(&axpy_float));
235 |     lua.set("axpy_float_2", hlua::function3(&axpy_float_2));
236 |     lua.set("broadcast_mul", hlua::function2(&broadcast_mul));
237 |     lua.set("collapse", hlua::function3(&collapse));
238 | 
239 |     assert_eq!(
240 |         lua.execute::<Integer>("return add(a, b)").unwrap().0,
241 |         19 + 114
242 |     );
243 |     assert_eq!(
244 |         lua.execute::<Integer>("return add(b, c)").unwrap().0,
245 |         114 + 96
246 |     );
247 |     assert_eq!(
248 |         lua.execute::<Integer>("return add(c, d)").unwrap().0,
249 |         96 + 313
250 |     );
251 |     assert_eq!(
252 |         lua.execute::<Integer>("return axpy(a, b, c)").unwrap().0,
253 |         19 * 114 + 96
254 |     );
255 |     assert_eq!(
256 |         lua.execute::<Integer>("return axpy(b, c, d)").unwrap().0,
257 |         114 * 96 + 313
258 |     );
259 |     assert_eq!(
260 |         lua.execute::<f64>("return axpy_float(2.5, c, d)").unwrap(),
261 |         axpy_float(2.5, Integer(96), Integer(313))
262 |     );
263 |     assert_eq!(
264 |         lua.execute::<BigInteger>("return broadcast_mul(a, v)")
265 |             .unwrap(),
266 |         broadcast_mul(Integer(19), big_integer.clone())
267 |     );
268 |     assert_eq!(
269 |         lua.execute::<BigInteger>("return broadcast_mul(b, v)")
270 |             .unwrap(),
271 |         broadcast_mul(Integer(114), big_integer.clone())
272 |     );
273 |     assert_eq!(
274 |         lua.execute::<f32>("return collapse(19.25, c, v)").unwrap(),
275 |         collapse(19.25, Integer(96), big_integer.clone())
276 |     );
277 | }
278 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/loslib.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: loslib.c,v 1.40.1.1 2013/04/12 18:48:47 roberto Exp $
  3 | ** Standard Operating System library
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | 
  8 | #include <errno.h>
  9 | #include <locale.h>
 10 | #include <stdlib.h>
 11 | #include <string.h>
 12 | #include <time.h>
 13 | 
 14 | #define loslib_c
 15 | #define LUA_LIB
 16 | 
 17 | #include "lua.h"
 18 | 
 19 | #include "lauxlib.h"
 20 | #include "lualib.h"
 21 | 
 22 | 
 23 | /*
 24 | ** list of valid conversion specifiers for the 'strftime' function
 25 | */
 26 | #if !defined(LUA_STRFTIMEOPTIONS)
 27 | 
 28 | #if !defined(LUA_USE_POSIX)
 29 | #define LUA_STRFTIMEOPTIONS	{ "aAbBcdHIjmMpSUwWxXyYz%", "" }
 30 | #else
 31 | #define LUA_STRFTIMEOPTIONS \
 32 | 	{ "aAbBcCdDeFgGhHIjmMnprRStTuUVwWxXyYzZ%", "" \
 33 | 	  "", "E", "cCxXyY",  \
 34 | 	  "O", "deHImMSuUVwWy" }
 35 | #endif
 36 | 
 37 | #endif
 38 | 
 39 | 
 40 | 
 41 | /*
 42 | ** By default, Lua uses tmpnam except when POSIX is available, where it
 43 | ** uses mkstemp.
 44 | */
 45 | #if defined(LUA_USE_MKSTEMP)
 46 | #include <unistd.h>
 47 | #define LUA_TMPNAMBUFSIZE	32
 48 | #define lua_tmpnam(b,e) { \
 49 |         strcpy(b, "/tmp/lua_XXXXXX"); \
 50 |         e = mkstemp(b); \
 51 |         if (e != -1) close(e); \
 52 |         e = (e == -1); }
 53 | 
 54 | #elif !defined(lua_tmpnam)
 55 | 
 56 | #define LUA_TMPNAMBUFSIZE	L_tmpnam
 57 | #define lua_tmpnam(b,e)		{ e = (tmpnam(b) == NULL); }
 58 | 
 59 | #endif
 60 | 
 61 | 
 62 | /*
 63 | ** By default, Lua uses gmtime/localtime, except when POSIX is available,
 64 | ** where it uses gmtime_r/localtime_r
 65 | */
 66 | #if defined(LUA_USE_GMTIME_R)
 67 | 
 68 | #define l_gmtime(t,r)		gmtime_r(t,r)
 69 | #define l_localtime(t,r)	localtime_r(t,r)
 70 | 
 71 | #elif !defined(l_gmtime)
 72 | 
 73 | #define l_gmtime(t,r)		((void)r, gmtime(t))
 74 | #define l_localtime(t,r)  	((void)r, localtime(t))
 75 | 
 76 | #endif
 77 | 
 78 | 
 79 | 
 80 | static int os_execute (lua_State *L) {
 81 |   const char *cmd = luaL_optstring(L, 1, NULL);
 82 |   int stat = system(cmd);
 83 |   if (cmd != NULL)
 84 |     return luaL_execresult(L, stat);
 85 |   else {
 86 |     lua_pushboolean(L, stat);  /* true if there is a shell */
 87 |     return 1;
 88 |   }
 89 | }
 90 | 
 91 | 
 92 | static int os_remove (lua_State *L) {
 93 |   const char *filename = luaL_checkstring(L, 1);
 94 |   return luaL_fileresult(L, remove(filename) == 0, filename);
 95 | }
 96 | 
 97 | 
 98 | static int os_rename (lua_State *L) {
 99 |   const char *fromname = luaL_checkstring(L, 1);
100 |   const char *toname = luaL_checkstring(L, 2);
101 |   return luaL_fileresult(L, rename(fromname, toname) == 0, NULL);
102 | }
103 | 
104 | 
105 | static int os_tmpname (lua_State *L) {
106 |   char buff[LUA_TMPNAMBUFSIZE];
107 |   int err;
108 |   lua_tmpnam(buff, err);
109 |   if (err)
110 |     return luaL_error(L, "unable to generate a unique filename");
111 |   lua_pushstring(L, buff);
112 |   return 1;
113 | }
114 | 
115 | 
116 | static int os_getenv (lua_State *L) {
117 |   lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
118 |   return 1;
119 | }
120 | 
121 | 
122 | static int os_clock (lua_State *L) {
123 |   lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
124 |   return 1;
125 | }
126 | 
127 | 
128 | /*
129 | ** {======================================================
130 | ** Time/Date operations
131 | ** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
132 | **   wday=%w+1, yday=%j, isdst=? }
133 | ** =======================================================
134 | */
135 | 
136 | static void setfield (lua_State *L, const char *key, int value) {
137 |   lua_pushinteger(L, value);
138 |   lua_setfield(L, -2, key);
139 | }
140 | 
141 | static void setboolfield (lua_State *L, const char *key, int value) {
142 |   if (value < 0)  /* undefined? */
143 |     return;  /* does not set field */
144 |   lua_pushboolean(L, value);
145 |   lua_setfield(L, -2, key);
146 | }
147 | 
148 | static int getboolfield (lua_State *L, const char *key) {
149 |   int res;
150 |   lua_getfield(L, -1, key);
151 |   res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
152 |   lua_pop(L, 1);
153 |   return res;
154 | }
155 | 
156 | 
157 | static int getfield (lua_State *L, const char *key, int d) {
158 |   int res, isnum;
159 |   lua_getfield(L, -1, key);
160 |   res = (int)lua_tointegerx(L, -1, &isnum);
161 |   if (!isnum) {
162 |     if (d < 0)
163 |       return luaL_error(L, "field " LUA_QS " missing in date table", key);
164 |     res = d;
165 |   }
166 |   lua_pop(L, 1);
167 |   return res;
168 | }
169 | 
170 | 
171 | static const char *checkoption (lua_State *L, const char *conv, char *buff) {
172 |   static const char *const options[] = LUA_STRFTIMEOPTIONS;
173 |   unsigned int i;
174 |   for (i = 0; i < sizeof(options)/sizeof(options[0]); i += 2) {
175 |     if (*conv != '\0' && strchr(options[i], *conv) != NULL) {
176 |       buff[1] = *conv;
177 |       if (*options[i + 1] == '\0') {  /* one-char conversion specifier? */
178 |         buff[2] = '\0';  /* end buffer */
179 |         return conv + 1;
180 |       }
181 |       else if (*(conv + 1) != '\0' &&
182 |                strchr(options[i + 1], *(conv + 1)) != NULL) {
183 |         buff[2] = *(conv + 1);  /* valid two-char conversion specifier */
184 |         buff[3] = '\0';  /* end buffer */
185 |         return conv + 2;
186 |       }
187 |     }
188 |   }
189 |   luaL_argerror(L, 1,
190 |     lua_pushfstring(L, "invalid conversion specifier '%%%s'", conv));
191 |   return conv;  /* to avoid warnings */
192 | }
193 | 
194 | 
195 | static int os_date (lua_State *L) {
196 |   const char *s = luaL_optstring(L, 1, "%c");
197 |   time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
198 |   struct tm tmr, *stm;
199 |   if (*s == '!') {  /* UTC? */
200 |     stm = l_gmtime(&t, &tmr);
201 |     s++;  /* skip `!' */
202 |   }
203 |   else
204 |     stm = l_localtime(&t, &tmr);
205 |   if (stm == NULL)  /* invalid date? */
206 |     lua_pushnil(L);
207 |   else if (strcmp(s, "*t") == 0) {
208 |     lua_createtable(L, 0, 9);  /* 9 = number of fields */
209 |     setfield(L, "sec", stm->tm_sec);
210 |     setfield(L, "min", stm->tm_min);
211 |     setfield(L, "hour", stm->tm_hour);
212 |     setfield(L, "day", stm->tm_mday);
213 |     setfield(L, "month", stm->tm_mon+1);
214 |     setfield(L, "year", stm->tm_year+1900);
215 |     setfield(L, "wday", stm->tm_wday+1);
216 |     setfield(L, "yday", stm->tm_yday+1);
217 |     setboolfield(L, "isdst", stm->tm_isdst);
218 |   }
219 |   else {
220 |     char cc[4];
221 |     luaL_Buffer b;
222 |     cc[0] = '%';
223 |     luaL_buffinit(L, &b);
224 |     while (*s) {
225 |       if (*s != '%')  /* no conversion specifier? */
226 |         luaL_addchar(&b, *s++);
227 |       else {
228 |         size_t reslen;
229 |         char buff[200];  /* should be big enough for any conversion result */
230 |         s = checkoption(L, s + 1, cc);
231 |         reslen = strftime(buff, sizeof(buff), cc, stm);
232 |         luaL_addlstring(&b, buff, reslen);
233 |       }
234 |     }
235 |     luaL_pushresult(&b);
236 |   }
237 |   return 1;
238 | }
239 | 
240 | 
241 | static int os_time (lua_State *L) {
242 |   time_t t;
243 |   if (lua_isnoneornil(L, 1))  /* called without args? */
244 |     t = time(NULL);  /* get current time */
245 |   else {
246 |     struct tm ts;
247 |     luaL_checktype(L, 1, LUA_TTABLE);
248 |     lua_settop(L, 1);  /* make sure table is at the top */
249 |     ts.tm_sec = getfield(L, "sec", 0);
250 |     ts.tm_min = getfield(L, "min", 0);
251 |     ts.tm_hour = getfield(L, "hour", 12);
252 |     ts.tm_mday = getfield(L, "day", -1);
253 |     ts.tm_mon = getfield(L, "month", -1) - 1;
254 |     ts.tm_year = getfield(L, "year", -1) - 1900;
255 |     ts.tm_isdst = getboolfield(L, "isdst");
256 |     t = mktime(&ts);
257 |   }
258 |   if (t == (time_t)(-1))
259 |     lua_pushnil(L);
260 |   else
261 |     lua_pushnumber(L, (lua_Number)t);
262 |   return 1;
263 | }
264 | 
265 | 
266 | static int os_difftime (lua_State *L) {
267 |   lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
268 |                              (time_t)(luaL_optnumber(L, 2, 0))));
269 |   return 1;
270 | }
271 | 
272 | /* }====================================================== */
273 | 
274 | 
275 | static int os_setlocale (lua_State *L) {
276 |   static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
277 |                       LC_NUMERIC, LC_TIME};
278 |   static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
279 |      "numeric", "time", NULL};
280 |   const char *l = luaL_optstring(L, 1, NULL);
281 |   int op = luaL_checkoption(L, 2, "all", catnames);
282 |   lua_pushstring(L, setlocale(cat[op], l));
283 |   return 1;
284 | }
285 | 
286 | 
287 | static int os_exit (lua_State *L) {
288 |   int status;
289 |   if (lua_isboolean(L, 1))
290 |     status = (lua_toboolean(L, 1) ? EXIT_SUCCESS : EXIT_FAILURE);
291 |   else
292 |     status = luaL_optint(L, 1, EXIT_SUCCESS);
293 |   if (lua_toboolean(L, 2))
294 |     lua_close(L);
295 |   if (L) exit(status);  /* 'if' to avoid warnings for unreachable 'return' */
296 |   return 0;
297 | }
298 | 
299 | 
300 | static const luaL_Reg syslib[] = {
301 |   {"clock",     os_clock},
302 |   {"date",      os_date},
303 |   {"difftime",  os_difftime},
304 |   {"execute",   os_execute},
305 |   {"exit",      os_exit},
306 |   {"getenv",    os_getenv},
307 |   {"remove",    os_remove},
308 |   {"rename",    os_rename},
309 |   {"setlocale", os_setlocale},
310 |   {"time",      os_time},
311 |   {"tmpname",   os_tmpname},
312 |   {NULL, NULL}
313 | };
314 | 
315 | /* }====================================================== */
316 | 
317 | 
318 | 
319 | LUAMOD_API int luaopen_os (lua_State *L) {
320 |   luaL_newlib(L, syslib);
321 |   return 1;
322 | }
323 | 
324 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/lopcodes.h:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: lopcodes.h,v 1.142.1.2 2014/10/20 18:32:09 roberto Exp $
  3 | ** Opcodes for Lua virtual machine
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #ifndef lopcodes_h
  8 | #define lopcodes_h
  9 | 
 10 | #include "llimits.h"
 11 | 
 12 | 
 13 | /*===========================================================================
 14 |   We assume that instructions are unsigned numbers.
 15 |   All instructions have an opcode in the first 6 bits.
 16 |   Instructions can have the following fields:
 17 | 	`A' : 8 bits
 18 | 	`B' : 9 bits
 19 | 	`C' : 9 bits
 20 | 	'Ax' : 26 bits ('A', 'B', and 'C' together)
 21 | 	`Bx' : 18 bits (`B' and `C' together)
 22 | 	`sBx' : signed Bx
 23 | 
 24 |   A signed argument is represented in excess K; that is, the number
 25 |   value is the unsigned value minus K. K is exactly the maximum value
 26 |   for that argument (so that -max is represented by 0, and +max is
 27 |   represented by 2*max), which is half the maximum for the corresponding
 28 |   unsigned argument.
 29 | ===========================================================================*/
 30 | 
 31 | 
 32 | enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
 33 | 
 34 | 
 35 | /*
 36 | ** size and position of opcode arguments.
 37 | */
 38 | #define SIZE_C		9
 39 | #define SIZE_B		9
 40 | #define SIZE_Bx		(SIZE_C + SIZE_B)
 41 | #define SIZE_A		8
 42 | #define SIZE_Ax		(SIZE_C + SIZE_B + SIZE_A)
 43 | 
 44 | #define SIZE_OP		6
 45 | 
 46 | #define POS_OP		0
 47 | #define POS_A		(POS_OP + SIZE_OP)
 48 | #define POS_C		(POS_A + SIZE_A)
 49 | #define POS_B		(POS_C + SIZE_C)
 50 | #define POS_Bx		POS_C
 51 | #define POS_Ax		POS_A
 52 | 
 53 | 
 54 | /*
 55 | ** limits for opcode arguments.
 56 | ** we use (signed) int to manipulate most arguments,
 57 | ** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
 58 | */
 59 | #if SIZE_Bx < LUAI_BITSINT-1
 60 | #define MAXARG_Bx        ((1<<SIZE_Bx)-1)
 61 | #define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
 62 | #else
 63 | #define MAXARG_Bx        MAX_INT
 64 | #define MAXARG_sBx        MAX_INT
 65 | #endif
 66 | 
 67 | #if SIZE_Ax < LUAI_BITSINT-1
 68 | #define MAXARG_Ax	((1<<SIZE_Ax)-1)
 69 | #else
 70 | #define MAXARG_Ax	MAX_INT
 71 | #endif
 72 | 
 73 | 
 74 | #define MAXARG_A        ((1<<SIZE_A)-1)
 75 | #define MAXARG_B        ((1<<SIZE_B)-1)
 76 | #define MAXARG_C        ((1<<SIZE_C)-1)
 77 | 
 78 | 
 79 | /* creates a mask with `n' 1 bits at position `p' */
 80 | #define MASK1(n,p)	((~((~(Instruction)0)<<(n)))<<(p))
 81 | 
 82 | /* creates a mask with `n' 0 bits at position `p' */
 83 | #define MASK0(n,p)	(~MASK1(n,p))
 84 | 
 85 | /*
 86 | ** the following macros help to manipulate instructions
 87 | */
 88 | 
 89 | #define GET_OPCODE(i)	(cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
 90 | #define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
 91 | 		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
 92 | 
 93 | #define getarg(i,pos,size)	(cast(int, ((i)>>pos) & MASK1(size,0)))
 94 | #define setarg(i,v,pos,size)	((i) = (((i)&MASK0(size,pos)) | \
 95 |                 ((cast(Instruction, v)<<pos)&MASK1(size,pos))))
 96 | 
 97 | #define GETARG_A(i)	getarg(i, POS_A, SIZE_A)
 98 | #define SETARG_A(i,v)	setarg(i, v, POS_A, SIZE_A)
 99 | 
100 | #define GETARG_B(i)	getarg(i, POS_B, SIZE_B)
101 | #define SETARG_B(i,v)	setarg(i, v, POS_B, SIZE_B)
102 | 
103 | #define GETARG_C(i)	getarg(i, POS_C, SIZE_C)
104 | #define SETARG_C(i,v)	setarg(i, v, POS_C, SIZE_C)
105 | 
106 | #define GETARG_Bx(i)	getarg(i, POS_Bx, SIZE_Bx)
107 | #define SETARG_Bx(i,v)	setarg(i, v, POS_Bx, SIZE_Bx)
108 | 
109 | #define GETARG_Ax(i)	getarg(i, POS_Ax, SIZE_Ax)
110 | #define SETARG_Ax(i,v)	setarg(i, v, POS_Ax, SIZE_Ax)
111 | 
112 | #define GETARG_sBx(i)	(GETARG_Bx(i)-MAXARG_sBx)
113 | #define SETARG_sBx(i,b)	SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
114 | 
115 | 
116 | #define CREATE_ABC(o,a,b,c)	((cast(Instruction, o)<<POS_OP) \
117 | 			| (cast(Instruction, a)<<POS_A) \
118 | 			| (cast(Instruction, b)<<POS_B) \
119 | 			| (cast(Instruction, c)<<POS_C))
120 | 
121 | #define CREATE_ABx(o,a,bc)	((cast(Instruction, o)<<POS_OP) \
122 | 			| (cast(Instruction, a)<<POS_A) \
123 | 			| (cast(Instruction, bc)<<POS_Bx))
124 | 
125 | #define CREATE_Ax(o,a)		((cast(Instruction, o)<<POS_OP) \
126 | 			| (cast(Instruction, a)<<POS_Ax))
127 | 
128 | 
129 | /*
130 | ** Macros to operate RK indices
131 | */
132 | 
133 | /* this bit 1 means constant (0 means register) */
134 | #define BITRK		(1 << (SIZE_B - 1))
135 | 
136 | /* test whether value is a constant */
137 | #define ISK(x)		((x) & BITRK)
138 | 
139 | /* gets the index of the constant */
140 | #define INDEXK(r)	((int)(r) & ~BITRK)
141 | 
142 | #define MAXINDEXRK	(BITRK - 1)
143 | 
144 | /* code a constant index as a RK value */
145 | #define RKASK(x)	((x) | BITRK)
146 | 
147 | 
148 | /*
149 | ** invalid register that fits in 8 bits
150 | */
151 | #define NO_REG		MAXARG_A
152 | 
153 | 
154 | /*
155 | ** R(x) - register
156 | ** Kst(x) - constant (in constant table)
157 | ** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
158 | */
159 | 
160 | 
161 | /*
162 | ** grep "ORDER OP" if you change these enums
163 | */
164 | 
165 | typedef enum {
166 | /*----------------------------------------------------------------------
167 | name		args	description
168 | ------------------------------------------------------------------------*/
169 | OP_MOVE,/*	A B	R(A) := R(B)					*/
170 | OP_LOADK,/*	A Bx	R(A) := Kst(Bx)					*/
171 | OP_LOADKX,/*	A 	R(A) := Kst(extra arg)				*/
172 | OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
173 | OP_LOADNIL,/*	A B	R(A), R(A+1), ..., R(A+B) := nil		*/
174 | OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
175 | 
176 | OP_GETTABUP,/*	A B C	R(A) := UpValue[B][RK(C)]			*/
177 | OP_GETTABLE,/*	A B C	R(A) := R(B)[RK(C)]				*/
178 | 
179 | OP_SETTABUP,/*	A B C	UpValue[A][RK(B)] := RK(C)			*/
180 | OP_SETUPVAL,/*	A B	UpValue[B] := R(A)				*/
181 | OP_SETTABLE,/*	A B C	R(A)[RK(B)] := RK(C)				*/
182 | 
183 | OP_NEWTABLE,/*	A B C	R(A) := {} (size = B,C)				*/
184 | 
185 | OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C)]		*/
186 | 
187 | OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
188 | OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
189 | OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
190 | OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
191 | OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
192 | OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
193 | OP_UNM,/*	A B	R(A) := -R(B)					*/
194 | OP_NOT,/*	A B	R(A) := not R(B)				*/
195 | OP_LEN,/*	A B	R(A) := length of R(B)				*/
196 | 
197 | OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
198 | 
199 | OP_JMP,/*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A - 1)	*/
200 | OP_EQ,/*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
201 | OP_LT,/*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++		*/
202 | OP_LE,/*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++		*/
203 | 
204 | OP_TEST,/*	A C	if not (R(A) <=> C) then pc++			*/
205 | OP_TESTSET,/*	A B C	if (R(B) <=> C) then R(A) := R(B) else pc++	*/
206 | 
207 | OP_CALL,/*	A B C	R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
208 | OP_TAILCALL,/*	A B C	return R(A)(R(A+1), ... ,R(A+B-1))		*/
209 | OP_RETURN,/*	A B	return R(A), ... ,R(A+B-2)	(see note)	*/
210 | 
211 | OP_FORLOOP,/*	A sBx	R(A)+=R(A+2);
212 | 			if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
213 | OP_FORPREP,/*	A sBx	R(A)-=R(A+2); pc+=sBx				*/
214 | 
215 | OP_TFORCALL,/*	A C	R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));	*/
216 | OP_TFORLOOP,/*	A sBx	if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
217 | 
218 | OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
219 | 
220 | OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx])			*/
221 | 
222 | OP_VARARG,/*	A B	R(A), R(A+1), ..., R(A+B-2) = vararg		*/
223 | 
224 | OP_EXTRAARG/*	Ax	extra (larger) argument for previous opcode	*/
225 | } OpCode;
226 | 
227 | 
228 | #define NUM_OPCODES	(cast(int, OP_EXTRAARG) + 1)
229 | 
230 | 
231 | 
232 | /*===========================================================================
233 |   Notes:
234 |   (*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then `top' is
235 |   set to last_result+1, so next open instruction (OP_CALL, OP_RETURN,
236 |   OP_SETLIST) may use `top'.
237 | 
238 |   (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
239 |   set top (like in OP_CALL with C == 0).
240 | 
241 |   (*) In OP_RETURN, if (B == 0) then return up to `top'.
242 | 
243 |   (*) In OP_SETLIST, if (B == 0) then B = `top'; if (C == 0) then next
244 |   'instruction' is EXTRAARG(real C).
245 | 
246 |   (*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.
247 | 
248 |   (*) For comparisons, A specifies what condition the test should accept
249 |   (true or false).
250 | 
251 |   (*) All `skips' (pc++) assume that next instruction is a jump.
252 | 
253 | ===========================================================================*/
254 | 
255 | 
256 | /*
257 | ** masks for instruction properties. The format is:
258 | ** bits 0-1: op mode
259 | ** bits 2-3: C arg mode
260 | ** bits 4-5: B arg mode
261 | ** bit 6: instruction set register A
262 | ** bit 7: operator is a test (next instruction must be a jump)
263 | */
264 | 
265 | enum OpArgMask {
266 |   OpArgN,  /* argument is not used */
267 |   OpArgU,  /* argument is used */
268 |   OpArgR,  /* argument is a register or a jump offset */
269 |   OpArgK   /* argument is a constant or register/constant */
270 | };
271 | 
272 | LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES];
273 | 
274 | #define getOpMode(m)	(cast(enum OpMode, luaP_opmodes[m] & 3))
275 | #define getBMode(m)	(cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
276 | #define getCMode(m)	(cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
277 | #define testAMode(m)	(luaP_opmodes[m] & (1 << 6))
278 | #define testTMode(m)	(luaP_opmodes[m] & (1 << 7))
279 | 
280 | 
281 | LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
282 | 
283 | 
284 | /* number of list items to accumulate before a SETLIST instruction */
285 | #define LFIELDS_PER_FLUSH	50
286 | 
287 | 
288 | #endif
289 | 


--------------------------------------------------------------------------------
/lua52-sys/lua/src/luac.c:
--------------------------------------------------------------------------------
  1 | /*
  2 | ** $Id: luac.c,v 1.69 2011/11/29 17:46:33 lhf Exp $
  3 | ** Lua compiler (saves bytecodes to files; also list bytecodes)
  4 | ** See Copyright Notice in lua.h
  5 | */
  6 | 
  7 | #include <errno.h>
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 11 | 
 12 | #define luac_c
 13 | #define LUA_CORE
 14 | 
 15 | #include "lua.h"
 16 | #include "lauxlib.h"
 17 | 
 18 | #include "lobject.h"
 19 | #include "lstate.h"
 20 | #include "lundump.h"
 21 | 
 22 | static void PrintFunction(const Proto* f, int full);
 23 | #define luaU_print	PrintFunction
 24 | 
 25 | #define PROGNAME	"luac"		/* default program name */
 26 | #define OUTPUT		PROGNAME ".out"	/* default output file */
 27 | 
 28 | static int listing=0;			/* list bytecodes? */
 29 | static int dumping=1;			/* dump bytecodes? */
 30 | static int stripping=0;			/* strip debug information? */
 31 | static char Output[]={ OUTPUT };	/* default output file name */
 32 | static const char* output=Output;	/* actual output file name */
 33 | static const char* progname=PROGNAME;	/* actual program name */
 34 | 
 35 | static void fatal(const char* message)
 36 | {
 37 |  fprintf(stderr,"%s: %s\n",progname,message);
 38 |  exit(EXIT_FAILURE);
 39 | }
 40 | 
 41 | static void cannot(const char* what)
 42 | {
 43 |  fprintf(stderr,"%s: cannot %s %s: %s\n",progname,what,output,strerror(errno));
 44 |  exit(EXIT_FAILURE);
 45 | }
 46 | 
 47 | static void usage(const char* message)
 48 | {
 49 |  if (*message=='-')
 50 |   fprintf(stderr,"%s: unrecognized option " LUA_QS "\n",progname,message);
 51 |  else
 52 |   fprintf(stderr,"%s: %s\n",progname,message);
 53 |  fprintf(stderr,
 54 |   "usage: %s [options] [filenames]\n"
 55 |   "Available options are:\n"
 56 |   "  -l       list (use -l -l for full listing)\n"
 57 |   "  -o name  output to file " LUA_QL("name") " (default is \"%s\")\n"
 58 |   "  -p       parse only\n"
 59 |   "  -s       strip debug information\n"
 60 |   "  -v       show version information\n"
 61 |   "  --       stop handling options\n"
 62 |   "  -        stop handling options and process stdin\n"
 63 |   ,progname,Output);
 64 |  exit(EXIT_FAILURE);
 65 | }
 66 | 
 67 | #define IS(s)	(strcmp(argv[i],s)==0)
 68 | 
 69 | static int doargs(int argc, char* argv[])
 70 | {
 71 |  int i;
 72 |  int version=0;
 73 |  if (argv[0]!=NULL && *argv[0]!=0) progname=argv[0];
 74 |  for (i=1; i<argc; i++)
 75 |  {
 76 |   if (*argv[i]!='-')			/* end of options; keep it */
 77 |    break;
 78 |   else if (IS("--"))			/* end of options; skip it */
 79 |   {
 80 |    ++i;
 81 |    if (version) ++version;
 82 |    break;
 83 |   }
 84 |   else if (IS("-"))			/* end of options; use stdin */
 85 |    break;
 86 |   else if (IS("-l"))			/* list */
 87 |    ++listing;
 88 |   else if (IS("-o"))			/* output file */
 89 |   {
 90 |    output=argv[++i];
 91 |    if (output==NULL || *output==0 || (*output=='-' && output[1]!=0))
 92 |     usage(LUA_QL("-o") " needs argument");
 93 |    if (IS("-")) output=NULL;
 94 |   }
 95 |   else if (IS("-p"))			/* parse only */
 96 |    dumping=0;
 97 |   else if (IS("-s"))			/* strip debug information */
 98 |    stripping=1;
 99 |   else if (IS("-v"))			/* show version */
100 |    ++version;
101 |   else					/* unknown option */
102 |    usage(argv[i]);
103 |  }
104 |  if (i==argc && (listing || !dumping))
105 |  {
106 |   dumping=0;
107 |   argv[--i]=Output;
108 |  }
109 |  if (version)
110 |  {
111 |   printf("%s\n",LUA_COPYRIGHT);
112 |   if (version==argc-1) exit(EXIT_SUCCESS);
113 |  }
114 |  return i;
115 | }
116 | 
117 | #define FUNCTION "(function()end)();"
118 | 
119 | static const char* reader(lua_State *L, void *ud, size_t *size)
120 | {
121 |  UNUSED(L);
122 |  if ((*(int*)ud)--)
123 |  {
124 |   *size=sizeof(FUNCTION)-1;
125 |   return FUNCTION;
126 |  }
127 |  else
128 |  {
129 |   *size=0;
130 |   return NULL;
131 |  }
132 | }
133 | 
134 | #define toproto(L,i) getproto(L->top+(i))
135 | 
136 | static const Proto* combine(lua_State* L, int n)
137 | {
138 |  if (n==1)
139 |   return toproto(L,-1);
140 |  else
141 |  {
142 |   Proto* f;
143 |   int i=n;
144 |   if (lua_load(L,reader,&i,"=(" PROGNAME ")",NULL)!=LUA_OK) fatal(lua_tostring(L,-1));
145 |   f=toproto(L,-1);
146 |   for (i=0; i<n; i++)
147 |   {
148 |    f->p[i]=toproto(L,i-n-1);
149 |    if (f->p[i]->sizeupvalues>0) f->p[i]->upvalues[0].instack=0;
150 |   }
151 |   f->sizelineinfo=0;
152 |   return f;
153 |  }
154 | }
155 | 
156 | static int writer(lua_State* L, const void* p, size_t size, void* u)
157 | {
158 |  UNUSED(L);
159 |  return (fwrite(p,size,1,(FILE*)u)!=1) && (size!=0);
160 | }
161 | 
162 | static int pmain(lua_State* L)
163 | {
164 |  int argc=(int)lua_tointeger(L,1);
165 |  char** argv=(char**)lua_touserdata(L,2);
166 |  const Proto* f;
167 |  int i;
168 |  if (!lua_checkstack(L,argc)) fatal("too many input files");
169 |  for (i=0; i<argc; i++)
170 |  {
171 |   const char* filename=IS("-") ? NULL : argv[i];
172 |   if (luaL_loadfile(L,filename)!=LUA_OK) fatal(lua_tostring(L,-1));
173 |  }
174 |  f=combine(L,argc);
175 |  if (listing) luaU_print(f,listing>1);
176 |  if (dumping)
177 |  {
178 |   FILE* D= (output==NULL) ? stdout : fopen(output,"wb");
179 |   if (D==NULL) cannot("open");
180 |   lua_lock(L);
181 |   luaU_dump(L,f,writer,D,stripping);
182 |   lua_unlock(L);
183 |   if (ferror(D)) cannot("write");
184 |   if (fclose(D)) cannot("close");
185 |  }
186 |  return 0;
187 | }
188 | 
189 | int main(int argc, char* argv[])
190 | {
191 |  lua_State* L;
192 |  int i=doargs(argc,argv);
193 |  argc-=i; argv+=i;
194 |  if (argc<=0) usage("no input files given");
195 |  L=luaL_newstate();
196 |  if (L==NULL) fatal("cannot create state: not enough memory");
197 |  lua_pushcfunction(L,&pmain);
198 |  lua_pushinteger(L,argc);
199 |  lua_pushlightuserdata(L,argv);
200 |  if (lua_pcall(L,2,0,0)!=LUA_OK) fatal(lua_tostring(L,-1));
201 |  lua_close(L);
202 |  return EXIT_SUCCESS;
203 | }
204 | 
205 | /*
206 | ** $Id: print.c,v 1.69 2013/07/04 01:03:46 lhf Exp $
207 | ** print bytecodes
208 | ** See Copyright Notice in lua.h
209 | */
210 | 
211 | #include <ctype.h>
212 | #include <stdio.h>
213 | 
214 | #define luac_c
215 | #define LUA_CORE
216 | 
217 | #include "ldebug.h"
218 | #include "lobject.h"
219 | #include "lopcodes.h"
220 | 
221 | #define VOID(p)		((const void*)(p))
222 | 
223 | static void PrintString(const TString* ts)
224 | {
225 |  const char* s=getstr(ts);
226 |  size_t i,n=ts->tsv.len;
227 |  printf("%c",'"');
228 |  for (i=0; i<n; i++)
229 |  {
230 |   int c=(int)(unsigned char)s[i];
231 |   switch (c)
232 |   {
233 |    case '"':  printf("\\\""); break;
234 |    case '\\': printf("\\\\"); break;
235 |    case '\a': printf("\\a"); break;
236 |    case '\b': printf("\\b"); break;
237 |    case '\f': printf("\\f"); break;
238 |    case '\n': printf("\\n"); break;
239 |    case '\r': printf("\\r"); break;
240 |    case '\t': printf("\\t"); break;
241 |    case '\v': printf("\\v"); break;
242 |    default:	if (isprint(c))
243 |    			printf("%c",c);
244 | 		else
245 | 			printf("\\%03d",c);
246 |   }
247 |  }
248 |  printf("%c",'"');
249 | }
250 | 
251 | static void PrintConstant(const Proto* f, int i)
252 | {
253 |  const TValue* o=&f->k[i];
254 |  switch (ttypenv(o))
255 |  {
256 |   case LUA_TNIL:
257 | 	printf("nil");
258 | 	break;
259 |   case LUA_TBOOLEAN:
260 | 	printf(bvalue(o) ? "true" : "false");
261 | 	break;
262 |   case LUA_TNUMBER:
263 | 	printf(LUA_NUMBER_FMT,nvalue(o));
264 | 	break;
265 |   case LUA_TSTRING:
266 | 	PrintString(rawtsvalue(o));
267 | 	break;
268 |   default:				/* cannot happen */
269 | 	printf("? type=%d",ttype(o));
270 | 	break;
271 |  }
272 | }
273 | 
274 | #define UPVALNAME(x) ((f->upvalues[x].name) ? getstr(f->upvalues[x].name) : "-")
275 | #define MYK(x)		(-1-(x))
276 | 
277 | static void PrintCode(const Proto* f)
278 | {
279 |  const Instruction* code=f->code;
280 |  int pc,n=f->sizecode;
281 |  for (pc=0; pc<n; pc++)
282 |  {
283 |   Instruction i=code[pc];
284 |   OpCode o=GET_OPCODE(i);
285 |   int a=GETARG_A(i);
286 |   int b=GETARG_B(i);
287 |   int c=GETARG_C(i);
288 |   int ax=GETARG_Ax(i);
289 |   int bx=GETARG_Bx(i);
290 |   int sbx=GETARG_sBx(i);
291 |   int line=getfuncline(f,pc);
292 |   printf("\t%d\t",pc+1);
293 |   if (line>0) printf("[%d]\t",line); else printf("[-]\t");
294 |   printf("%-9s\t",luaP_opnames[o]);
295 |   switch (getOpMode(o))
296 |   {
297 |    case iABC:
298 |     printf("%d",a);
299 |     if (getBMode(o)!=OpArgN) printf(" %d",ISK(b) ? (MYK(INDEXK(b))) : b);
300 |     if (getCMode(o)!=OpArgN) printf(" %d",ISK(c) ? (MYK(INDEXK(c))) : c);
301 |     break;
302 |    case iABx:
303 |     printf("%d",a);
304 |     if (getBMode(o)==OpArgK) printf(" %d",MYK(bx));
305 |     if (getBMode(o)==OpArgU) printf(" %d",bx);
306 |     break;
307 |    case iAsBx:
308 |     printf("%d %d",a,sbx);
309 |     break;
310 |    case iAx:
311 |     printf("%d",MYK(ax));
312 |     break;
313 |   }
314 |   switch (o)
315 |   {
316 |    case OP_LOADK:
317 |     printf("\t; "); PrintConstant(f,bx);
318 |     break;
319 |    case OP_GETUPVAL:
320 |    case OP_SETUPVAL:
321 |     printf("\t; %s",UPVALNAME(b));
322 |     break;
323 |    case OP_GETTABUP:
324 |     printf("\t; %s",UPVALNAME(b));
325 |     if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
326 |     break;
327 |    case OP_SETTABUP:
328 |     printf("\t; %s",UPVALNAME(a));
329 |     if (ISK(b)) { printf(" "); PrintConstant(f,INDEXK(b)); }
330 |     if (ISK(c)) { printf(" "); PrintConstant(f,INDEXK(c)); }
331 |     break;
332 |    case OP_GETTABLE:
333 |    case OP_SELF:
334 |     if (ISK(c)) { printf("\t; "); PrintConstant(f,INDEXK(c)); }
335 |     break;
336 |    case OP_SETTABLE:
337 |    case OP_ADD:
338 |    case OP_SUB:
339 |    case OP_MUL:
340 |    case OP_DIV:
341 |    case OP_POW:
342 |    case OP_EQ:
343 |    case OP_LT:
344 |    case OP_LE:
345 |     if (ISK(b) || ISK(c))
346 |     {
347 |      printf("\t; ");
348 |      if (ISK(b)) PrintConstant(f,INDEXK(b)); else printf("-");
349 |      printf(" ");
350 |      if (ISK(c)) PrintConstant(f,INDEXK(c)); else printf("-");
351 |     }
352 |     break;
353 |    case OP_JMP:
354 |    case OP_FORLOOP:
355 |    case OP_FORPREP:
356 |    case OP_TFORLOOP:
357 |     printf("\t; to %d",sbx+pc+2);
358 |     break;
359 |    case OP_CLOSURE:
360 |     printf("\t; %p",VOID(f->p[bx]));
361 |     break;
362 |    case OP_SETLIST:
363 |     if (c==0) printf("\t; %d",(int)code[++pc]); else printf("\t; %d",c);
364 |     break;
365 |    case OP_EXTRAARG:
366 |     printf("\t; "); PrintConstant(f,ax);
367 |     break;
368 |    default:
369 |     break;
370 |   }
371 |   printf("\n");
372 |  }
373 | }
374 | 
375 | #define SS(x)	((x==1)?"":"s")
376 | #define S(x)	(int)(x),SS(x)
377 | 
378 | static void PrintHeader(const Proto* f)
379 | {
380 |  const char* s=f->source ? getstr(f->source) : "=?";
381 |  if (*s=='@' || *s=='=')
382 |   s++;
383 |  else if (*s==LUA_SIGNATURE[0])
384 |   s="(bstring)";
385 |  else
386 |   s="(string)";
387 |  printf("\n%s <%s:%d,%d> (%d instruction%s at %p)\n",
388 |  	(f->linedefined==0)?"main":"function",s,
389 | 	f->linedefined,f->lastlinedefined,
390 | 	S(f->sizecode),VOID(f));
391 |  printf("%d%s param%s, %d slot%s, %d upvalue%s, ",
392 | 	(int)(f->numparams),f->is_vararg?"+":"",SS(f->numparams),
393 | 	S(f->maxstacksize),S(f->sizeupvalues));
394 |  printf("%d local%s, %d constant%s, %d function%s\n",
395 | 	S(f->sizelocvars),S(f->sizek),S(f->sizep));
396 | }
397 | 
398 | static void PrintDebug(const Proto* f)
399 | {
400 |  int i,n;
401 |  n=f->sizek;
402 |  printf("constants (%d) for %p:\n",n,VOID(f));
403 |  for (i=0; i<n; i++)
404 |  {
405 |   printf("\t%d\t",i+1);
406 |   PrintConstant(f,i);
407 |   printf("\n");
408 |  }
409 |  n=f->sizelocvars;
410 |  printf("locals (%d) for %p:\n",n,VOID(f));
411 |  for (i=0; i<n; i++)
412 |  {
413 |   printf("\t%d\t%s\t%d\t%d\n",
414 |   i,getstr(f->locvars[i].varname),f->locvars[i].startpc+1,f->locvars[i].endpc+1);
415 |  }
416 |  n=f->sizeupvalues;
417 |  printf("upvalues (%d) for %p:\n",n,VOID(f));
418 |  for (i=0; i<n; i++)
419 |  {
420 |   printf("\t%d\t%s\t%d\t%d\n",
421 |   i,UPVALNAME(i),f->upvalues[i].instack,f->upvalues[i].idx);
422 |  }
423 | }
424 | 
425 | static void PrintFunction(const Proto* f, int full)
426 | {
427 |  int i,n=f->sizep;
428 |  PrintHeader(f);
429 |  PrintCode(f);
430 |  if (full) PrintDebug(f);
431 |  for (i=0; i<n; i++) PrintFunction(f->p[i],full);
432 | }
433 | 


--------------------------------------------------------------------------------