CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
lua.h-Dateireferenz
#include <stdarg.h>
#include <stddef.h>
#include "luaconf.h"
+ Include-Abhängigkeitsdiagramm für lua.h:
+ Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  lua_Debug
 

Makrodefinitionen

#define LUA_VERSION   "Lua 5.1"
 
#define LUA_RELEASE   "Lua 5.1.5"
 
#define LUA_VERSION_NUM   501
 
#define LUA_COPYRIGHT   "Copyright (C) 1994-2012 Lua.org, PUC-Rio"
 
#define LUA_AUTHORS   "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
 
#define LUA_SIGNATURE   "\033Lua"
 
#define LUA_MULTRET   (-1)
 
#define LUA_REGISTRYINDEX   (-10000)
 
#define LUA_ENVIRONINDEX   (-10001)
 
#define LUA_GLOBALSINDEX   (-10002)
 
#define lua_upvalueindex(i)   (LUA_GLOBALSINDEX-(i))
 
#define LUA_YIELD   1
 
#define LUA_ERRRUN   2
 
#define LUA_ERRSYNTAX   3
 
#define LUA_ERRMEM   4
 
#define LUA_ERRERR   5
 
#define LUA_TNONE   (-1)
 
#define LUA_TNIL   0
 
#define LUA_TBOOLEAN   1
 
#define LUA_TLIGHTUSERDATA   2
 
#define LUA_TNUMBER   3
 
#define LUA_TSTRING   4
 
#define LUA_TTABLE   5
 
#define LUA_TFUNCTION   6
 
#define LUA_TUSERDATA   7
 
#define LUA_TTHREAD   8
 
#define LUA_MINSTACK   20
 
#define LUA_GCSTOP   0
 
#define LUA_GCRESTART   1
 
#define LUA_GCCOLLECT   2
 
#define LUA_GCCOUNT   3
 
#define LUA_GCCOUNTB   4
 
#define LUA_GCSTEP   5
 
#define LUA_GCSETPAUSE   6
 
#define LUA_GCSETSTEPMUL   7
 
#define lua_pop(L, n)   lua_settop(L, -(n)-1)
 
#define lua_newtable(L)   lua_createtable(L, 0, 0)
 
#define lua_register(L, n, f)   (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
 
#define lua_pushcfunction(L, f)   lua_pushcclosure(L, (f), 0)
 
#define lua_strlen(L, i)   lua_objlen(L, (i))
 
#define lua_isfunction(L, n)   (lua_type(L, (n)) == LUA_TFUNCTION)
 
#define lua_istable(L, n)   (lua_type(L, (n)) == LUA_TTABLE)
 
#define lua_islightuserdata(L, n)   (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
 
#define lua_isnil(L, n)   (lua_type(L, (n)) == LUA_TNIL)
 
#define lua_isboolean(L, n)   (lua_type(L, (n)) == LUA_TBOOLEAN)
 
#define lua_isthread(L, n)   (lua_type(L, (n)) == LUA_TTHREAD)
 
#define lua_isnone(L, n)   (lua_type(L, (n)) == LUA_TNONE)
 
#define lua_isnoneornil(L, n)   (lua_type(L, (n)) <= 0)
 
#define lua_pushliteral(L, s)   lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
 
#define lua_setglobal(L, s)   lua_setfield(L, LUA_GLOBALSINDEX, (s))
 
#define lua_getglobal(L, s)   lua_getfield(L, LUA_GLOBALSINDEX, (s))
 
#define lua_tostring(L, i)   lua_tolstring(L, (i), NULL)
 
#define lua_open()   luaL_newstate()
 
#define lua_getregistry(L)   lua_pushvalue(L, LUA_REGISTRYINDEX)
 
#define lua_getgccount(L)   lua_gc(L, LUA_GCCOUNT, 0)
 
#define lua_Chunkreader   lua_Reader
 
#define lua_Chunkwriter   lua_Writer
 
#define LUA_HOOKCALL   0
 
#define LUA_HOOKRET   1
 
#define LUA_HOOKLINE   2
 
#define LUA_HOOKCOUNT   3
 
#define LUA_HOOKTAILRET   4
 
#define LUA_MASKCALL   (1 << LUA_HOOKCALL)
 
#define LUA_MASKRET   (1 << LUA_HOOKRET)
 
#define LUA_MASKLINE   (1 << LUA_HOOKLINE)
 
#define LUA_MASKCOUNT   (1 << LUA_HOOKCOUNT)
 

Typdefinitionen

typedef struct lua_State lua_State
 
typedef int(* lua_CFunction )(lua_State *L)
 
typedef const char *(* lua_Reader )(lua_State *L, void *ud, size_t *sz)
 
typedef int(* lua_Writer )(lua_State *L, const void *p, size_t sz, void *ud)
 
typedef void *(* lua_Alloc )(void *ud, void *ptr, size_t osize, size_t nsize)
 
typedef LUA_NUMBER lua_Number
 
typedef LUA_INTEGER lua_Integer
 
typedef struct lua_Debug lua_Debug
 
typedef void(* lua_Hook )(lua_State *L, lua_Debug *ar)
 

Funktionen

LUA_API lua_State *() lua_newstate (lua_Alloc f, void *ud)
 
LUA_API void() lua_close (lua_State *L)
 
LUA_API lua_State *() lua_newthread (lua_State *L)
 
LUA_API lua_CFunction() lua_atpanic (lua_State *L, lua_CFunction panicf)
 
LUA_API int() lua_gettop (lua_State *L)
 
LUA_API void() lua_settop (lua_State *L, int idx)
 
LUA_API void() lua_pushvalue (lua_State *L, int idx)
 
LUA_API void() lua_remove (lua_State *L, int idx)
 
LUA_API void() lua_insert (lua_State *L, int idx)
 
LUA_API void() lua_replace (lua_State *L, int idx)
 
LUA_API int() lua_checkstack (lua_State *L, int sz)
 
LUA_API void() lua_xmove (lua_State *from, lua_State *to, int n)
 
LUA_API int() lua_isnumber (lua_State *L, int idx)
 
LUA_API int() lua_isstring (lua_State *L, int idx)
 
LUA_API int() lua_iscfunction (lua_State *L, int idx)
 
LUA_API int() lua_isuserdata (lua_State *L, int idx)
 
LUA_API int() lua_type (lua_State *L, int idx)
 
LUA_API const char *() lua_typename (lua_State *L, int tp)
 
LUA_API int() lua_equal (lua_State *L, int idx1, int idx2)
 
LUA_API int() lua_rawequal (lua_State *L, int idx1, int idx2)
 
LUA_API int() lua_lessthan (lua_State *L, int idx1, int idx2)
 
LUA_API lua_Number() lua_tonumber (lua_State *L, int idx)
 
LUA_API lua_Integer() lua_tointeger (lua_State *L, int idx)
 
LUA_API int() lua_toboolean (lua_State *L, int idx)
 
LUA_API const char *() lua_tolstring (lua_State *L, int idx, size_t *len)
 
LUA_API size_t() lua_objlen (lua_State *L, int idx)
 
LUA_API lua_CFunction() lua_tocfunction (lua_State *L, int idx)
 
LUA_API void *() lua_touserdata (lua_State *L, int idx)
 
LUA_API lua_State *() lua_tothread (lua_State *L, int idx)
 
LUA_API const void *() lua_topointer (lua_State *L, int idx)
 
LUA_API void() lua_pushnil (lua_State *L)
 
