mirrors/Nim
1
0
Fork 0
mirror of https://github.com/nim-lang/Nim.git synced 2026-07-14 21:20:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #467 from fowlmouth/patch-9

Browse Source 
use proper types in lua
This commit is contained in:
Araq
2013-06-06 14:18:55 -07:00
parent ce378d8984 463267ce12
commit b92c87e2ec
3 changed files with 241 additions and 308 deletions
Download Patch File Download Diff File Expand all files Collapse all files

183
lib/wrappers/lua/lauxlib.nim
View File

@@ -26,9 +26,9 @@ import
proc pushstring*(L: PState, s: string) proc pushstring*(L: PState, s: string)
# compatibilty macros # compatibilty macros
proc getn*(L: PState, n: int): int proc getn*(L: PState, n: cint): cint
# calls lua_objlen # calls lua_objlen
proc setn*(L: PState, t, n: int) proc setn*(L: PState, t, n: cint)
# does nothing! # does nothing!
type type
Treg*{.final.} = object Treg*{.final.} = object
@@ -37,58 +37,45 @@ type
Preg* = ptr Treg Preg* = ptr Treg
proc openlib*(L: PState, libname: cstring, lr: Preg, nup: int){.cdecl,
dynlib: lua.LIB_NAME, importc: "luaL_openlib".} {.push callConv: cdecl, dynlib: lua.LIB_NAME.}
proc register*(L: PState, libname: cstring, lr: Preg){.cdecl, {.push importc: "luaL_$1".}
dynlib: lua.LIB_NAME, importc: "luaL_register".}
proc getmetafield*(L: PState, obj: int, e: cstring): int{.cdecl, proc openlib*(L: PState, libname: cstring, lr: Preg, nup: cint)
dynlib: lua.LIB_NAME, importc: "luaL_getmetafield".} proc register*(L: PState, libname: cstring, lr: Preg)
proc callmeta*(L: PState, obj: int, e: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_callmeta".} proc getmetafield*(L: PState, obj: cint, e: cstring): cint
proc typerror*(L: PState, narg: int, tname: cstring): int{.cdecl, proc callmeta*(L: PState, obj: cint, e: cstring): cint
dynlib: LIB_NAME, importc: "luaL_typerror".} proc typerror*(L: PState, narg: cint, tname: cstring): cint
proc argerror*(L: PState, numarg: int, extramsg: cstring): int{.cdecl, proc argerror*(L: PState, numarg: cint, extramsg: cstring): cint
dynlib: LIB_NAME, importc: "luaL_argerror".} proc checklstring*(L: PState, numArg: cint, len: ptr int): cstring
proc checklstring*(L: PState, numArg: int, len: ptr int): cstring{.cdecl, proc optlstring*(L: PState, numArg: cint, def: cstring, len: ptr cint): cstring
dynlib: LIB_NAME, importc: "luaL_checklstring".} proc checknumber*(L: PState, numArg: cint): Number
proc optlstring*(L: PState, numArg: int, def: cstring, len: ptr int): cstring{. proc optnumber*(L: PState, nArg: cint, def: Number): Number
cdecl, dynlib: LIB_NAME, importc: "luaL_optlstring".} proc checkinteger*(L: PState, numArg: cint): Integer
proc checknumber*(L: PState, numArg: int): Number{.cdecl, proc optinteger*(L: PState, nArg: cint, def: Integer): Integer
dynlib: LIB_NAME, importc: "luaL_checknumber".} proc checkstack*(L: PState, sz: cint, msg: cstring)
proc optnumber*(L: PState, nArg: int, def: Number): Number{.cdecl, proc checktype*(L: PState, narg, t: cint)
dynlib: LIB_NAME, importc: "luaL_optnumber".}
proc checkinteger*(L: PState, numArg: int): Integer{.cdecl, proc checkany*(L: PState, narg: cint)
dynlib: LIB_NAME, importc: "luaL_checkinteger".} proc newmetatable*(L: PState, tname: cstring): cint
proc optinteger*(L: PState, nArg: int, def: Integer): Integer{.
cdecl, dynlib: LIB_NAME, importc: "luaL_optinteger".} proc checkudata*(L: PState, ud: cint, tname: cstring): Pointer
proc checkstack*(L: PState, sz: int, msg: cstring){.cdecl, proc where*(L: PState, lvl: cint)
dynlib: LIB_NAME, importc: "luaL_checkstack".} proc error*(L: PState, fmt: cstring): cint{.varargs.}
proc checktype*(L: PState, narg, t: int){.cdecl, dynlib: LIB_NAME, proc checkoption*(L: PState, narg: cint, def: cstring, lst: cstringArray): cint
importc: "luaL_checktype".}
proc checkany*(L: PState, narg: int){.cdecl, dynlib: LIB_NAME, proc unref*(L: PState, t, theref: cint)
importc: "luaL_checkany".} proc loadfile*(L: PState, filename: cstring): cint
proc newmetatable*(L: PState, tname: cstring): int{.cdecl, proc loadbuffer*(L: PState, buff: cstring, size: cint, name: cstring): cint
dynlib: LIB_NAME, importc: "luaL_newmetatable".} proc loadstring*(L: PState, s: cstring): cint
proc checkudata*(L: PState, ud: int, tname: cstring): Pointer{.cdecl, proc newstate*(): PState
dynlib: LIB_NAME, importc: "luaL_checkudata".}
proc where*(L: PState, lvl: int){.cdecl, dynlib: LIB_NAME, {.pop.}
importc: "luaL_where".} proc reference*(L: PState, t: cint): cint{.importc: "luaL_ref".}
proc error*(L: PState, fmt: cstring): int{.cdecl, varargs,
dynlib: LIB_NAME, importc: "luaL_error".} {.pop.}
proc checkoption*(L: PState, narg: int, def: cstring, lst: cstringArray): int{.
cdecl, dynlib: LIB_NAME, importc: "luaL_checkoption".}
proc reference*(L: PState, t: int): int{.cdecl, dynlib: LIB_NAME,
importc: "luaL_ref".}
proc unref*(L: PState, t, theref: int){.cdecl, dynlib: LIB_NAME,
importc: "luaL_unref".}
proc loadfile*(L: PState, filename: cstring): int{.cdecl,
dynlib: LIB_NAME, importc: "luaL_loadfile".}
proc loadbuffer*(L: PState, buff: cstring, size: int, name: cstring): int{.
cdecl, dynlib: LIB_NAME, importc: "luaL_loadbuffer".}
proc loadstring*(L: PState, s: cstring): int{.cdecl, dynlib: LIB_NAME,
importc: "luaL_loadstring".}
proc newstate*(): PState{.cdecl, dynlib: LIB_NAME,
importc: "luaL_newstate".}
proc open*(): PState proc open*(): PState
# compatibility; moved from unit lua to lauxlib because it needs luaL_newstate # compatibility; moved from unit lua to lauxlib because it needs luaL_newstate
# #
@@ -96,15 +83,15 @@ proc open*(): PState
#** some useful macros #** some useful macros
#** =============================================================== #** ===============================================================
# #
proc argcheck*(L: PState, cond: bool, numarg: int, extramsg: cstring) proc argcheck*(L: PState, cond: bool, numarg: cint, extramsg: cstring)
proc checkstring*(L: PState, n: int): cstring proc checkstring*(L: PState, n: cint): cstring
proc optstring*(L: PState, n: int, d: cstring): cstring proc optstring*(L: PState, n: cint, d: cstring): cstring
proc checkint*(L: PState, n: int): int proc checkint*(L: PState, n: cint): cint
proc checklong*(L: PState, n: int): int32 proc checklong*(L: PState, n: cint): clong
proc optint*(L: PState, n: int, d: float64): int proc optint*(L: PState, n: cint, d: float64): cint
proc optlong*(L: PState, n: int, d: float64): int32 proc optlong*(L: PState, n: cint, d: float64): clong
proc dofile*(L: PState, filename: cstring): int proc dofile*(L: PState, filename: cstring): cint
proc dostring*(L: PState, str: cstring): int proc dostring*(L: PState, str: cstring): cint
proc getmetatable*(L: PState, tname: cstring) proc getmetatable*(L: PState, tname: cstring)
# not translated: # not translated:
# #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) # #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
@@ -119,7 +106,7 @@ const # note: this is just arbitrary, as it related to t
type type
Buffer*{.final.} = object Buffer*{.final.} = object
p*: cstring # current position in buffer p*: cstring # current position in buffer
lvl*: int # number of strings in the stack (level) lvl*: cint # number of strings in the stack (level)
L*: PState L*: PState
buffer*: array[0..BUFFERSIZE - 1, Char] # warning: see note above about LUAL_BUFFERSIZE buffer*: array[0..BUFFERSIZE - 1, Char] # warning: see note above about LUAL_BUFFERSIZE
@@ -130,80 +117,76 @@ proc addchar*(B: PBuffer, c: Char)
# compatibility only (alias for luaL_addchar) # compatibility only (alias for luaL_addchar)
proc putchar*(B: PBuffer, c: Char) proc putchar*(B: PBuffer, c: Char)
# warning: see note above about LUAL_BUFFERSIZE # warning: see note above about LUAL_BUFFERSIZE
proc addsize*(B: PBuffer, n: int) proc addsize*(B: PBuffer, n: cint)
proc buffinit*(L: PState, B: PBuffer){.cdecl, dynlib: LIB_NAME,
importc: "luaL_buffinit".} {.push callConv: cdecl, dynlib: lua.LIB_NAME, importc: "luaL_$1".}
proc prepbuffer*(B: PBuffer): cstring{.cdecl, dynlib: LIB_NAME, proc buffinit*(L: PState, B: PBuffer)
importc: "luaL_prepbuffer".} proc prepbuffer*(B: PBuffer): cstring
proc addlstring*(B: PBuffer, s: cstring, L: int){.cdecl, proc addlstring*(B: PBuffer, s: cstring, L: cint)
dynlib: LIB_NAME, importc: "luaL_addlstring".} proc addstring*(B: PBuffer, s: cstring)
proc addstring*(B: PBuffer, s: cstring){.cdecl, dynlib: LIB_NAME, proc addvalue*(B: PBuffer)
importc: "luaL_addstring".} proc pushresult*(B: PBuffer)
proc addvalue*(B: PBuffer){.cdecl, dynlib: LIB_NAME, proc gsub*(L: PState, s, p, r: cstring): cstring
importc: "luaL_addvalue".} proc findtable*(L: PState, idx: cint, fname: cstring, szhint: cint): cstring
proc pushresult*(B: PBuffer){.cdecl, dynlib: LIB_NAME,
importc: "luaL_pushresult".}
proc gsub*(L: PState, s, p, r: cstring): cstring{.cdecl,
dynlib: LIB_NAME, importc: "luaL_gsub".}
proc findtable*(L: PState, idx: int, fname: cstring, szhint: int): cstring{.
cdecl, dynlib: LIB_NAME, importc: "luaL_findtable".}
# compatibility with ref system # compatibility with ref system
# pre-defined references # pre-defined references
{.pop.}
const const
NOREF* = - 2 NOREF* = - 2
REFNIL* = - 1 REFNIL* = - 1
proc unref*(L: PState, theref: int) proc unref*(L: PState, theref: cint)
proc getref*(L: PState, theref: int) proc getref*(L: PState, theref: cint)
# #
#** Compatibility macros and functions #** Compatibility macros and functions
# #
# implementation # implementation
proc pushstring(L: PState, s: string) = proc pushstring(L: PState, s: string) =
pushlstring(L, cstring(s), len(s)) pushlstring(L, cstring(s), s.len.cint)
proc getn(L: PState, n: int): int = proc getn(L: PState, n: cint): cint =
Result = objlen(L, n) Result = objlen(L, n)
proc setn(L: PState, t, n: int) = proc setn(L: PState, t, n: cint) =
# does nothing as this operation is deprecated # does nothing as this operation is deprecated
nil nil
proc open(): PState = proc open(): PState =
Result = newstate() Result = newstate()
proc dofile(L: PState, filename: cstring): int = proc dofile(L: PState, filename: cstring): cint =
Result = loadfile(L, filename) Result = loadfile(L, filename)
if Result == 0: Result = pcall(L, 0, MULTRET, 0) if Result == 0: Result = pcall(L, 0, MULTRET, 0)
proc dostring(L: PState, str: cstring): int = proc dostring(L: PState, str: cstring): cint =
Result = loadstring(L, str) Result = loadstring(L, str)
if Result == 0: Result = pcall(L, 0, MULTRET, 0) if Result == 0: Result = pcall(L, 0, MULTRET, 0)
proc getmetatable(L: PState, tname: cstring) = proc getmetatable(L: PState, tname: cstring) =
getfield(L, REGISTRYINDEX, tname) getfield(L, REGISTRYINDEX, tname)
proc argcheck(L: PState, cond: bool, numarg: int, extramsg: cstring) = proc argcheck(L: PState, cond: bool, numarg: cint, extramsg: cstring) =
if not cond: if not cond:
discard argerror(L, numarg, extramsg) discard argerror(L, numarg, extramsg)
proc checkstring(L: PState, n: int): cstring = proc checkstring(L: PState, n: cint): cstring =
Result = checklstring(L, n, nil) Result = checklstring(L, n, nil)
proc optstring(L: PState, n: int, d: cstring): cstring = proc optstring(L: PState, n: cint, d: cstring): cstring =
Result = optlstring(L, n, d, nil) Result = optlstring(L, n, d, nil)
proc checkint(L: PState, n: int): int = proc checkint(L: PState, n: cint): cint =
Result = toInt(checknumber(L, n)) Result = cint(checknumber(L, n))
proc checklong(L: PState, n: int): int32 = proc checklong(L: PState, n: cint): clong =
Result = int32(ToInt(checknumber(L, n))) Result = int32(ToInt(checknumber(L, n)))
proc optint(L: PState, n: int, d: float64): int = proc optint(L: PState, n: cint, d: float64): cint =
Result = int(ToInt(optnumber(L, n, d))) Result = optnumber(L, n, d).cint
proc optlong(L: PState, n: int, d: float64): int32 = proc optlong(L: PState, n: cint, d: float64): clong =
Result = int32(ToInt(optnumber(L, n, d))) Result = int32(ToInt(optnumber(L, n, d)))
proc addchar(B: PBuffer, c: Char) = proc addchar(B: PBuffer, c: Char) =
@@ -215,11 +198,11 @@ proc addchar(B: PBuffer, c: Char) =
proc putchar(B: PBuffer, c: Char) = proc putchar(B: PBuffer, c: Char) =
addchar(B, c) addchar(B, c)
proc addsize(B: PBuffer, n: int) = proc addsize(B: PBuffer, n: cint) =
B.p = cast[cstring](cast[int](B.p) + n) B.p = cast[cstring](cast[int](B.p) + n)
proc unref(L: PState, theref: int) = proc unref(L: PState, theref: cint) =
unref(L, REGISTRYINDEX, theref) unref(L, REGISTRYINDEX, theref)
proc getref(L: PState, theref: int) = proc getref(L: PState, theref: cint) =
rawgeti(L, REGISTRYINDEX, theref) rawgeti(L, REGISTRYINDEX, theref)

324
lib/wrappers/lua/lua.nim
View File

@@ -51,16 +51,16 @@ when defined(useLuajit):
else: else:
when defined(MACOSX): when defined(MACOSX):
const const
NAME* = "liblua(|5.2|5.1|5.0).dylib" NAME* = "liblua(|5.1|5.0).dylib"
LIB_NAME* = "liblua(|5.2|5.1|5.0).dylib" LIB_NAME* = "liblua(|5.1|5.0).dylib"
elif defined(UNIX): elif defined(UNIX):
const const
NAME* = "liblua(|5.2|5.1|5.0).so(|.0)" NAME* = "liblua(|5.1|5.0).so(|.0)"
LIB_NAME* = "liblua(|5.2|5.1|5.0).so(|.0)" LIB_NAME* = "liblua(|5.1|5.0).so(|.0)"
else: else:
const const
NAME* = "lua(|5.2|5.1|5.0).dll" NAME* = "lua(|5.1|5.0).dll"
LIB_NAME* = "lua(|5.2|5.1|5.0).dll" LIB_NAME* = "lua(|5.1|5.0).dll"
const const
VERSION* = "Lua 5.1" VERSION* = "Lua 5.1"
@@ -76,7 +76,7 @@ const
ENVIRONINDEX* = - 10001 ENVIRONINDEX* = - 10001
GLOBALSINDEX* = - 10002 GLOBALSINDEX* = - 10002
proc upvalueindex*(I: int): int proc upvalueindex*(I: cint): cint
const # thread status; 0 is OK const # thread status; 0 is OK
constYIELD* = 1 constYIELD* = 1
ERRRUN* = 2 ERRRUN* = 2
@@ -86,16 +86,16 @@ const # thread status; 0 is OK
type type
PState* = Pointer PState* = Pointer
CFunction* = proc (L: PState): int{.cdecl.} CFunction* = proc (L: PState): cint{.cdecl.}
# #
#** functions that read/write blocks when loading/dumping Lua chunks #** functions that read/write blocks when loading/dumping Lua chunks
# #
type type
Reader* = proc (L: PState, ud: Pointer, sz: ptr int): cstring{.cdecl.} Reader* = proc (L: PState, ud: Pointer, sz: ptr cint): cstring{.cdecl.}
Writer* = proc (L: PState, p: Pointer, sz: int, ud: Pointer): int{.cdecl.} Writer* = proc (L: PState, p: Pointer, sz: cint, ud: Pointer): cint{.cdecl.}
Alloc* = proc (ud, theptr: Pointer, osize, nsize: int){.cdecl.} Alloc* = proc (ud, theptr: Pointer, osize, nsize: cint){.cdecl.}
const const
TNONE* = - 1 TNONE* = - 1
@@ -112,130 +112,86 @@ const
type # Type of Numbers in Lua type # Type of Numbers in Lua
Number* = float Number* = float
Integer* = int Integer* = cint
{.pragma: ilua, importc: "lua_$1".}
{.push callConv: cdecl, dynlib: LibName.}
#{.push importc: "lua_$1".}
proc newstate*(f: Alloc, ud: Pointer): PState {.ilua.}
proc close*(L: PState){.ilua.}
proc newthread*(L: PState): PState{.ilua.}
proc atpanic*(L: PState, panicf: CFunction): CFunction{.ilua.}
proc gettop*(L: PState): cint{.ilua.}
proc settop*(L: PState, idx: cint){.ilua.}
proc pushvalue*(L: PState, Idx: cint){.ilua.}
proc remove*(L: PState, idx: cint){.ilua.}
proc insert*(L: PState, idx: cint){.ilua.}
proc replace*(L: PState, idx: cint){.ilua.}
proc checkstack*(L: PState, sz: cint): cint{.ilua.}
proc xmove*(`from`, `to`: PState, n: cint){.ilua.}
proc isnumber*(L: PState, idx: cint): cint{.ilua.}
proc isstring*(L: PState, idx: cint): cint{.ilua.}
proc iscfunction*(L: PState, idx: cint): cint{.ilua.}
proc isuserdata*(L: PState, idx: cint): cint{.ilua.}
proc luatype*(L: PState, idx: cint): cint{.importc: "lua_type".}
proc typename*(L: PState, tp: cint): cstring{.ilua.}
proc equal*(L: PState, idx1, idx2: cint): cint{.ilua.}
proc rawequal*(L: PState, idx1, idx2: cint): cint{.ilua.}
proc lessthan*(L: PState, idx1, idx2: cint): cint{.ilua.}
proc tonumber*(L: PState, idx: cint): Number{.ilua.}
proc tointeger*(L: PState, idx: cint): Integer{.ilua.}
proc toboolean*(L: PState, idx: cint): cint{.ilua.}
proc tolstring*(L: PState, idx: cint, length: ptr cint): cstring{.ilua.}
proc objlen*(L: PState, idx: cint): cint{.ilua.}
proc tocfunction*(L: PState, idx: cint): CFunction{.ilua.}
proc touserdata*(L: PState, idx: cint): Pointer{.ilua.}
proc tothread*(L: PState, idx: cint): PState{.ilua.}
proc topointer*(L: PState, idx: cint): Pointer{.ilua.}
proc pushnil*(L: PState){.ilua.}
proc pushnumber*(L: PState, n: Number){.ilua.}
proc pushinteger*(L: PState, n: Integer){.ilua.}
proc pushlstring*(L: PState, s: cstring, len: cint){.ilua.}
proc pushstring*(L: PState, s: cstring){.ilua.}
proc pushvfstring*(L: PState, fmt: cstring, argp: Pointer): cstring{.ilua.}
proc pushfstring*(L: PState, fmt: cstring): cstring{.varargs,ilua.}
proc pushcclosure*(L: PState, fn: CFunction, n: cint){.ilua.}
proc pushboolean*(L: PState, b: cint){.ilua.}
proc pushlightuserdata*(L: PState, p: Pointer){.ilua.}
proc pushthread*(L: PState){.ilua.}
proc gettable*(L: PState, idx: cint){.ilua.}
proc getfield*(L: Pstate, idx: cint, k: cstring){.ilua.}
proc rawget*(L: PState, idx: cint){.ilua.}
proc rawgeti*(L: PState, idx, n: cint){.ilua.}
proc createtable*(L: PState, narr, nrec: cint){.ilua.}
proc newuserdata*(L: PState, sz: cint): Pointer{.ilua.}
proc getmetatable*(L: PState, objindex: cint): cint{.ilua.}
proc getfenv*(L: PState, idx: cint){.ilua.}
proc settable*(L: PState, idx: cint){.ilua.}
proc setfield*(L: PState, idx: cint, k: cstring){.ilua.}
proc rawset*(L: PState, idx: cint){.ilua.}
proc rawseti*(L: PState, idx, n: cint){.ilua.}
proc setmetatable*(L: PState, objindex: cint): cint{.ilua.}
proc setfenv*(L: PState, idx: cint): cint{.ilua.}
proc call*(L: PState, nargs, nresults: cint){.ilua.}
proc pcall*(L: PState, nargs, nresults, errf: cint): cint{.ilua.}
proc cpcall*(L: PState, func: CFunction, ud: Pointer): cint{.ilua.}
proc load*(L: PState, reader: Reader, dt: Pointer, chunkname: cstring): cint{.ilua.}
proc dump*(L: PState, writer: Writer, data: Pointer): cint{.ilua.}
proc luayield*(L: PState, nresults: cint): cint{.importc: "lua_yield".}
proc resume*(L: PState, narg: cint): cint{.ilua.}
proc status*(L: PState): cint{.ilua.}
proc gc*(L: PState, what, data: cint): cint{.ilua.}
proc error*(L: PState): cint{.ilua.}
proc next*(L: PState, idx: cint): cint{.ilua.}
proc concat*(L: PState, n: cint){.ilua.}
proc getallocf*(L: PState, ud: ptr Pointer): Alloc{.ilua.}
proc setallocf*(L: PState, f: Alloc, ud: Pointer){.ilua.}
{.pop.}
proc newstate*(f: Alloc, ud: Pointer): PState{.cdecl, dynlib: NAME,
importc: "lua_newstate".}
proc close*(L: PState){.cdecl, dynlib: NAME, importc: "lua_close".}
proc newthread*(L: PState): PState{.cdecl, dynlib: NAME,
importc: "lua_newthread".}
proc atpanic*(L: PState, panicf: CFunction): CFunction{.cdecl, dynlib: NAME,
importc: "lua_atpanic".}
proc gettop*(L: PState): int{.cdecl, dynlib: NAME, importc: "lua_gettop".}
proc settop*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_settop".}
proc pushvalue*(L: PState, Idx: int){.cdecl, dynlib: NAME,
importc: "lua_pushvalue".}
proc remove*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_remove".}
proc insert*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_insert".}
proc replace*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_replace".}
proc checkstack*(L: PState, sz: int): cint{.cdecl, dynlib: NAME,
importc: "lua_checkstack".}
proc xmove*(`from`, `to`: PState, n: int){.cdecl, dynlib: NAME,
importc: "lua_xmove".}
proc isnumber*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_isnumber".}
proc isstring*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_isstring".}
proc iscfunction*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_iscfunction".}
proc isuserdata*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_isuserdata".}
proc luatype*(L: PState, idx: int): int{.cdecl, dynlib: NAME, importc: "lua_type".}
proc typename*(L: PState, tp: int): cstring{.cdecl, dynlib: NAME,
importc: "lua_typename".}
proc equal*(L: PState, idx1, idx2: int): cint{.cdecl, dynlib: NAME,
importc: "lua_equal".}
proc rawequal*(L: PState, idx1, idx2: int): cint{.cdecl, dynlib: NAME,
importc: "lua_rawequal".}
proc lessthan*(L: PState, idx1, idx2: int): cint{.cdecl, dynlib: NAME,
importc: "lua_lessthan".}
proc tonumber*(L: PState, idx: int): Number{.cdecl, dynlib: NAME,
importc: "lua_tonumber".}
proc tointeger*(L: PState, idx: int): Integer{.cdecl, dynlib: NAME,
importc: "lua_tointeger".}
proc toboolean*(L: PState, idx: int): cint{.cdecl, dynlib: NAME,
importc: "lua_toboolean".}
proc tolstring*(L: PState, idx: int, length: ptr int): cstring{.cdecl,
dynlib: NAME, importc: "lua_tolstring".}
proc objlen*(L: PState, idx: int): int{.cdecl, dynlib: NAME,
importc: "lua_objlen".}
proc tocfunction*(L: PState, idx: int): CFunction{.cdecl, dynlib: NAME,
importc: "lua_tocfunction".}
proc touserdata*(L: PState, idx: int): Pointer{.cdecl, dynlib: NAME,
importc: "lua_touserdata".}
proc tothread*(L: PState, idx: int): PState{.cdecl, dynlib: NAME,
importc: "lua_tothread".}
proc topointer*(L: PState, idx: int): Pointer{.cdecl, dynlib: NAME,
importc: "lua_topointer".}
proc pushnil*(L: PState){.cdecl, dynlib: NAME, importc: "lua_pushnil".}
proc pushnumber*(L: PState, n: Number){.cdecl, dynlib: NAME,
importc: "lua_pushnumber".}
proc pushinteger*(L: PState, n: Integer){.cdecl, dynlib: NAME,
importc: "lua_pushinteger".}
proc pushlstring*(L: PState, s: cstring, len: int){.cdecl, dynlib: NAME,
importc: "lua_pushlstring".}
proc pushstring*(L: PState, s: cstring){.cdecl, dynlib: NAME,
importc: "lua_pushstring".}
proc pushvfstring*(L: PState, fmt: cstring, argp: Pointer): cstring{.cdecl,
dynlib: NAME, importc: "lua_pushvfstring".}
proc pushfstring*(L: PState, fmt: cstring): cstring{.cdecl, varargs,
dynlib: NAME, importc: "lua_pushfstring".}
proc pushcclosure*(L: PState, fn: CFunction, n: int){.cdecl, dynlib: NAME,
importc: "lua_pushcclosure".}
proc pushboolean*(L: PState, b: cint){.cdecl, dynlib: NAME,
importc: "lua_pushboolean".}
proc pushlightuserdata*(L: PState, p: Pointer){.cdecl, dynlib: NAME,
importc: "lua_pushlightuserdata".}
proc pushthread*(L: PState){.cdecl, dynlib: NAME, importc: "lua_pushthread".}
proc gettable*(L: PState, idx: int){.cdecl, dynlib: NAME,
importc: "lua_gettable".}
proc getfield*(L: Pstate, idx: int, k: cstring){.cdecl, dynlib: NAME,
importc: "lua_getfield".}
proc rawget*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_rawget".}
proc rawgeti*(L: PState, idx, n: int){.cdecl, dynlib: NAME,
importc: "lua_rawgeti".}
proc createtable*(L: PState, narr, nrec: int){.cdecl, dynlib: NAME,
importc: "lua_createtable".}
proc newuserdata*(L: PState, sz: int): Pointer{.cdecl, dynlib: NAME,
importc: "lua_newuserdata".}
proc getmetatable*(L: PState, objindex: int): int{.cdecl, dynlib: NAME,
importc: "lua_getmetatable".}
proc getfenv*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_getfenv".}
proc settable*(L: PState, idx: int){.cdecl, dynlib: NAME,
importc: "lua_settable".}
proc setfield*(L: PState, idx: int, k: cstring){.cdecl, dynlib: NAME,
importc: "lua_setfield".}
proc rawset*(L: PState, idx: int){.cdecl, dynlib: NAME, importc: "lua_rawset".}
proc rawseti*(L: PState, idx, n: int){.cdecl, dynlib: NAME,
importc: "lua_rawseti".}
proc setmetatable*(L: PState, objindex: int): int{.cdecl, dynlib: NAME,
importc: "lua_setmetatable".}
proc setfenv*(L: PState, idx: int): int{.cdecl, dynlib: NAME,
importc: "lua_setfenv".}
proc call*(L: PState, nargs, nresults: int){.cdecl, dynlib: NAME,
importc: "lua_call".}
proc pcall*(L: PState, nargs, nresults, errf: int): int{.cdecl, dynlib: NAME,
importc: "lua_pcall".}
proc cpcall*(L: PState, func: CFunction, ud: Pointer): int{.cdecl, dynlib: NAME,
importc: "lua_cpcall".}
proc load*(L: PState, reader: Reader, dt: Pointer, chunkname: cstring): int{.
cdecl, dynlib: NAME, importc: "lua_load".}
proc dump*(L: PState, writer: Writer, data: Pointer): int{.cdecl, dynlib: NAME,
importc: "lua_dump".}
proc luayield*(L: PState, nresults: int): int{.cdecl, dynlib: NAME,
importc: "lua_yield".}
proc resume*(L: PState, narg: int): int{.cdecl, dynlib: NAME,
importc: "lua_resume".}
proc status*(L: PState): int{.cdecl, dynlib: NAME, importc: "lua_status".}
proc gc*(L: PState, what, data: int): int{.cdecl, dynlib: NAME,
importc: "lua_gc".}
proc error*(L: PState): int{.cdecl, dynlib: NAME, importc: "lua_error".}
proc next*(L: PState, idx: int): int{.cdecl, dynlib: NAME, importc: "lua_next".}
proc concat*(L: PState, n: int){.cdecl, dynlib: NAME, importc: "lua_concat".}
proc getallocf*(L: PState, ud: ptr Pointer): Alloc{.cdecl, dynlib: NAME,
importc: "lua_getallocf".}
proc setallocf*(L: PState, f: Alloc, ud: Pointer){.cdecl, dynlib: NAME,
importc: "lua_setallocf".}
# #
#** Garbage-collection functions and options #** Garbage-collection functions and options
# #
@@ -256,29 +212,29 @@ const
#** =============================================================== #** ===============================================================
# #
proc pop*(L: PState, n: int) proc pop*(L: PState, n: cint)
proc newtable*(L: Pstate) proc newtable*(L: Pstate)
proc register*(L: PState, n: cstring, f: CFunction) proc register*(L: PState, n: cstring, f: CFunction)
proc pushcfunction*(L: PState, f: CFunction) proc pushcfunction*(L: PState, f: CFunction)
proc strlen*(L: Pstate, i: int): int proc strlen*(L: Pstate, i: cint): cint
proc isfunction*(L: PState, n: int): bool proc isfunction*(L: PState, n: cint): bool
proc istable*(L: PState, n: int): bool proc istable*(L: PState, n: cint): bool
proc islightuserdata*(L: PState, n: int): bool proc islightuserdata*(L: PState, n: cint): bool
proc isnil*(L: PState, n: int): bool proc isnil*(L: PState, n: cint): bool
proc isboolean*(L: PState, n: int): bool proc isboolean*(L: PState, n: cint): bool
proc isthread*(L: PState, n: int): bool proc isthread*(L: PState, n: cint): bool
proc isnone*(L: PState, n: int): bool proc isnone*(L: PState, n: cint): bool
proc isnoneornil*(L: PState, n: int): bool proc isnoneornil*(L: PState, n: cint): bool
proc pushliteral*(L: PState, s: cstring) proc pushliteral*(L: PState, s: cstring)
proc setglobal*(L: PState, s: cstring) proc setglobal*(L: PState, s: cstring)
proc getglobal*(L: PState, s: cstring) proc getglobal*(L: PState, s: cstring)
proc tostring*(L: PState, i: int): cstring proc tostring*(L: PState, i: cint): cstring
# #
#** compatibility macros and functions #** compatibility macros and functions
# #
proc getregistry*(L: PState) proc getregistry*(L: PState)
proc getgccount*(L: PState): int proc getgccount*(L: PState): cint
type type
Chunkreader* = Reader Chunkreader* = Reader
Chunkwriter* = Writer Chunkwriter* = Writer
@@ -307,18 +263,18 @@ const
type type
TDebug*{.final.} = object # activation record TDebug*{.final.} = object # activation record
event*: int event*: cint
name*: cstring # (n) name*: cstring # (n)
namewhat*: cstring # (n) `global', `local', `field', `method' namewhat*: cstring # (n) `global', `local', `field', `method'
what*: cstring # (S) `Lua', `C', `main', `tail' what*: cstring # (S) `Lua', `C', `main', `tail'
source*: cstring # (S) source*: cstring # (S)
currentline*: int # (l) currentline*: cint # (l)
nups*: int # (u) number of upvalues nups*: cint # (u) number of upvalues
linedefined*: int # (S) linedefined*: cint # (S)
lastlinedefined*: int # (S) lastlinedefined*: cint # (S)
short_src*: array[0..IDSIZE - 1, Char] # (S) short_src*: array[0.. <IDSIZE, Char] # (S) \
# private part # private part
i_ci*: int # active function i_ci*: cint # active function
PDebug* = ptr TDebug PDebug* = ptr TDebug
Hook* = proc (L: PState, ar: PDebug){.cdecl.} Hook* = proc (L: PState, ar: PDebug){.cdecl.}
@@ -329,31 +285,27 @@ type
#** ====================================================================== #** ======================================================================
# #
proc getstack*(L: PState, level: int, ar: PDebug): int{.cdecl, dynlib: NAME, {.push callConv: cdecl, dynlib: lua.LIB_NAME.}
importc: "lua_getstack".}
proc getinfo*(L: PState, what: cstring, ar: PDebug): int{.cdecl, dynlib: NAME, proc getstack*(L: PState, level: cint, ar: PDebug): cint{.ilua.}
importc: "lua_getinfo".} proc getinfo*(L: PState, what: cstring, ar: PDebug): cint{.ilua.}
proc getlocal*(L: PState, ar: PDebug, n: int): cstring{.cdecl, dynlib: NAME, proc getlocal*(L: PState, ar: PDebug, n: cint): cstring{.ilua.}
importc: "lua_getlocal".} proc setlocal*(L: PState, ar: PDebug, n: cint): cstring{.ilua.}
proc setlocal*(L: PState, ar: PDebug, n: int): cstring{.cdecl, dynlib: NAME, proc getupvalue*(L: PState, funcindex: cint, n: cint): cstring{.ilua.}
importc: "lua_setlocal".} proc setupvalue*(L: PState, funcindex: cint, n: cint): cstring{.ilua.}
proc getupvalue*(L: PState, funcindex: int, n: int): cstring{.cdecl, proc sethook*(L: PState, func: Hook, mask: cint, count: cint): cint{.ilua.}
dynlib: NAME, importc: "lua_getupvalue".} proc gethook*(L: PState): Hook{.ilua.}
proc setupvalue*(L: PState, funcindex: int, n: int): cstring{.cdecl, proc gethookmask*(L: PState): cint{.ilua.}
dynlib: NAME, importc: "lua_setupvalue".} proc gethookcount*(L: PState): cint{.ilua.}
proc sethook*(L: PState, func: Hook, mask: int, count: int): int{.cdecl,
dynlib: NAME, importc: "lua_sethook".} {.pop.}
proc gethook*(L: PState): Hook{.cdecl, dynlib: NAME, importc: "lua_gethook".}
proc gethookmask*(L: PState): int{.cdecl, dynlib: NAME,
importc: "lua_gethookmask".}
proc gethookcount*(L: PState): int{.cdecl, dynlib: NAME,
importc: "lua_gethookcount".}
# implementation # implementation
proc upvalueindex(I: int): int = proc upvalueindex(I: cint): cint =
Result = GLOBALSINDEX - i Result = GLOBALSINDEX - i
proc pop(L: PState, n: int) = proc pop(L: PState, n: cint) =
settop(L, - n - 1) settop(L, - n - 1)
proc newtable(L: PState) = proc newtable(L: PState) =
@@ -366,35 +318,35 @@ proc register(L: PState, n: cstring, f: CFunction) =
proc pushcfunction(L: PState, f: CFunction) = proc pushcfunction(L: PState, f: CFunction) =
pushcclosure(L, f, 0) pushcclosure(L, f, 0)
proc strlen(L: PState, i: int): int = proc strlen(L: PState, i: cint): cint =
Result = objlen(L, i) Result = objlen(L, i)
proc isfunction(L: PState, n: int): bool = proc isfunction(L: PState, n: cint): bool =
Result = luatype(L, n) == TFUNCTION Result = luatype(L, n) == TFUNCTION
proc istable(L: PState, n: int): bool = proc istable(L: PState, n: cint): bool =
Result = luatype(L, n) == TTABLE Result = luatype(L, n) == TTABLE
proc islightuserdata(L: PState, n: int): bool = proc islightuserdata(L: PState, n: cint): bool =
Result = luatype(L, n) == TLIGHTUSERDATA Result = luatype(L, n) == TLIGHTUSERDATA
proc isnil(L: PState, n: int): bool = proc isnil(L: PState, n: cint): bool =
Result = luatype(L, n) == TNIL Result = luatype(L, n) == TNIL
proc isboolean(L: PState, n: int): bool = proc isboolean(L: PState, n: cint): bool =
Result = luatype(L, n) == TBOOLEAN Result = luatype(L, n) == TBOOLEAN
proc isthread(L: PState, n: int): bool = proc isthread(L: PState, n: cint): bool =
Result = luatype(L, n) == TTHREAD Result = luatype(L, n) == TTHREAD
proc isnone(L: PState, n: int): bool = proc isnone(L: PState, n: cint): bool =
Result = luatype(L, n) == TNONE Result = luatype(L, n) == TNONE
proc isnoneornil(L: PState, n: int): bool = proc isnoneornil(L: PState, n: cint): bool =
Result = luatype(L, n) <= 0 Result = luatype(L, n) <= 0
proc pushliteral(L: PState, s: cstring) = proc pushliteral(L: PState, s: cstring) =
pushlstring(L, s, len(s)) pushlstring(L, s, s.len.cint)
proc setglobal(L: PState, s: cstring) = proc setglobal(L: PState, s: cstring) =
setfield(L, GLOBALSINDEX, s) setfield(L, GLOBALSINDEX, s)
@@ -402,11 +354,11 @@ proc setglobal(L: PState, s: cstring) =
proc getglobal(L: PState, s: cstring) = proc getglobal(L: PState, s: cstring) =
getfield(L, GLOBALSINDEX, s) getfield(L, GLOBALSINDEX, s)
proc tostring(L: PState, i: int): cstring = proc tostring(L: PState, i: cint): cstring =
Result = tolstring(L, i, nil) Result = tolstring(L, i, nil)
proc getregistry(L: PState) = proc getregistry(L: PState) =
pushvalue(L, REGISTRYINDEX) pushvalue(L, REGISTRYINDEX)
proc getgccount(L: PState): int = proc getgccount(L: PState): cint =
Result = gc(L, GCCOUNT, 0) Result = gc(L, GCCOUNT, 0)

38
lib/wrappers/lua/lualib.nim
View File

@@ -32,35 +32,33 @@ const
DBLIBNAME* = "debug" DBLIBNAME* = "debug"
LOADLIBNAME* = "package" LOADLIBNAME* = "package"
proc open_base*(L: PState): cint{.cdecl, dynlib: LIB_NAME, {.pragma: ilua, importc: "lua$1".}
importc: "luaopen_base".}
proc open_table*(L: PState): cint{.cdecl, dynlib: LIB_NAME, {.push callConv: cdecl, dynlib: lua.LIB_NAME.}
importc: "luaopen_table".} proc open_base*(L: PState): cint{.ilua.}
proc open_io*(L: PState): cint{.cdecl, dynlib: LIB_NAME, importc: "luaopen_io".} proc open_table*(L: PState): cint{.ilua.}
proc open_string*(L: PState): cint{.cdecl, dynlib: LIB_NAME, proc open_io*(L: PState): cint{.ilua.}
importc: "luaopen_string".} proc open_string*(L: PState): cint{.ilua.}
proc open_math*(L: PState): cint{.cdecl, dynlib: LIB_NAME, proc open_math*(L: PState): cint{.ilua.}
importc: "luaopen_math".} proc open_debug*(L: PState): cint{.ilua.}
proc open_debug*(L: PState): cint{.cdecl, dynlib: LIB_NAME, proc open_package*(L: PState): cint{.ilua.}
importc: "luaopen_debug".} proc openlibs*(L: PState){.importc: "luaL_openlibs".}
proc open_package*(L: PState): cint{.cdecl, dynlib: LIB_NAME, {.pop.}
importc: "luaopen_package".}
proc openlibs*(L: PState){.cdecl, dynlib: LIB_NAME, importc: "luaL_openlibs".}
proc baselibopen*(L: PState): Bool = proc baselibopen*(L: PState): Bool =
Result = open_base(L) != 0'i32 open_base(L) != 0'i32
proc tablibopen*(L: PState): Bool = proc tablibopen*(L: PState): Bool =
Result = open_table(L) != 0'i32 open_table(L) != 0'i32
proc iolibopen*(L: PState): Bool = proc iolibopen*(L: PState): Bool =
Result = open_io(L) != 0'i32 open_io(L) != 0'i32
proc strlibopen*(L: PState): Bool = proc strlibopen*(L: PState): Bool =
Result = open_string(L) != 0'i32 open_string(L) != 0'i32
proc mathlibopen*(L: PState): Bool = proc mathlibopen*(L: PState): Bool =
Result = open_math(L) != 0'i32 open_math(L) != 0'i32
proc dblibopen*(L: PState): Bool = proc dblibopen*(L: PState): Bool =
Result = open_debug(L) != 0'i32 open_debug(L) != 0'i32