LUA_API void() lua_pushnumber (lua_State *L, lua_Number n)
 
LUA_API void() lua_pushinteger (lua_State *L, lua_Integer n)
 
LUA_API void() lua_pushlstring (lua_State *L, const char *s, size_t l)
 
LUA_API void() lua_pushstring (lua_State *L, const char *s)
 
LUA_API const char *() lua_pushvfstring (lua_State *L, const char *fmt, va_list argp)
 
LUA_API const char *() lua_pushfstring (lua_State *L, const char *fmt,...)
 
LUA_API void() lua_pushcclosure (lua_State *L, lua_CFunction fn, int n)
 
LUA_API void() lua_pushboolean (lua_State *L, int b)
 
LUA_API void() lua_pushlightuserdata (lua_State *L, void *p)
 
LUA_API int() lua_pushthread (lua_State *L)
 
LUA_API void() lua_gettable (lua_State *L, int idx)
 
LUA_API void() lua_getfield (lua_State *L, int idx, const char *k)
 
LUA_API void() lua_rawget (lua_State *L, int idx)
 
LUA_API void() lua_rawgeti (lua_State *L, int idx, int n)
 
LUA_API void() lua_createtable (lua_State *L, int narr, int nrec)
 
LUA_API void *() lua_newuserdata (lua_State *L, size_t sz)
 
LUA_API int() lua_getmetatable (lua_State *L, int objindex)
 
LUA_API void() lua_getfenv (lua_State *L, int idx)
 
LUA_API void() lua_settable (lua_State *L, int idx)
 
LUA_API void() lua_setfield (lua_State *L, int idx, const char *k)
 
LUA_API void() lua_rawset (lua_State *L, int idx)
 
LUA_API void() lua_rawseti (lua_State *L, int idx, int n)
 
LUA_API int() lua_setmetatable (lua_State *L, int objindex)
 
LUA_API int() lua_setfenv (lua_State *L, int idx)
 
LUA_API void() lua_call (lua_State *L, int nargs, int nresults)
 
LUA_API int() lua_pcall (lua_State *L, int nargs, int nresults, int errfunc)
 
LUA_API int() lua_cpcall (lua_State *L, lua_CFunction func, void *ud)
 
LUA_API int() lua_load (lua_State *L, lua_Reader reader, void *dt, const char *chunkname)
 
LUA_API int() lua_dump (lua_State *L, lua_Writer writer, void *data)
 
LUA_API int() lua_yield (lua_State *L, int nresults)
 
LUA_API int() lua_resume (lua_State *L, int narg)
 
LUA_API int() lua_status (lua_State *L)
 
LUA_API int() lua_gc (lua_State *L, int what, int data)
 
LUA_API int() lua_error (lua_State *L)
 
LUA_API int() lua_next (lua_State *L, int idx)
 
LUA_API void() lua_concat (lua_State *L, int n)
 
LUA_API lua_Alloc() lua_getallocf (lua_State *L, void **ud)
 
LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud)
 
LUA_API void lua_setlevel (lua_State *from, lua_State *to)
 
LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar)
 
LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar)
 
LUA_API const char * lua_getlocal (lua_State *L, const lua_Debug *ar, int n)
 
LUA_API const char * lua_setlocal (lua_State *L, const lua_Debug *ar, int n)
 
LUA_API const char * lua_getupvalue (lua_State *L, int funcindex, int n)
 
LUA_API const char * lua_setupvalue (lua_State *L, int funcindex, int n)
 
LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count)
 
LUA_API lua_Hook lua_gethook (lua_State *L)
 
LUA_API int lua_gethookmask (lua_State *L)
 
LUA_API int lua_gethookcount (lua_State *L)
 

Makro-Dokumentation

#define LUA_AUTHORS   "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"

Definiert in Zeile 23 der Datei lua.h.

#define lua_Chunkreader   lua_Reader

Definiert in Zeile 293 der Datei lua.h.

#define lua_Chunkwriter   lua_Writer

Definiert in Zeile 294 der Datei lua.h.

#define LUA_COPYRIGHT   "Copyright (C) 1994-2012 Lua.org, PUC-Rio"

Definiert in Zeile 22 der Datei lua.h.

#define LUA_ENVIRONINDEX   (-10001)

Definiert in Zeile 37 der Datei lua.h.

#define LUA_ERRERR   5

Definiert in Zeile 47 der Datei lua.h.

#define LUA_ERRMEM   4

Definiert in Zeile 46 der Datei lua.h.

#define LUA_ERRRUN   2

Definiert in Zeile 44 der Datei lua.h.

#define LUA_ERRSYNTAX   3

Definiert in Zeile 45 der Datei lua.h.

#define LUA_GCCOLLECT   2

Definiert in Zeile 223 der Datei lua.h.

#define LUA_GCCOUNT   3

Definiert in Zeile 224 der Datei lua.h.

#define LUA_GCCOUNTB   4

Definiert in Zeile 225 der Datei lua.h.

#define LUA_GCRESTART   1

Definiert in Zeile 222 der Datei lua.h.

#define LUA_GCSETPAUSE   6

Definiert in Zeile 227 der Datei lua.h.

#define LUA_GCSETSTEPMUL   7

Definiert in Zeile 228 der Datei lua.h.

#define LUA_GCSTEP   5

Definiert in Zeile 226 der Datei lua.h.

#define LUA_GCSTOP   0

Definiert in Zeile 221 der Datei lua.h.

#define lua_getgccount (   L)    lua_gc(L, LUA_GCCOUNT, 0)

Definiert in Zeile 291 der Datei lua.h.

#define lua_getglobal (   L,
  s 
)    lua_getfield(L, LUA_GLOBALSINDEX, (s))

Definiert in Zeile 277 der Datei lua.h.

#define lua_getregistry (   L)    lua_pushvalue(L, LUA_REGISTRYINDEX)

Definiert in Zeile 289 der Datei lua.h.

#define LUA_GLOBALSINDEX   (-10002)

Definiert in Zeile 38 der Datei lua.h.

#define LUA_HOOKCALL   0

Definiert in Zeile 311 der Datei lua.h.

#define LUA_HOOKCOUNT   3

Definiert in Zeile 314 der Datei lua.h.

#define LUA_HOOKLINE   2

Definiert in Zeile 313 der Datei lua.h.

#define LUA_HOOKRET   1

Definiert in Zeile 312 der Datei lua.h.

#define LUA_HOOKTAILRET   4

Definiert in Zeile 315 der Datei lua.h.

#define lua_isboolean (   L,
  n 
)    (lua_type(L, (n)) == LUA_TBOOLEAN)

Definiert in Zeile 268 der Datei lua.h.

#define lua_isfunction (   L,
  n 
)    (lua_type(L, (n)) == LUA_TFUNCTION)

Definiert in Zeile 264 der Datei lua.h.

#define lua_islightuserdata (   L,
  n 
)    (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)

Definiert in Zeile 266 der Datei lua.h.

#define lua_isnil (   L,
  n 
)    (lua_type(L, (n)) == LUA_TNIL)

Definiert in Zeile 267 der Datei lua.h.

#define lua_isnone (   L,
  n 
)    (lua_type(L, (n)) == LUA_TNONE)

Definiert in Zeile 270 der Datei lua.h.

#define lua_isnoneornil (   L,
  n 
)    (lua_type(L, (n)) <= 0)

Definiert in Zeile 271 der Datei lua.h.

#define lua_istable (   L,
  n 
)    (lua_type(L, (n)) == LUA_TTABLE)

Definiert in Zeile 265 der Datei lua.h.

#define lua_isthread (   L,
  n 
)    (lua_type(L, (n)) == LUA_TTHREAD)

Definiert in Zeile 269 der Datei lua.h.

#define LUA_MASKCALL   (1 << LUA_HOOKCALL)

Definiert in Zeile 321 der Datei lua.h.

#define LUA_MASKCOUNT   (1 << LUA_HOOKCOUNT)

Definiert in Zeile 324 der Datei lua.h.

#define LUA_MASKLINE   (1 << LUA_HOOKLINE)

Definiert in Zeile 323 der Datei lua.h.

#define LUA_MASKRET   (1 << LUA_HOOKRET)

Definiert in Zeile 322 der Datei lua.h.

#define LUA_MINSTACK   20

Definiert in Zeile 87 der Datei lua.h.

#define LUA_MULTRET   (-1)

Definiert in Zeile 30 der Datei lua.h.

#define lua_newtable (   L)    lua_createtable(L, 0, 0)

Definiert in Zeile 256 der Datei lua.h.

#define lua_open ( )    luaL_newstate()

Definiert in Zeile 287 der Datei lua.h.

#define lua_pop (   L,
  n 
)    lua_settop(L, -(n)-1)

Definiert in Zeile 254 der Datei lua.h.

#define lua_pushcfunction (   L,
 
)    lua_pushcclosure(L, (f), 0)

Definiert in Zeile 260 der Datei lua.h.

#define lua_pushliteral (   L,
  s 
)    lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)

Definiert in Zeile 273 der Datei lua.h.

#define lua_register (   L,
  n,
 
)    (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))

Definiert in Zeile 258 der Datei lua.h.

#define LUA_REGISTRYINDEX   (-10000)

Definiert in Zeile 36 der Datei lua.h.

#define LUA_RELEASE   "Lua 5.1.5"

Definiert in Zeile 20 der Datei lua.h.

#define lua_setglobal (   L,
  s 
)    lua_setfield(L, LUA_GLOBALSINDEX, (s))

Definiert in Zeile 276 der Datei lua.h.

#define LUA_SIGNATURE   "\033Lua"

Definiert in Zeile 27 der Datei lua.h.

#define lua_strlen (   L,
 
)    lua_objlen(L, (i))

Definiert in Zeile 262 der Datei lua.h.

#define LUA_TBOOLEAN   1

Definiert in Zeile 75 der Datei lua.h.

#define LUA_TFUNCTION   6

Definiert in Zeile 80 der Datei lua.h.

#define LUA_TLIGHTUSERDATA   2

Definiert in Zeile 76 der Datei lua.h.

#define LUA_TNIL   0

Definiert in Zeile 74 der Datei lua.h.

#define LUA_TNONE   (-1)

Definiert in Zeile 72 der Datei lua.h.

#define LUA_TNUMBER   3

Definiert in Zeile 77 der Datei lua.h.

#define lua_tostring (   L,
 
)    lua_tolstring(L, (i), NULL)

Definiert in Zeile 279 der Datei lua.h.

#define LUA_TSTRING   4

Definiert in Zeile 78 der Datei lua.h.

#define LUA_TTABLE   5

Definiert in Zeile 79 der Datei lua.h.

#define LUA_TTHREAD   8

Definiert in Zeile 82 der Datei lua.h.

#define LUA_TUSERDATA   7

Definiert in Zeile 81 der Datei lua.h.

#define lua_upvalueindex (   i)    (LUA_GLOBALSINDEX-(i))

Definiert in Zeile 39 der Datei lua.h.

#define LUA_VERSION   "Lua 5.1"

Definiert in Zeile 19 der Datei lua.h.

#define LUA_VERSION_NUM   501

Definiert in Zeile 21 der Datei lua.h.

#define LUA_YIELD   1

Definiert in Zeile 43 der Datei lua.h.

Dokumentation der benutzerdefinierten Typen

typedef void*(* lua_Alloc)(void *ud, void *ptr, size_t osize, size_t nsize)

Definiert in Zeile 66 der Datei lua.h.

typedef int(* lua_CFunction)(lua_State *L)

Definiert in Zeile 52 der Datei lua.h.

typedef struct lua_Debug lua_Debug

Definiert in Zeile 326 der Datei lua.h.

typedef void(* lua_Hook)(lua_State *L, lua_Debug *ar)

Definiert in Zeile 330 der Datei lua.h.

Definiert in Zeile 103 der Datei lua.h.

Definiert in Zeile 99 der Datei lua.h.

typedef const char*(* lua_Reader)(lua_State *L, void *ud, size_t *sz)

Definiert in Zeile 58 der Datei lua.h.

typedef struct lua_State lua_State

Definiert in Zeile 50 der Datei lua.h.

typedef int(* lua_Writer)(lua_State *L, const void *p, size_t sz, void *ud)

Definiert in Zeile 60 der Datei lua.h.

Dokumentation der Funktionen

LUA_API lua_CFunction() lua_atpanic ( lua_State L,
lua_CFunction  panicf 
)

Definiert in Zeile 130 der Datei lapi.c.

130  {
131  lua_CFunction old;
132  lua_lock(L);
133  old = G(L)->panic;
134  G(L)->panic = panicf;
135  lua_unlock(L);
136  return old;
137 }
LUA_API void() lua_call ( lua_State L,
int  nargs,
int  nresults 
)

Definiert in Zeile 776 der Datei lapi.c.

776  {
777  StkId func;
778  lua_lock(L);
779  api_checknelems(L, nargs+1);
780  checkresults(L, nargs, nresults);
781  func = L->top - (nargs+1);
782  luaD_call(L, func, nresults);
783  adjustresults(L, nresults);
784  lua_unlock(L);
785 }
LUA_API int() lua_checkstack ( lua_State L,
int  sz 
)

Definiert in Zeile 95 der Datei lapi.c.

95  {
96  int res = 1;
97  lua_lock(L);
98  if (size > LUAI_MAXCSTACK || (L->top - L->base + size) > LUAI_MAXCSTACK)
99  res = 0; /* stack overflow */
100  else if (size > 0) {
101  luaD_checkstack(L, size);
102  if (L->ci->top < L->top + size)
103  L->ci->top = L->top + size;
104  }
105  lua_unlock(L);
106  return res;
107 }
LUA_API void() lua_close ( lua_State L)

Definiert in Zeile 199 der Datei lstate.c.

199  {
200  L = G(L)->mainthread; /* only the main thread can be closed */
201  lua_lock(L);
202  luaF_close(L, L->stack); /* close all upvalues for this thread */
203  luaC_separateudata(L, 1); /* separate udata that have GC metamethods */
204  L->errfunc = 0; /* no error function during GC metamethods */
205  do { /* repeat until no more errors */
206  L->ci = L->base_ci;
207  L->base = L->top = L->ci->base;
208  L->nCcalls = L->baseCcalls = 0;
209  } while (luaD_rawrunprotected(L, callallgcTM, NULL) != 0);
210  lua_assert(G(L)->tmudata == NULL);
212  close_state(L);
213 }
LUA_API void() lua_concat ( lua_State L,
int  n 
)

Definiert in Zeile 990 der Datei lapi.c.

990  {
991  lua_lock(L);
992  api_checknelems(L, n);
993  if (n >= 2) {
994  luaC_checkGC(L);
995  luaV_concat(L, n, cast_int(L->top - L->base) - 1);
996  L->top -= (n-1);
997  }
998  else if (n == 0) { /* push empty string */
999  setsvalue2s(L, L->top, luaS_newlstr(L, "", 0));
1000  api_incr_top(L);
1001  }
1002  /* else n == 1; nothing to do */
1003  lua_unlock(L);
1004 }
LUA_API int() lua_cpcall ( lua_State L,
lua_CFunction  func,
void *  ud 
)

Definiert in Zeile 850 der Datei lapi.c.

850  {
851  struct CCallS c;
852  int status;
853  lua_lock(L);
854  c.func = func;
855  c.ud = ud;
856  status = luaD_pcall(L, f_Ccall, &c, savestack(L, L->top), 0);
857  lua_unlock(L);
858  return status;
859 }
LUA_API void() lua_createtable ( lua_State L,
int  narr,
int  nrec 
)

Definiert in Zeile 578 der Datei lapi.c.

578  {
579  lua_lock(L);
580  luaC_checkGC(L);
581  sethvalue(L, L->top, luaH_new(L, narray, nrec));
582  api_incr_top(L);
583  lua_unlock(L);
584 }
LUA_API int() lua_dump ( lua_State L,
lua_Writer  writer,
void *  data 
)

Definiert in Zeile 875 der Datei lapi.c.

875  {
876  int status;
877  TValue *o;
878  lua_lock(L);
879  api_checknelems(L, 1);
880  o = L->top - 1;
881  if (isLfunction(o))
882  status = luaU_dump(L, clvalue(o)->l.p, writer, data, 0);
883  else
884  status = 1;
885  lua_unlock(L);
886  return status;
887 }
LUA_API int() lua_equal ( lua_State L,
int  idx1,
int  idx2 
)

Definiert in Zeile 287 der Datei lapi.c.

287  {
288  StkId o1, o2;
289  int i;
290  lua_lock(L); /* may call tag method */
291  o1 = index2adr(L, index1);
292  o2 = index2adr(L, index2);
293  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0 : equalobj(L, o1, o2);
294  lua_unlock(L);
295  return i;
296 }
LUA_API int() lua_error ( lua_State L)

Definiert in Zeile 964 der Datei lapi.c.

964  {
965  lua_lock(L);
966  api_checknelems(L, 1);
967  luaG_errormsg(L);
968  lua_unlock(L);
969  return 0; /* to avoid warnings */
970 }
LUA_API int() lua_gc ( lua_State L,
int  what,
int  data 
)

Definiert in Zeile 899 der Datei lapi.c.

899  {
900  int res = 0;
901  global_State *g;
902  lua_lock(L);
903  g = G(L);
904  switch (what) {
905  case LUA_GCSTOP: {
906  g->GCthreshold = MAX_LUMEM;
907  break;
908  }
909  case LUA_GCRESTART: {
910  g->GCthreshold = g->totalbytes;
911  break;
912  }
913  case LUA_GCCOLLECT: {
914  luaC_fullgc(L);
915  break;
916  }
917  case LUA_GCCOUNT: {
918  /* GC values are expressed in Kbytes: #bytes/2^10 */
919  res = cast_int(g->totalbytes >> 10);
920  break;
921  }
922  case LUA_GCCOUNTB: {
923  res = cast_int(g->totalbytes & 0x3ff);
924  break;
925  }
926  case LUA_GCSTEP: {
927  lu_mem a = (cast(lu_mem, data) << 10);
928  if (a <= g->totalbytes)
929  g->GCthreshold = g->totalbytes - a;
930  else
931  g->GCthreshold = 0;
932  while (g->GCthreshold <= g->totalbytes) {
933  luaC_step(L);
934  if (g->gcstate == GCSpause) { /* end of cycle? */
935  res = 1; /* signal it */
936  break;
937  }
938  }
939  break;
940  }
941  case LUA_GCSETPAUSE: {
942  res = g->gcpause;
943  g->gcpause = data;
944  break;
945  }
946  case LUA_GCSETSTEPMUL: {
947  res = g->gcstepmul;
948  g->gcstepmul = data;
949  break;
950  }
951  default: res = -1; /* invalid option */
952  }
953  lua_unlock(L);
954  return res;
955 }
LUA_API lua_Alloc() lua_getallocf ( lua_State L,
void **  ud 
)

Definiert in Zeile 1007 der Datei lapi.c.

1007  {
1008  lua_Alloc f;
1009  lua_lock(L);
1010  if (ud) *ud = G(L)->ud;
1011  f = G(L)->frealloc;
1012  lua_unlock(L);
1013  return f;
1014 }
LUA_API void() lua_getfenv ( lua_State L,
int  idx 
)

Definiert in Zeile 616 der Datei lapi.c.

616  {
617  StkId o;
618  lua_lock(L);
619  o = index2adr(L, idx);
620  api_checkvalidindex(L, o);
621  switch (ttype(o)) {
622  case LUA_TFUNCTION:
623  sethvalue(L, L->top, clvalue(o)->c.env);
624  break;
625  case LUA_TUSERDATA:
626  sethvalue(L, L->top, uvalue(o)->env);
627  break;
628  case LUA_TTHREAD:
629  setobj2s(L, L->top, gt(thvalue(o)));
630  break;
631  default:
632  setnilvalue(L->top);
633  break;
634  }
635  api_incr_top(L);
636  lua_unlock(L);
637 }
LUA_API void() lua_getfield ( lua_State L,
int  idx,
const char *  k 
)

Definiert in Zeile 544 der Datei lapi.c.

544  {
545  StkId t;
546  TValue key;
547  lua_lock(L);
548  t = index2adr(L, idx);
549  api_checkvalidindex(L, t);
550  setsvalue(L, &key, luaS_new(L, k));
551  luaV_gettable(L, t, &key, L->top);
552  api_incr_top(L);
553  lua_unlock(L);
554 }
LUA_API lua_Hook lua_gethook ( lua_State L)

Definiert in Zeile 69 der Datei ldebug.c.

69  {
70  return L->hook;
71 }
LUA_API int lua_gethookcount ( lua_State L)

Definiert in Zeile 79 der Datei ldebug.c.

79  {
80  return L->basehookcount;
81 }
LUA_API int lua_gethookmask ( lua_State L)

Definiert in Zeile 74 der Datei ldebug.c.

74  {
75  return L->hookmask;
76 }
LUA_API int lua_getinfo ( lua_State L,
const char *  what,
lua_Debug ar 
)

Definiert in Zeile 232 der Datei ldebug.c.

232  {
233  int status;
234  Closure *f = NULL;
235  CallInfo *ci = NULL;
236  lua_lock(L);
237  if (*what == '>') {
238  StkId func = L->top - 1;
239  luai_apicheck(L, ttisfunction(func));
240  what++; /* skip the '>' */
241  f = clvalue(func);
242  L->top--; /* pop function */
243  }
244  else if (ar->i_ci != 0) { /* no tail call? */
245  ci = L->base_ci + ar->i_ci;
247  f = clvalue(ci->func);
248  }
249  status = auxgetinfo(L, what, ar, f, ci);
250  if (strchr(what, 'f')) {
251  if (f == NULL) setnilvalue(L->top);
252  else setclvalue(L, L->top, f);
253  incr_top(L);
254  }
255  if (strchr(what, 'L'))
256  collectvalidlines(L, f);
257  lua_unlock(L);
258  return status;
259 }
LUA_API const char* lua_getlocal ( lua_State L,
const lua_Debug ar,
int  n 
)

Definiert in Zeile 127 der Datei ldebug.c.

127  {
128  CallInfo *ci = L->base_ci + ar->i_ci;
129  const char *name = findlocal(L, ci, n);
130  lua_lock(L);
131  if (name)
132  luaA_pushobject(L, ci->base + (n - 1));
133  lua_unlock(L);
134  return name;
135 }
LUA_API int() lua_getmetatable ( lua_State L,
int  objindex 
)

Definiert in Zeile 587 der Datei lapi.c.

587  {
588  const TValue *obj;
589  Table *mt = NULL;
590  int res;
591  lua_lock(L);
592  obj = index2adr(L, objindex);
593  switch (ttype(obj)) {
594  case LUA_TTABLE:
595  mt = hvalue(obj)->metatable;
596  break;
597  case LUA_TUSERDATA:
598  mt = uvalue(obj)->metatable;
599  break;
600  default:
601  mt = G(L)->mt[ttype(obj)];
602  break;
603  }
604  if (mt == NULL)
605  res = 0;
606  else {
607  sethvalue(L, L->top, mt);
608  api_incr_top(L);
609  res = 1;
610  }
611  lua_unlock(L);
612  return res;
613 }
LUA_API int lua_getstack ( lua_State L,
int  level,
lua_Debug ar 
)

Definiert in Zeile 84 der Datei ldebug.c.

84  {
85  int status;
86  CallInfo *ci;
87  lua_lock(L);
88  for (ci = L->ci; level > 0 && ci > L->base_ci; ci--) {
89  level--;
90  if (f_isLua(ci)) /* Lua function? */
91  level -= ci->tailcalls; /* skip lost tail calls */
92  }
93  if (level == 0 && ci > L->base_ci) { /* level found? */
94  status = 1;
95  ar->i_ci = cast_int(ci - L->base_ci);
96  }
97  else if (level < 0) { /* level is of a lost tail call? */
98  status = 1;
99  ar->i_ci = 0;
100  }
101  else status = 0; /* no such level */
102  lua_unlock(L);
103  return status;
104 }
LUA_API void() lua_gettable ( lua_State L,
int  idx 
)

Definiert in Zeile 534 der Datei lapi.c.

534  {
535  StkId t;
536  lua_lock(L);
537  t = index2adr(L, idx);
538  api_checkvalidindex(L, t);
539  luaV_gettable(L, t, L->top - 1, L->top - 1);
540  lua_unlock(L);
541 }
LUA_API int() lua_gettop ( lua_State L)

Definiert in Zeile 159 der Datei lapi.c.

159  {
160  return cast_int(L->top - L->base);
161 }
LUA_API const char* lua_getupvalue ( lua_State L,
int  funcindex,
int  n 
)

Definiert in Zeile 1057 der Datei lapi.c.

1057  {
1058  const char *name;
1059  TValue *val;
1060  lua_lock(L);
1061  name = aux_upvalue(index2adr(L, funcindex), n, &val);
1062  if (name) {
1063  setobj2s(L, L->top, val);
1064  api_incr_top(L);
1065  }
1066  lua_unlock(L);
1067  return name;
1068 }
LUA_API void() lua_insert ( lua_State L,
int  idx 
)

Definiert in Zeile 191 der Datei lapi.c.

191  {
192  StkId p;
193  StkId q;
194  lua_lock(L);
195  p = index2adr(L, idx);
196  api_checkvalidindex(L, p);
197  for (q = L->top; q>p; q--) setobjs2s(L, q, q-1);
198  setobjs2s(L, p, L->top);
199  lua_unlock(L);
200 }
LUA_API int() lua_iscfunction ( lua_State L,
int  idx 
)

Definiert in Zeile 254 der Datei lapi.c.

254  {
255  StkId o = index2adr(L, idx);
256  return iscfunction(o);
257 }
LUA_API int() lua_isnumber ( lua_State L,
int  idx 
)

Definiert in Zeile 260 der Datei lapi.c.

260  {
261  TValue n;
262  const TValue *o = index2adr(L, idx);
263  return tonumber(o, &n);
264 }
LUA_API int() lua_isstring ( lua_State L,
int  idx 
)

Definiert in Zeile 267 der Datei lapi.c.

267  {
268  int t = lua_type(L, idx);
269  return (t == LUA_TSTRING || t == LUA_TNUMBER);
270 }
LUA_API int() lua_isuserdata ( lua_State L,
int  idx 
)

Definiert in Zeile 273 der Datei lapi.c.

273  {
274  const TValue *o = index2adr(L, idx);
275  return (ttisuserdata(o) || ttislightuserdata(o));
276 }
LUA_API int() lua_lessthan ( lua_State L,
int  idx1,
int  idx2 
)

Definiert in Zeile 299 der Datei lapi.c.

299  {
300  StkId o1, o2;
301  int i;
302  lua_lock(L); /* may call tag method */
303  o1 = index2adr(L, index1);
304  o2 = index2adr(L, index2);
305  i = (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
306  : luaV_lessthan(L, o1, o2);
307  lua_unlock(L);
308  return i;
309 }
LUA_API int() lua_load ( lua_State L,
lua_Reader  reader,
void *  dt,
const char *  chunkname 
)

Definiert in Zeile 862 der Datei lapi.c.

863  {
864  ZIO z;
865  int status;
866  lua_lock(L);
867  if (!chunkname) chunkname = "?";
868  luaZ_init(L, &z, reader, data);
869  status = luaD_protectedparser(L, &z, chunkname);
870  lua_unlock(L);
871  return status;
872 }
LUA_API lua_State*() lua_newstate ( lua_Alloc  f,
void *  ud 
)

Definiert in Zeile 143 der Datei lstate.c.

143  {
144  int i;
145  lua_State *L;
146  global_State *g;
147  void *l = (*f)(ud, NULL, 0, state_size(LG));
148  if (l == NULL) return NULL;
149  L = tostate(l);
150  g = &((LG *)L)->g;
151  L->next = NULL;
152  L->tt = LUA_TTHREAD;
154  L->marked = luaC_white(g);
155  set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
156  preinit_state(L, g);
157  g->frealloc = f;
158  g->ud = ud;
159  g->mainthread = L;
160  g->uvhead.u.l.prev = &g->uvhead;
161  g->uvhead.u.l.next = &g->uvhead;
162  g->GCthreshold = 0; /* mark it as unfinished state */
163  g->strt.size = 0;
164  g->strt.nuse = 0;
165  g->strt.hash = NULL;
166  setnilvalue(registry(L));
167  luaZ_initbuffer(L, &g->buff);
168  g->panic = NULL;
169  g->gcstate = GCSpause;
170  g->rootgc = obj2gco(L);
171  g->sweepstrgc = 0;
172  g->sweepgc = &g->rootgc;
173  g->gray = NULL;
174  g->grayagain = NULL;
175  g->weak = NULL;
176  g->tmudata = NULL;
177  g->totalbytes = sizeof(LG);
178  g->gcpause = LUAI_GCPAUSE;
179  g->gcstepmul = LUAI_GCMUL;
180  g->gcdept = 0;
181  for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
182  if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
183  /* memory allocation error: free partial state */
184  close_state(L);
185  L = NULL;
186  }
187  else
189  return L;
190 }
LUA_API lua_State*() lua_newthread ( lua_State L)

Definiert in Zeile 140 der Datei lapi.c.

140  {
141  lua_State *L1;
142  lua_lock(L);
143  luaC_checkGC(L);
144  L1 = luaE_newthread(L);
145  setthvalue(L, L->top, L1);
146  api_incr_top(L);
147  lua_unlock(L);
148  luai_userstatethread(L, L1);
149  return L1;
150 }
LUA_API void*() lua_newuserdata ( lua_State L,
size_t  sz 
)

Definiert in Zeile 1025 der Datei lapi.c.

1025  {
1026  Udata *u;
1027  lua_lock(L);
1028  luaC_checkGC(L);
1029  u = luaS_newudata(L, size, getcurrenv(L));
1030  setuvalue(L, L->top, u);
1031  api_incr_top(L);
1032  lua_unlock(L);
1033  return u + 1;
1034 }
LUA_API int() lua_next ( lua_State L,
int  idx 
)

Definiert in Zeile 973 der Datei lapi.c.

973  {
974  StkId t;
975  int more;
976  lua_lock(L);
977  t = index2adr(L, idx);
978  api_check(L, ttistable(t));
979  more = luaH_next(L, hvalue(t), L->top - 1);
980  if (more) {
981  api_incr_top(L);
982  }
983  else /* no more elements */
984  L->top -= 1; /* remove key */
985  lua_unlock(L);
986  return more;
987 }
LUA_API size_t() lua_objlen ( lua_State L,
int  idx 
)

Definiert in Zeile 361 der Datei lapi.c.

361  {
362  StkId o = index2adr(L, idx);
363  switch (ttype(o)) {
364  case LUA_TSTRING: return tsvalue(o)->len;
365  case LUA_TUSERDATA: return uvalue(o)->len;
366  case LUA_TTABLE: return luaH_getn(hvalue(o));
367  case LUA_TNUMBER: {
368  size_t l;
369  lua_lock(L); /* `luaV_tostring' may create a new string */
370  l = (luaV_tostring(L, o) ? tsvalue(o)->len : 0);
371  lua_unlock(L);
372  return l;
373  }
374  default: return 0;
375  }
376 }
LUA_API int() lua_pcall ( lua_State L,
int  nargs,
int  nresults,
int  errfunc 
)

Definiert in Zeile 805 der Datei lapi.c.

805  {
806  struct CallS c;
807  int status;
808  ptrdiff_t func;
809  lua_lock(L);
810  api_checknelems(L, nargs+1);
811  checkresults(L, nargs, nresults);
812  if (errfunc == 0)
813  func = 0;
814  else {
815  StkId o = index2adr(L, errfunc);
816  api_checkvalidindex(L, o);
817  func = savestack(L, o);
818  }
819  c.func = L->top - (nargs+1); /* function to be called */
820  c.nresults = nresults;
821  status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
823  lua_unlock(L);
824  return status;
825 }
LUA_API void() lua_pushboolean ( lua_State L,
int  b 
)

Definiert in Zeile 503 der Datei lapi.c.

503  {
504  lua_lock(L);
505  setbvalue(L->top, (b != 0)); /* ensure that true is 1 */
506  api_incr_top(L);
507  lua_unlock(L);
508 }
LUA_API void() lua_pushcclosure ( lua_State L,
lua_CFunction  fn,
int  n 
)

Definiert in Zeile 486 der Datei lapi.c.

486  {
487  Closure *cl;
488  lua_lock(L);
489  luaC_checkGC(L);
490  api_checknelems(L, n);
491  cl = luaF_newCclosure(L, n, getcurrenv(L));
492  cl->c.f = fn;
493  L->top -= n;
494  while (n--)
495  setobj2n(L, &cl->c.upvalue[n], L->top+n);
496  setclvalue(L, L->top, cl);
497  lua_assert(iswhite(obj2gco(cl)));
498  api_incr_top(L);
499  lua_unlock(L);
500 }
LUA_API const char*() lua_pushfstring ( lua_State L,
const char *  fmt,
  ... 
)

Definiert in Zeile 473 der Datei lapi.c.

473  {
474  const char *ret;
475  va_list argp;
476  lua_lock(L);
477  luaC_checkGC(L);
478  va_start(argp, fmt);
479  ret = luaO_pushvfstring(L, fmt, argp);
480  va_end(argp);
481  lua_unlock(L);
482  return ret;
483 }
LUA_API void() lua_pushinteger ( lua_State L,
lua_Integer  n 
)

Definiert in Zeile 437 der Datei lapi.c.

437  {
438  lua_lock(L);
439  setnvalue(L->top, cast_num(n));
440  api_incr_top(L);
441  lua_unlock(L);
442 }
LUA_API void() lua_pushlightuserdata ( lua_State L,
void *  p 
)

Definiert in Zeile 511 der Datei lapi.c.

511  {
512  lua_lock(L);
513  setpvalue(L->top, p);
514  api_incr_top(L);
515  lua_unlock(L);
516 }
LUA_API void() lua_pushlstring ( lua_State L,
const char *  s,
size_t  l 
)

Definiert in Zeile 445 der Datei lapi.c.

445  {
446  lua_lock(L);
447  luaC_checkGC(L);
448  setsvalue2s(L, L->top, luaS_newlstr(L, s, len));
449  api_incr_top(L);
450  lua_unlock(L);
451 }
LUA_API void() lua_pushnil ( lua_State L)

Definiert in Zeile 421 der Datei lapi.c.

421  {
422  lua_lock(L);
423  setnilvalue(L->top);
424  api_incr_top(L);
425  lua_unlock(L);
426 }
LUA_API void() lua_pushnumber ( lua_State L,
lua_Number  n 
)

Definiert in Zeile 429 der Datei lapi.c.

429  {
430  lua_lock(L);
431  setnvalue(L->top, n);
432  api_incr_top(L);
433  lua_unlock(L);
434 }
LUA_API void() lua_pushstring ( lua_State L,
const char *  s 
)

Definiert in Zeile 454 der Datei lapi.c.

454  {
455  if (s == NULL)
456  lua_pushnil(L);
457  else
458  lua_pushlstring(L, s, strlen(s));
459 }
LUA_API int() lua_pushthread ( lua_State L)

Definiert in Zeile 519 der Datei lapi.c.

519  {
520  lua_lock(L);
521  setthvalue(L, L->top, L);
522  api_incr_top(L);
523  lua_unlock(L);
524  return (G(L)->mainthread == L);
525 }
LUA_API void() lua_pushvalue ( lua_State L,
int  idx 
)

Definiert in Zeile 228 der Datei lapi.c.

228  {
229  lua_lock(L);
230  setobj2s(L, L->top, index2adr(L, idx));
231  api_incr_top(L);
232  lua_unlock(L);
233 }
LUA_API const char*() lua_pushvfstring ( lua_State L,
const char *  fmt,
va_list  argp 
)

Definiert in Zeile 462 der Datei lapi.c.

463  {
464  const char *ret;
465  lua_lock(L);
466  luaC_checkGC(L);
467  ret = luaO_pushvfstring(L, fmt, argp);
468  lua_unlock(L);
469  return ret;
470 }
LUA_API int() lua_rawequal ( lua_State L,
int  idx1,
int  idx2 
)

Definiert in Zeile 279 der Datei lapi.c.

279  {
280  StkId o1 = index2adr(L, index1);
281  StkId o2 = index2adr(L, index2);
282  return (o1 == luaO_nilobject || o2 == luaO_nilobject) ? 0
283  : luaO_rawequalObj(o1, o2);
284 }
LUA_API void() lua_rawget ( lua_State L,
int  idx 
)

Definiert in Zeile 557 der Datei lapi.c.

557  {
558  StkId t;
559  lua_lock(L);
560  t = index2adr(L, idx);
561  api_check(L, ttistable(t));
562  setobj2s(L, L->top - 1, luaH_get(hvalue(t), L->top - 1));
563  lua_unlock(L);
564 }
LUA_API void() lua_rawgeti ( lua_State L,
int  idx,
int  n 
)

Definiert in Zeile 567 der Datei lapi.c.

567  {
568  StkId o;
569  lua_lock(L);
570  o = index2adr(L, idx);
571  api_check(L, ttistable(o));
572  setobj2s(L, L->top, luaH_getnum(hvalue(o), n));
573  api_incr_top(L);
574  lua_unlock(L);
575 }
LUA_API void() lua_rawset ( lua_State L,
int  idx 
)

Definiert in Zeile 671 der Datei lapi.c.

671  {
672  StkId t;
673  lua_lock(L);
674  api_checknelems(L, 2);
675  t = index2adr(L, idx);
676  api_check(L, ttistable(t));
677  setobj2t(L, luaH_set(L, hvalue(t), L->top-2), L->top-1);
678  luaC_barriert(L, hvalue(t), L->top-1);
679  L->top -= 2;
680  lua_unlock(L);
681 }
LUA_API void() lua_rawseti ( lua_State L,
int  idx,
int  n 
)

Definiert in Zeile 684 der Datei lapi.c.

684  {
685  StkId o;
686  lua_lock(L);
687  api_checknelems(L, 1);
688  o = index2adr(L, idx);
689  api_check(L, ttistable(o));
690  setobj2t(L, luaH_setnum(L, hvalue(o), n), L->top-1);
691  luaC_barriert(L, hvalue(o), L->top-1);
692  L->top--;
693  lua_unlock(L);
694 }
LUA_API void() lua_remove ( lua_State L,
int  idx 
)

Definiert in Zeile 180 der Datei lapi.c.

180  {
181  StkId p;
182  lua_lock(L);
183  p = index2adr(L, idx);
184  api_checkvalidindex(L, p);
185  while (++p < L->top) setobjs2s(L, p-1, p);
186  L->top--;
187  lua_unlock(L);
188 }
LUA_API void() lua_replace ( lua_State L,
int  idx 
)

Definiert in Zeile 203 der Datei lapi.c.

203  {
204  StkId o;
205  lua_lock(L);
206  /* explicit test for incompatible code */
207  if (idx == LUA_ENVIRONINDEX && L->ci == L->base_ci)
208  luaG_runerror(L, "no calling environment");
209  api_checknelems(L, 1);
210  o = index2adr(L, idx);
211  api_checkvalidindex(L, o);
212  if (idx == LUA_ENVIRONINDEX) {
213  Closure *func = curr_func(L);
214  api_check(L, ttistable(L->top - 1));
215  func->c.env = hvalue(L->top - 1);
216  luaC_barrier(L, func, L->top - 1);
217  }
218  else {
219  setobj(L, o, L->top - 1);
220  if (idx < LUA_GLOBALSINDEX) /* function upvalue? */
221  luaC_barrier(L, curr_func(L), L->top - 1);
222  }
223  L->top--;
224  lua_unlock(L);
225 }
LUA_API int() lua_resume ( lua_State L,
int  narg 
)

Definiert in Zeile 418 der Datei ldo.c.

418  {
419  int status;
420  lua_lock(L);
421  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
422  return resume_error(L, "cannot resume non-suspended coroutine");
423  if (L->nCcalls >= LUAI_MAXCCALLS)
424  return resume_error(L, "C stack overflow");
425  luai_userstateresume(L, nargs);
426  lua_assert(L->errfunc == 0);
427  L->baseCcalls = ++L->nCcalls;
428  status = luaD_rawrunprotected(L, resume, L->top - nargs);
429  if (status != 0) { /* error? */
430  L->status = cast_byte(status); /* mark thread as `dead' */
431  luaD_seterrorobj(L, status, L->top);
432  L->ci->top = L->top;
433  }
434  else {
435  lua_assert(L->nCcalls == L->baseCcalls);
436  status = L->status;
437  }
438  --L->nCcalls;
439  lua_unlock(L);
440  return status;
441 }
LUA_API void lua_setallocf ( lua_State L,
lua_Alloc  f,
void *  ud 
)

Definiert in Zeile 1017 der Datei lapi.c.

1017  {
1018  lua_lock(L);
1019  G(L)->ud = ud;
1020  G(L)->frealloc = f;
1021  lua_unlock(L);
1022 }
LUA_API int() lua_setfenv ( lua_State L,
int  idx 
)

Definiert in Zeile 734 der Datei lapi.c.

734  {
735  StkId o;
736  int res = 1;
737  lua_lock(L);
738  api_checknelems(L, 1);
739  o = index2adr(L, idx);
740  api_checkvalidindex(L, o);
741  api_check(L, ttistable(L->top - 1));
742  switch (ttype(o)) {
743  case LUA_TFUNCTION:
744  clvalue(o)->c.env = hvalue(L->top - 1);
745  break;
746  case LUA_TUSERDATA:
747  uvalue(o)->env = hvalue(L->top - 1);
748  break;
749  case LUA_TTHREAD:
750  sethvalue(L, gt(thvalue(o)), hvalue(L->top - 1));
751  break;
752  default:
753  res = 0;
754  break;
755  }
756  if (res) luaC_objbarrier(L, gcvalue(o), hvalue(L->top - 1));
757  L->top--;
758  lua_unlock(L);
759  return res;
760 }
LUA_API void() lua_setfield ( lua_State L,
int  idx,
const char *  k 
)

Definiert in Zeile 657 der Datei lapi.c.

657  {
658  StkId t;
659  TValue key;
660  lua_lock(L);
661  api_checknelems(L, 1);
662  t = index2adr(L, idx);
663  api_checkvalidindex(L, t);
664  setsvalue(L, &key, luaS_new(L, k));
665  luaV_settable(L, t, &key, L->top - 1);
666  L->top--; /* pop value */
667  lua_unlock(L);
668 }
LUA_API int lua_sethook ( lua_State L,
lua_Hook  func,
int  mask,
int  count 
)

Definiert in Zeile 56 der Datei ldebug.c.

56  {
57  if (func == NULL || mask == 0) { /* turn off hooks? */
58  mask = 0;
59  func = NULL;
60  }
61  L->hook = func;
62  L->basehookcount = count;
63  resethookcount(L);
64  L->hookmask = cast_byte(mask);
65  return 1;
66 }
LUA_API void lua_setlevel ( lua_State from,
lua_State to 
)

Definiert in Zeile 125 der Datei lapi.c.

125  {
126  to->nCcalls = from->nCcalls;
127 }
LUA_API const char* lua_setlocal ( lua_State L,
const lua_Debug ar,
int  n 
)

Definiert in Zeile 138 der Datei ldebug.c.

138  {
139  CallInfo *ci = L->base_ci + ar->i_ci;
140  const char *name = findlocal(L, ci, n);
141  lua_lock(L);
142  if (name)
143  setobjs2s(L, ci->base + (n - 1), L->top - 1);
144  L->top--; /* pop value */
145  lua_unlock(L);
146  return name;
147 }
LUA_API int() lua_setmetatable ( lua_State L,
int  objindex 
)

Definiert in Zeile 697 der Datei lapi.c.

697  {
698  TValue *obj;
699  Table *mt;
700  lua_lock(L);
701  api_checknelems(L, 1);
702  obj = index2adr(L, objindex);
703  api_checkvalidindex(L, obj);
704  if (ttisnil(L->top - 1))
705  mt = NULL;
706  else {
707  api_check(L, ttistable(L->top - 1));
708  mt = hvalue(L->top - 1);
709  }
710  switch (ttype(obj)) {
711  case LUA_TTABLE: {
712  hvalue(obj)->metatable = mt;
713  if (mt)
714  luaC_objbarriert(L, hvalue(obj), mt);
715  break;
716  }
717  case LUA_TUSERDATA: {
718  uvalue(obj)->metatable = mt;
719  if (mt)
720  luaC_objbarrier(L, rawuvalue(obj), mt);
721  break;
722  }
723  default: {
724  G(L)->mt[ttype(obj)] = mt;
725  break;
726  }
727  }
728  L->top--;
729  lua_unlock(L);
730  return 1;
731 }
LUA_API void() lua_settable ( lua_State L,
int  idx 
)

Definiert in Zeile 645 der Datei lapi.c.

645  {
646  StkId t;
647  lua_lock(L);
648  api_checknelems(L, 2);
649  t = index2adr(L, idx);
650  api_checkvalidindex(L, t);
651  luaV_settable(L, t, L->top - 2, L->top - 1);
652  L->top -= 2; /* pop index and value */
653  lua_unlock(L);
654 }
LUA_API void() lua_settop ( lua_State L,
int  idx 
)

Definiert in Zeile 164 der Datei lapi.c.

164  {
165  lua_lock(L);
166  if (idx >= 0) {
167  api_check(L, idx <= L->stack_last - L->base);
168  while (L->top < L->base + idx)
169  setnilvalue(L->top++);
170  L->top = L->base + idx;
171  }
172  else {
173  api_check(L, -(idx+1) <= (L->top - L->base));
174  L->top += idx+1; /* `subtract' index (index is negative) */
175  }
176  lua_unlock(L);
177 }
LUA_API const char* lua_setupvalue ( lua_State L,
int  funcindex,
int  n 
)

Definiert in Zeile 1071 der Datei lapi.c.

1071  {
1072  const char *name;
1073  TValue *val;
1074  StkId fi;
1075  lua_lock(L);
1076  fi = index2adr(L, funcindex);
1077  api_checknelems(L, 1);
1078  name = aux_upvalue(fi, n, &val);
1079  if (name) {
1080  L->top--;
1081  setobj(L, val, L->top);
1082  luaC_barrier(L, clvalue(fi), L->top);
1083  }
1084  lua_unlock(L);
1085  return name;
1086 }
LUA_API int() lua_status ( lua_State L)

Definiert in Zeile 890 der Datei lapi.c.

890  {
891  return L->status;
892 }
LUA_API int() lua_toboolean ( lua_State L,
int  idx 
)

Definiert in Zeile 337 der Datei lapi.c.

337  {
338  const TValue *o = index2adr(L, idx);
339  return !l_isfalse(o);
340 }
LUA_API lua_CFunction() lua_tocfunction ( lua_State L,
int  idx 
)

Definiert in Zeile 379 der Datei lapi.c.

379  {
380  StkId o = index2adr(L, idx);
381  return (!iscfunction(o)) ? NULL : clvalue(o)->c.f;
382 }
LUA_API lua_Integer() lua_tointeger ( lua_State L,
int  idx 
)

Definiert in Zeile 323 der Datei lapi.c.

323  {
324  TValue n;
325  const TValue *o = index2adr(L, idx);
326  if (tonumber(o, &n)) {
327  lua_Integer res;
328  lua_Number num = nvalue(o);
329  lua_number2integer(res, num);
330  return res;
331  }
332  else
333  return 0;
334 }
LUA_API const char*() lua_tolstring ( lua_State L,
int  idx,
size_t len 
)

Definiert in Zeile 343 der Datei lapi.c.

343  {
344  StkId o = index2adr(L, idx);
345  if (!ttisstring(o)) {
346  lua_lock(L); /* `luaV_tostring' may create a new string */
347  if (!luaV_tostring(L, o)) { /* conversion failed? */
348  if (len != NULL) *len = 0;
349  lua_unlock(L);
350  return NULL;
351  }
352  luaC_checkGC(L);
353  o = index2adr(L, idx); /* previous call may reallocate the stack */
354  lua_unlock(L);
355  }
356  if (len != NULL) *len = tsvalue(o)->len;
357  return svalue(o);
358 }
LUA_API lua_Number() lua_tonumber ( lua_State L,
int  idx 
)

Definiert in Zeile 313 der Datei lapi.c.

313  {
314  TValue n;
315  const TValue *o = index2adr(L, idx);
316  if (tonumber(o, &n))
317  return nvalue(o);
318  else
319  return 0;
320 }
LUA_API const void*() lua_topointer ( lua_State L,
int  idx 
)

Definiert in Zeile 401 der Datei lapi.c.

401  {
402  StkId o = index2adr(L, idx);
403  switch (ttype(o)) {
404  case LUA_TTABLE: return hvalue(o);
405  case LUA_TFUNCTION: return clvalue(o);
406  case LUA_TTHREAD: return thvalue(o);
407  case LUA_TUSERDATA:
408  case LUA_TLIGHTUSERDATA:
409  return lua_touserdata(L, idx);
410  default: return NULL;
411  }
412 }
LUA_API lua_State*() lua_tothread ( lua_State L,
int  idx 
)

Definiert in Zeile 395 der Datei lapi.c.

395  {
396  StkId o = index2adr(L, idx);
397  return (!ttisthread(o)) ? NULL : thvalue(o);
398 }
LUA_API void*() lua_touserdata ( lua_State L,
int  idx 
)

Definiert in Zeile 385 der Datei lapi.c.

385  {
386  StkId o = index2adr(L, idx);
387  switch (ttype(o)) {
388  case LUA_TUSERDATA: return (rawuvalue(o) + 1);
389  case LUA_TLIGHTUSERDATA: return pvalue(o);
390  default: return NULL;
391  }
392 }
LUA_API int() lua_type ( lua_State L,
int  idx 
)

Definiert in Zeile 242 der Datei lapi.c.

242  {
243  StkId o = index2adr(L, idx);
244  return (o == luaO_nilobject) ? LUA_TNONE : ttype(o);
245 }
LUA_API const char*() lua_typename ( lua_State L,
int  tp 
)

Definiert in Zeile 248 der Datei lapi.c.

248  {
249  UNUSED(L);
250  return (t == LUA_TNONE) ? "no value" : luaT_typenames[t];
251 }
LUA_API void() lua_xmove ( lua_State from,
lua_State to,
int  n 
)

Definiert in Zeile 110 der Datei lapi.c.

110  {
111  int i;
112  if (from == to) return;
113  lua_lock(to);
114  api_checknelems(from, n);
115  api_check(from, G(from) == G(to));
116  api_check(from, to->ci->top - to->top >= n);
117  from->top -= n;
118  for (i = 0; i < n; i++) {
119  setobj2s(to, to->top++, from->top + i);
120  }
121  lua_unlock(to);
122 }
LUA_API int() lua_yield ( lua_State L,
int  nresults 
)

Definiert in Zeile 444 der Datei ldo.c.

444  {
446  lua_lock(L);
447  if (L->nCcalls > L->baseCcalls)
448  luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
449  L->base = L->top - nresults; /* protect stack slots below */
450  L->status = LUA_YIELD;
451  lua_unlock(L);
452  return -1;
453 }