@ -1,256 +0,0 @@ | |||||
/* | |||||
** $Id: lauxlib.h,v 1.129 2015/11/23 11:29:43 roberto Exp $ | |||||
** Auxiliary functions for building Lua libraries | |||||
** See Copyright Notice in lua.h | |||||
*/ | |||||
#ifndef lauxlib_h | |||||
#define lauxlib_h | |||||
#include <stddef.h> | |||||
#include <stdio.h> | |||||
#include "lua.h" | |||||
/* extra error code for 'luaL_load' */ | |||||
#define LUA_ERRFILE (LUA_ERRERR+1) | |||||
typedef struct luaL_Reg { | |||||
const char *name; | |||||
lua_CFunction func; | |||||
} luaL_Reg; | |||||
#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) | |||||
LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); | |||||
#define luaL_checkversion(L) \ | |||||
luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) | |||||
LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); | |||||
LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); | |||||
LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); | |||||
LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); | |||||
LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, | |||||
size_t *l); | |||||
LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, | |||||
const char *def, size_t *l); | |||||
LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); | |||||
LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); | |||||
LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); | |||||
LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, | |||||
lua_Integer def); | |||||
LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); | |||||
LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); | |||||
LUALIB_API void (luaL_checkany) (lua_State *L, int arg); | |||||
LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); | |||||
LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); | |||||
LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); | |||||
LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); | |||||
LUALIB_API void (luaL_where) (lua_State *L, int lvl); | |||||
LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); | |||||
LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, | |||||
const char *const lst[]); | |||||
LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); | |||||
LUALIB_API int (luaL_execresult) (lua_State *L, int stat); | |||||
/* predefined references */ | |||||
#define LUA_NOREF (-2) | |||||
#define LUA_REFNIL (-1) | |||||
LUALIB_API int (luaL_ref) (lua_State *L, int t); | |||||
LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); | |||||
LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, | |||||
const char *mode); | |||||
#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) | |||||
LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, | |||||
const char *name, const char *mode); | |||||
LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); | |||||
LUALIB_API lua_State *(luaL_newstate) (void); | |||||
LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); | |||||
LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, | |||||
const char *r); | |||||
LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); | |||||
LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); | |||||
LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, | |||||
const char *msg, int level); | |||||
LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, | |||||
lua_CFunction openf, int glb); | |||||
/* | |||||
** =============================================================== | |||||
** some useful macros | |||||
** =============================================================== | |||||
*/ | |||||
#define luaL_newlibtable(L,l) \ | |||||
lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) | |||||
#define luaL_newlib(L,l) \ | |||||
(luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) | |||||
#define luaL_argcheck(L, cond,arg,extramsg) \ | |||||
((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) | |||||
#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) | |||||
#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) | |||||
#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) | |||||
#define luaL_dofile(L, fn) \ | |||||
(luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) | |||||
#define luaL_dostring(L, s) \ | |||||
(luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) | |||||
#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) | |||||
#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) | |||||
#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) | |||||
/* | |||||
** {====================================================== | |||||
** Generic Buffer manipulation | |||||
** ======================================================= | |||||
*/ | |||||
typedef struct luaL_Buffer { | |||||
char *b; /* buffer address */ | |||||
size_t size; /* buffer size */ | |||||
size_t n; /* number of characters in buffer */ | |||||
lua_State *L; | |||||
char initb[LUAL_BUFFERSIZE]; /* initial buffer */ | |||||
} luaL_Buffer; | |||||
#define luaL_addchar(B,c) \ | |||||
((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ | |||||
((B)->b[(B)->n++] = (c))) | |||||
#define luaL_addsize(B,s) ((B)->n += (s)) | |||||
LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); | |||||
LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); | |||||
LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); | |||||
LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); | |||||
LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); | |||||
LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); | |||||
LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); | |||||
LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); | |||||
#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) | |||||
/* }====================================================== */ | |||||
/* | |||||
** {====================================================== | |||||
** File handles for IO library | |||||
** ======================================================= | |||||
*/ | |||||
/* | |||||
** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and | |||||
** initial structure 'luaL_Stream' (it may contain other fields | |||||
** after that initial structure). | |||||
*/ | |||||
#define LUA_FILEHANDLE "FILE*" | |||||
typedef struct luaL_Stream { | |||||
FILE *f; /* stream (NULL for incompletely created streams) */ | |||||
lua_CFunction closef; /* to close stream (NULL for closed streams) */ | |||||
} luaL_Stream; | |||||
/* }====================================================== */ | |||||
/* compatibility with old module system */ | |||||
#if defined(LUA_COMPAT_MODULE) | |||||
LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname, | |||||
int sizehint); | |||||
LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname, | |||||
const luaL_Reg *l, int nup); | |||||
#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0)) | |||||
#endif | |||||
/* | |||||
** {================================================================== | |||||
** "Abstraction Layer" for basic report of messages and errors | |||||
** =================================================================== | |||||
*/ | |||||
/* print a string */ | |||||
#if !defined(lua_writestring) | |||||
#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) | |||||
#endif | |||||
/* print a newline and flush the output */ | |||||
#if !defined(lua_writeline) | |||||
#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) | |||||
#endif | |||||
/* print an error message */ | |||||
#if !defined(lua_writestringerror) | |||||
#define lua_writestringerror(s,p) \ | |||||
(fprintf(stderr, (s), (p)), fflush(stderr)) | |||||
#endif | |||||
/* }================================================================== */ | |||||
/* | |||||
** {============================================================ | |||||
** Compatibility with deprecated conversions | |||||
** ============================================================= | |||||
*/ | |||||
#if defined(LUA_COMPAT_APIINTCASTS) | |||||
#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) | |||||
#define luaL_optunsigned(L,a,d) \ | |||||
((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) | |||||
#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) | |||||
#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) | |||||
#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) | |||||
#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) | |||||
#endif | |||||
/* }============================================================ */ | |||||
#endif | |||||
@ -1,486 +0,0 @@ | |||||
/* | |||||
** $Id: lua.h,v 1.331 2016/05/30 15:53:28 roberto Exp $ | |||||
** Lua - A Scripting Language | |||||
** Lua.org, PUC-Rio, Brazil (http://www.lua.org) | |||||
** See Copyright Notice at the end of this file | |||||
*/ | |||||
#ifndef lua_h | |||||
#define lua_h | |||||
#include <stdarg.h> | |||||
#include <stddef.h> | |||||
#include "luaconf.h" | |||||
#define LUA_VERSION_MAJOR "5" | |||||
#define LUA_VERSION_MINOR "3" | |||||
#define LUA_VERSION_NUM 503 | |||||
#define LUA_VERSION_RELEASE "3" | |||||
#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR | |||||
#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE | |||||
#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2016 Lua.org, PUC-Rio" | |||||
#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" | |||||
/* mark for precompiled code ('<esc>Lua') */ | |||||
#define LUA_SIGNATURE "\x1bLua" | |||||
/* option for multiple returns in 'lua_pcall' and 'lua_call' */ | |||||
#define LUA_MULTRET (-1) | |||||
/* | |||||
** Pseudo-indices | |||||
** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty | |||||
** space after that to help overflow detection) | |||||
*/ | |||||
#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | |||||
#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) | |||||
/* thread status */ | |||||
#define LUA_OK 0 | |||||
#define LUA_YIELD 1 | |||||
#define LUA_ERRRUN 2 | |||||
#define LUA_ERRSYNTAX 3 | |||||
#define LUA_ERRMEM 4 | |||||
#define LUA_ERRGCMM 5 | |||||
#define LUA_ERRERR 6 | |||||
typedef struct lua_State lua_State; | |||||
/* | |||||
** basic types | |||||
*/ | |||||
#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_NUMTAGS 9 | |||||
/* minimum Lua stack available to a C function */ | |||||
#define LUA_MINSTACK 20 | |||||
/* predefined values in the registry */ | |||||
#define LUA_RIDX_MAINTHREAD 1 | |||||
#define LUA_RIDX_GLOBALS 2 | |||||
#define LUA_RIDX_LAST LUA_RIDX_GLOBALS | |||||
/* type of numbers in Lua */ | |||||
typedef LUA_NUMBER lua_Number; | |||||
/* type for integer functions */ | |||||
typedef LUA_INTEGER lua_Integer; | |||||
/* unsigned integer type */ | |||||
typedef LUA_UNSIGNED lua_Unsigned; | |||||
/* type for continuation-function contexts */ | |||||
typedef LUA_KCONTEXT lua_KContext; | |||||
/* | |||||
** Type for C functions registered with Lua | |||||
*/ | |||||
typedef int (*lua_CFunction) (lua_State *L); | |||||
/* | |||||
** Type for continuation functions | |||||
*/ | |||||
typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); | |||||
/* | |||||
** Type for functions that read/write blocks when loading/dumping Lua chunks | |||||
*/ | |||||
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); | |||||
/* | |||||
** Type for memory-allocation functions | |||||
*/ | |||||
typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); | |||||
/* | |||||
** generic extra include file | |||||
*/ | |||||
#if defined(LUA_USER_H) | |||||
#include LUA_USER_H | |||||
#endif | |||||
/* | |||||
** RCS ident string | |||||
*/ | |||||
extern const char lua_ident[]; | |||||
/* | |||||
** state manipulation | |||||
*/ | |||||
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 const lua_Number *(lua_version) (lua_State *L); | |||||
/* | |||||
** basic stack manipulation | |||||
*/ | |||||
LUA_API int (lua_absindex) (lua_State *L, int idx); | |||||
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_rotate) (lua_State *L, int idx, int n); | |||||
LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); | |||||
LUA_API int (lua_checkstack) (lua_State *L, int n); | |||||
LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); | |||||
/* | |||||
** access functions (stack -> C) | |||||
*/ | |||||
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_isinteger) (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 lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); | |||||
LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); | |||||
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_rawlen) (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); | |||||
/* | |||||
** Comparison and arithmetic functions | |||||
*/ | |||||
#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ | |||||
#define LUA_OPSUB 1 | |||||
#define LUA_OPMUL 2 | |||||
#define LUA_OPMOD 3 | |||||
#define LUA_OPPOW 4 | |||||
#define LUA_OPDIV 5 | |||||
#define LUA_OPIDIV 6 | |||||
#define LUA_OPBAND 7 | |||||
#define LUA_OPBOR 8 | |||||
#define LUA_OPBXOR 9 | |||||
#define LUA_OPSHL 10 | |||||
#define LUA_OPSHR 11 | |||||
#define LUA_OPUNM 12 | |||||
#define LUA_OPBNOT 13 | |||||
LUA_API void (lua_arith) (lua_State *L, int op); | |||||
#define LUA_OPEQ 0 | |||||
#define LUA_OPLT 1 | |||||
#define LUA_OPLE 2 | |||||
LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); | |||||
LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); | |||||
/* | |||||
** push functions (C -> stack) | |||||
*/ | |||||
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 const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); | |||||
LUA_API const char *(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); | |||||
/* | |||||
** get functions (Lua -> stack) | |||||
*/ | |||||
LUA_API int (lua_getglobal) (lua_State *L, const char *name); | |||||
LUA_API int (lua_gettable) (lua_State *L, int idx); | |||||
LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); | |||||
LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); | |||||
LUA_API int (lua_rawget) (lua_State *L, int idx); | |||||
LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); | |||||
LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); | |||||
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 int (lua_getuservalue) (lua_State *L, int idx); | |||||
/* | |||||
** set functions (stack -> Lua) | |||||
*/ | |||||
LUA_API void (lua_setglobal) (lua_State *L, const char *name); | |||||
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_seti) (lua_State *L, int idx, lua_Integer n); | |||||
LUA_API void (lua_rawset) (lua_State *L, int idx); | |||||
LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); | |||||
LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); | |||||
LUA_API int (lua_setmetatable) (lua_State *L, int objindex); | |||||
LUA_API void (lua_setuservalue) (lua_State *L, int idx); | |||||
/* | |||||
** 'load' and 'call' functions (load and run Lua code) | |||||
*/ | |||||
LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, | |||||
lua_KContext ctx, lua_KFunction k); | |||||
#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) | |||||
LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, | |||||
lua_KContext ctx, lua_KFunction k); | |||||
#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) | |||||
LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, | |||||
const char *chunkname, const char *mode); | |||||
LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); | |||||
/* | |||||
** coroutine functions | |||||
*/ | |||||
LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, | |||||
lua_KFunction k); | |||||
LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg); | |||||
LUA_API int (lua_status) (lua_State *L); | |||||
LUA_API int (lua_isyieldable) (lua_State *L); | |||||
#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) | |||||
/* | |||||
** garbage-collection function and options | |||||
*/ | |||||
#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_GCISRUNNING 9 | |||||
LUA_API int (lua_gc) (lua_State *L, int what, int data); | |||||
/* | |||||
** miscellaneous functions | |||||
*/ | |||||
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 void (lua_len) (lua_State *L, int idx); | |||||
LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); | |||||
LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); | |||||
LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); | |||||
/* | |||||
** {============================================================== | |||||
** some useful macros | |||||
** =============================================================== | |||||
*/ | |||||
#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) | |||||
#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) | |||||
#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) | |||||
#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_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_pushstring(L, "" s) | |||||
#define lua_pushglobaltable(L) \ | |||||
((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) | |||||
#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) | |||||
#define lua_insert(L,idx) lua_rotate(L, (idx), 1) | |||||
#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | |||||
#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) | |||||
/* }============================================================== */ | |||||
/* | |||||
** {============================================================== | |||||
** compatibility macros for unsigned conversions | |||||
** =============================================================== | |||||
*/ | |||||
#if defined(LUA_COMPAT_APIINTCASTS) | |||||
#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) | |||||
#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) | |||||
#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) | |||||
#endif | |||||
/* }============================================================== */ | |||||
/* | |||||
** {====================================================================== | |||||
** Debug API | |||||
** ======================================================================= | |||||
*/ | |||||
/* | |||||
** Event codes | |||||
*/ | |||||
#define LUA_HOOKCALL 0 | |||||
#define LUA_HOOKRET 1 | |||||
#define LUA_HOOKLINE 2 | |||||
#define LUA_HOOKCOUNT 3 | |||||
#define LUA_HOOKTAILCALL 4 | |||||
/* | |||||
** Event masks | |||||
*/ | |||||
#define LUA_MASKCALL (1 << LUA_HOOKCALL) | |||||
#define LUA_MASKRET (1 << LUA_HOOKRET) | |||||
#define LUA_MASKLINE (1 << LUA_HOOKLINE) | |||||
#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | |||||
typedef struct lua_Debug lua_Debug; /* activation record */ | |||||
/* Functions to be called by the debugger in specific events */ | |||||
typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); | |||||
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 void *(lua_upvalueid) (lua_State *L, int fidx, int n); | |||||
LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, | |||||
int fidx2, int n2); | |||||
LUA_API void (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); | |||||
struct lua_Debug { | |||||
int event; | |||||
const char *name; /* (n) */ | |||||
const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ | |||||
const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ | |||||
const char *source; /* (S) */ | |||||
int currentline; /* (l) */ | |||||
int linedefined; /* (S) */ | |||||
int lastlinedefined; /* (S) */ | |||||
unsigned char nups; /* (u) number of upvalues */ | |||||
unsigned char nparams;/* (u) number of parameters */ | |||||
char isvararg; /* (u) */ | |||||
char istailcall; /* (t) */ | |||||
char short_src[LUA_IDSIZE]; /* (S) */ | |||||
/* private part */ | |||||
struct CallInfo *i_ci; /* active function */ | |||||
}; | |||||
/* }====================================================================== */ | |||||
/****************************************************************************** | |||||
* Copyright (C) 1994-2016 Lua.org, PUC-Rio. | |||||
* | |||||
* Permission is hereby granted, free of charge, to any person obtaining | |||||
* a copy of this software and associated documentation files (the | |||||
* "Software"), to deal in the Software without restriction, including | |||||
* without limitation the rights to use, copy, modify, merge, publish, | |||||
* distribute, sublicense, and/or sell copies of the Software, and to | |||||
* permit persons to whom the Software is furnished to do so, subject to | |||||
* the following conditions: | |||||
* | |||||
* The above copyright notice and this permission notice shall be | |||||
* included in all copies or substantial portions of the Software. | |||||
* | |||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |||||
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |||||
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. | |||||
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY | |||||
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, | |||||
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE | |||||
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. | |||||
******************************************************************************/ | |||||
#endif |
@ -1,9 +0,0 @@ | |||||
// lua.hpp | |||||
// Lua header files for C++ | |||||
// <<extern "C">> not supplied automatically because Lua also compiles as C++ | |||||
extern "C" { | |||||
#include "lua.h" | |||||
#include "lualib.h" | |||||
#include "lauxlib.h" | |||||
} |
@ -1,769 +0,0 @@ | |||||
/* | |||||
** $Id: luaconf.h,v 1.255 2016/05/01 20:06:09 roberto Exp $ | |||||
** Configuration file for Lua | |||||
** See Copyright Notice in lua.h | |||||
*/ | |||||
#ifndef luaconf_h | |||||
#define luaconf_h | |||||
#include <limits.h> | |||||
#include <stddef.h> | |||||
/* | |||||
** =================================================================== | |||||
** Search for "@@" to find all configurable definitions. | |||||
** =================================================================== | |||||
*/ | |||||
/* | |||||
** {==================================================================== | |||||
** System Configuration: macros to adapt (if needed) Lua to some | |||||
** particular platform, for instance compiling it with 32-bit numbers or | |||||
** restricting it to C89. | |||||
** ===================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. You | |||||
** can also define LUA_32BITS in the make file, but changing here you | |||||
** ensure that all software connected to Lua will be compiled with the | |||||
** same configuration. | |||||
*/ | |||||
/* #define LUA_32BITS */ | |||||
/* | |||||
@@ LUA_USE_C89 controls the use of non-ISO-C89 features. | |||||
** Define it if you want Lua to avoid the use of a few C99 features | |||||
** or Windows-specific features on Windows. | |||||
*/ | |||||
/* #define LUA_USE_C89 */ | |||||
/* | |||||
** By default, Lua on Windows use (some) specific Windows features | |||||
*/ | |||||
#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) | |||||
#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ | |||||
#endif | |||||
#if defined(LUA_USE_WINDOWS) | |||||
#define LUA_DL_DLL /* enable support for DLL */ | |||||
#define LUA_USE_C89 /* broadly, Windows is C89 */ | |||||
#endif | |||||
#if defined(LUA_USE_LINUX) | |||||
#define LUA_USE_POSIX | |||||
#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ | |||||
#define LUA_USE_READLINE /* needs some extra libraries */ | |||||
#endif | |||||
#if defined(LUA_USE_MACOSX) | |||||
#define LUA_USE_POSIX | |||||
#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ | |||||
#define LUA_USE_READLINE /* needs an extra library: -lreadline */ | |||||
#endif | |||||
/* | |||||
@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for | |||||
** C89 ('long' and 'double'); Windows always has '__int64', so it does | |||||
** not need to use this case. | |||||
*/ | |||||
#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) | |||||
#define LUA_C89_NUMBERS | |||||
#endif | |||||
/* | |||||
@@ LUAI_BITSINT defines the (minimum) number of bits in an 'int'. | |||||
*/ | |||||
/* avoid undefined shifts */ | |||||
#if ((INT_MAX >> 15) >> 15) >= 1 | |||||
#define LUAI_BITSINT 32 | |||||
#else | |||||
/* 'int' always must have at least 16 bits */ | |||||
#define LUAI_BITSINT 16 | |||||
#endif | |||||
/* | |||||
@@ LUA_INT_TYPE defines the type for Lua integers. | |||||
@@ LUA_FLOAT_TYPE defines the type for Lua floats. | |||||
** Lua should work fine with any mix of these options (if supported | |||||
** by your C compiler). The usual configurations are 64-bit integers | |||||
** and 'double' (the default), 32-bit integers and 'float' (for | |||||
** restricted platforms), and 'long'/'double' (for C compilers not | |||||
** compliant with C99, which may not have support for 'long long'). | |||||
*/ | |||||
/* predefined options for LUA_INT_TYPE */ | |||||
#define LUA_INT_INT 1 | |||||
#define LUA_INT_LONG 2 | |||||
#define LUA_INT_LONGLONG 3 | |||||
/* predefined options for LUA_FLOAT_TYPE */ | |||||
#define LUA_FLOAT_FLOAT 1 | |||||
#define LUA_FLOAT_DOUBLE 2 | |||||
#define LUA_FLOAT_LONGDOUBLE 3 | |||||
#if defined(LUA_32BITS) /* { */ | |||||
/* | |||||
** 32-bit integers and 'float' | |||||
*/ | |||||
#if LUAI_BITSINT >= 32 /* use 'int' if big enough */ | |||||
#define LUA_INT_TYPE LUA_INT_INT | |||||
#else /* otherwise use 'long' */ | |||||
#define LUA_INT_TYPE LUA_INT_LONG | |||||
#endif | |||||
#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT | |||||
#elif defined(LUA_C89_NUMBERS) /* }{ */ | |||||
/* | |||||
** largest types available for C89 ('long' and 'double') | |||||
*/ | |||||
#define LUA_INT_TYPE LUA_INT_LONG | |||||
#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE | |||||
#endif /* } */ | |||||
/* | |||||
** default configuration for 64-bit Lua ('long long' and 'double') | |||||
*/ | |||||
#if !defined(LUA_INT_TYPE) | |||||
#define LUA_INT_TYPE LUA_INT_LONGLONG | |||||
#endif | |||||
#if !defined(LUA_FLOAT_TYPE) | |||||
#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE | |||||
#endif | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Configuration for Paths. | |||||
** =================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for | |||||
** Lua libraries. | |||||
@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for | |||||
** C libraries. | |||||
** CHANGE them if your machine has a non-conventional directory | |||||
** hierarchy or if you want to install your libraries in | |||||
** non-conventional directories. | |||||
*/ | |||||
#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR | |||||
#if defined(_WIN32) /* { */ | |||||
/* | |||||
** In Windows, any exclamation mark ('!') in the path is replaced by the | |||||
** path of the directory of the executable file of the current process. | |||||
*/ | |||||
#define LUA_LDIR "!\\lua\\" | |||||
#define LUA_CDIR "!\\" | |||||
#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" | |||||
#define LUA_PATH_DEFAULT \ | |||||
LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ | |||||
LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ | |||||
LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ | |||||
".\\?.lua;" ".\\?\\init.lua" | |||||
#define LUA_CPATH_DEFAULT \ | |||||
LUA_CDIR"?.dll;" \ | |||||
LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ | |||||
LUA_CDIR"loadall.dll;" ".\\?.dll;" \ | |||||
LUA_CDIR"?53.dll;" ".\\?53.dll" | |||||
#else /* }{ */ | |||||
#define LUA_ROOT "/usr/local/" | |||||
#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" | |||||
#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" | |||||
#define LUA_PATH_DEFAULT \ | |||||
LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ | |||||
LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ | |||||
"./?.lua;" "./?/init.lua" | |||||
#define LUA_CPATH_DEFAULT \ | |||||
LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \ | |||||
LUA_CDIR"lib?53.so;" "./lib?53.so" | |||||
#endif /* } */ | |||||
/* | |||||
@@ LUA_DIRSEP is the directory separator (for submodules). | |||||
** CHANGE it if your machine does not use "/" as the directory separator | |||||
** and is not Windows. (On Windows Lua automatically uses "\".) | |||||
*/ | |||||
#if defined(_WIN32) | |||||
#define LUA_DIRSEP "\\" | |||||
#else | |||||
#define LUA_DIRSEP "/" | |||||
#endif | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Marks for exported symbols in the C code | |||||
** =================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUA_API is a mark for all core API functions. | |||||
@@ LUALIB_API is a mark for all auxiliary library functions. | |||||
@@ LUAMOD_API is a mark for all standard library opening functions. | |||||
** CHANGE them if you need to define those functions in some special way. | |||||
** For instance, if you want to create one Windows DLL with the core and | |||||
** the libraries, you may want to use the following definition (define | |||||
** LUA_BUILD_AS_DLL to get it). | |||||
*/ | |||||
#if defined(LUA_BUILD_AS_DLL) /* { */ | |||||
#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ | |||||
#define LUA_API __declspec(dllexport) | |||||
#else /* }{ */ | |||||
#define LUA_API __declspec(dllimport) | |||||
#endif /* } */ | |||||
#else /* }{ */ | |||||
#define LUA_API extern | |||||
#endif /* } */ | |||||
/* more often than not the libs go together with the core */ | |||||
#define LUALIB_API LUA_API | |||||
#define LUAMOD_API LUALIB_API | |||||
/* | |||||
@@ LUAI_FUNC is a mark for all extern functions that are not to be | |||||
** exported to outside modules. | |||||
@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables | |||||
** that are not to be exported to outside modules (LUAI_DDEF for | |||||
** definitions and LUAI_DDEC for declarations). | |||||
** CHANGE them if you need to mark them in some special way. Elf/gcc | |||||
** (versions 3.2 and later) mark them as "hidden" to optimize access | |||||
** when Lua is compiled as a shared library. Not all elf targets support | |||||
** this attribute. Unfortunately, gcc does not offer a way to check | |||||
** whether the target offers that support, and those without support | |||||
** give a warning about it. To avoid these warnings, change to the | |||||
** default definition. | |||||
*/ | |||||
#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ | |||||
defined(__ELF__) /* { */ | |||||
#define LUAI_FUNC __attribute__((visibility("hidden"))) extern | |||||
#else /* }{ */ | |||||
#define LUAI_FUNC extern | |||||
#endif /* } */ | |||||
#define LUAI_DDEC LUAI_FUNC | |||||
#define LUAI_DDEF /* empty */ | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Compatibility with previous versions | |||||
** =================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2. | |||||
@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1. | |||||
** You can define it to get all options, or change specific options | |||||
** to fit your specific needs. | |||||
*/ | |||||
#if defined(LUA_COMPAT_5_2) /* { */ | |||||
/* | |||||
@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated | |||||
** functions in the mathematical library. | |||||
*/ | |||||
#define LUA_COMPAT_MATHLIB | |||||
/* | |||||
@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'. | |||||
*/ | |||||
#define LUA_COMPAT_BITLIB | |||||
/* | |||||
@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod. | |||||
*/ | |||||
#define LUA_COMPAT_IPAIRS | |||||
/* | |||||
@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for | |||||
** manipulating other integer types (lua_pushunsigned, lua_tounsigned, | |||||
** luaL_checkint, luaL_checklong, etc.) | |||||
*/ | |||||
#define LUA_COMPAT_APIINTCASTS | |||||
#endif /* } */ | |||||
#if defined(LUA_COMPAT_5_1) /* { */ | |||||
/* Incompatibilities from 5.2 -> 5.3 */ | |||||
#define LUA_COMPAT_MATHLIB | |||||
#define LUA_COMPAT_APIINTCASTS | |||||
/* | |||||
@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'. | |||||
** You can replace it with 'table.unpack'. | |||||
*/ | |||||
#define LUA_COMPAT_UNPACK | |||||
/* | |||||
@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'. | |||||
** You can replace it with 'package.searchers'. | |||||
*/ | |||||
#define LUA_COMPAT_LOADERS | |||||
/* | |||||
@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall. | |||||
** You can call your C function directly (with light C functions). | |||||
*/ | |||||
#define lua_cpcall(L,f,u) \ | |||||
(lua_pushcfunction(L, (f)), \ | |||||
lua_pushlightuserdata(L,(u)), \ | |||||
lua_pcall(L,1,0,0)) | |||||
/* | |||||
@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library. | |||||
** You can rewrite 'log10(x)' as 'log(x, 10)'. | |||||
*/ | |||||
#define LUA_COMPAT_LOG10 | |||||
/* | |||||
@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base | |||||
** library. You can rewrite 'loadstring(s)' as 'load(s)'. | |||||
*/ | |||||
#define LUA_COMPAT_LOADSTRING | |||||
/* | |||||
@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library. | |||||
*/ | |||||
#define LUA_COMPAT_MAXN | |||||
/* | |||||
@@ The following macros supply trivial compatibility for some | |||||
** changes in the API. The macros themselves document how to | |||||
** change your code to avoid using them. | |||||
*/ | |||||
#define lua_strlen(L,i) lua_rawlen(L, (i)) | |||||
#define lua_objlen(L,i) lua_rawlen(L, (i)) | |||||
#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) | |||||
#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) | |||||
/* | |||||
@@ LUA_COMPAT_MODULE controls compatibility with previous | |||||
** module functions 'module' (Lua) and 'luaL_register' (C). | |||||
*/ | |||||
#define LUA_COMPAT_MODULE | |||||
#endif /* } */ | |||||
/* | |||||
@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a | |||||
@@ a float mark ('.0'). | |||||
** This macro is not on by default even in compatibility mode, | |||||
** because this is not really an incompatibility. | |||||
*/ | |||||
/* #define LUA_COMPAT_FLOATSTRING */ | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Configuration for Numbers. | |||||
** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* | |||||
** satisfy your needs. | |||||
** =================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUA_NUMBER is the floating-point type used by Lua. | |||||
@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' | |||||
@@ over a floating number. | |||||
@@ l_mathlim(x) corrects limit name 'x' to the proper float type | |||||
** by prefixing it with one of FLT/DBL/LDBL. | |||||
@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. | |||||
@@ LUA_NUMBER_FMT is the format for writing floats. | |||||
@@ lua_number2str converts a float to a string. | |||||
@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. | |||||
@@ l_floor takes the floor of a float. | |||||
@@ lua_str2number converts a decimal numeric string to a number. | |||||
*/ | |||||
/* The following definitions are good for most cases here */ | |||||
#define l_floor(x) (l_mathop(floor)(x)) | |||||
#define lua_number2str(s,sz,n) l_sprintf((s), sz, LUA_NUMBER_FMT, (n)) | |||||
/* | |||||
@@ lua_numbertointeger converts a float number to an integer, or | |||||
** returns 0 if float is not within the range of a lua_Integer. | |||||
** (The range comparisons are tricky because of rounding. The tests | |||||
** here assume a two-complement representation, where MININTEGER always | |||||
** has an exact representation as a float; MAXINTEGER may not have one, | |||||
** and therefore its conversion to float may have an ill-defined value.) | |||||
*/ | |||||
#define lua_numbertointeger(n,p) \ | |||||
((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | |||||
(n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | |||||
(*(p) = (LUA_INTEGER)(n), 1)) | |||||
/* now the variable definitions */ | |||||
#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ | |||||
#define LUA_NUMBER float | |||||
#define l_mathlim(n) (FLT_##n) | |||||
#define LUAI_UACNUMBER double | |||||
#define LUA_NUMBER_FRMLEN "" | |||||
#define LUA_NUMBER_FMT "%.7g" | |||||
#define l_mathop(op) op##f | |||||
#define lua_str2number(s,p) strtof((s), (p)) | |||||
#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ | |||||
#define LUA_NUMBER long double | |||||
#define l_mathlim(n) (LDBL_##n) | |||||
#define LUAI_UACNUMBER long double | |||||
#define LUA_NUMBER_FRMLEN "L" | |||||
#define LUA_NUMBER_FMT "%.19Lg" | |||||
#define l_mathop(op) op##l | |||||
#define lua_str2number(s,p) strtold((s), (p)) | |||||
#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ | |||||
#define LUA_NUMBER double | |||||
#define l_mathlim(n) (DBL_##n) | |||||
#define LUAI_UACNUMBER double | |||||
#define LUA_NUMBER_FRMLEN "" | |||||
#define LUA_NUMBER_FMT "%.14g" | |||||
#define l_mathop(op) op | |||||
#define lua_str2number(s,p) strtod((s), (p)) | |||||
#else /* }{ */ | |||||
#error "numeric float type not defined" | |||||
#endif /* } */ | |||||
/* | |||||
@@ LUA_INTEGER is the integer type used by Lua. | |||||
** | |||||
@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. | |||||
** | |||||
@@ LUAI_UACINT is the result of an 'usual argument conversion' | |||||
@@ over a lUA_INTEGER. | |||||
@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. | |||||
@@ LUA_INTEGER_FMT is the format for writing integers. | |||||
@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. | |||||
@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. | |||||
@@ lua_integer2str converts an integer to a string. | |||||
*/ | |||||
/* The following definitions are good for most cases here */ | |||||
#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" | |||||
#define lua_integer2str(s,sz,n) l_sprintf((s), sz, LUA_INTEGER_FMT, (n)) | |||||
#define LUAI_UACINT LUA_INTEGER | |||||
/* | |||||
** use LUAI_UACINT here to avoid problems with promotions (which | |||||
** can turn a comparison between unsigneds into a signed comparison) | |||||
*/ | |||||
#define LUA_UNSIGNED unsigned LUAI_UACINT | |||||
/* now the variable definitions */ | |||||
#if LUA_INT_TYPE == LUA_INT_INT /* { int */ | |||||
#define LUA_INTEGER int | |||||
#define LUA_INTEGER_FRMLEN "" | |||||
#define LUA_MAXINTEGER INT_MAX | |||||
#define LUA_MININTEGER INT_MIN | |||||
#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ | |||||
#define LUA_INTEGER long | |||||
#define LUA_INTEGER_FRMLEN "l" | |||||
#define LUA_MAXINTEGER LONG_MAX | |||||
#define LUA_MININTEGER LONG_MIN | |||||
#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ | |||||
/* use presence of macro LLONG_MAX as proxy for C99 compliance */ | |||||
#if defined(LLONG_MAX) /* { */ | |||||
/* use ISO C99 stuff */ | |||||
#define LUA_INTEGER long long | |||||
#define LUA_INTEGER_FRMLEN "ll" | |||||
#define LUA_MAXINTEGER LLONG_MAX | |||||
#define LUA_MININTEGER LLONG_MIN | |||||
#elif defined(LUA_USE_WINDOWS) /* }{ */ | |||||
/* in Windows, can use specific Windows types */ | |||||
#define LUA_INTEGER __int64 | |||||
#define LUA_INTEGER_FRMLEN "I64" | |||||
#define LUA_MAXINTEGER _I64_MAX | |||||
#define LUA_MININTEGER _I64_MIN | |||||
#else /* }{ */ | |||||
#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ | |||||
or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" | |||||
#endif /* } */ | |||||
#else /* }{ */ | |||||
#error "numeric integer type not defined" | |||||
#endif /* } */ | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Dependencies with C99 and other C details | |||||
** =================================================================== | |||||
*/ | |||||
/* | |||||
@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. | |||||
** (All uses in Lua have only one format item.) | |||||
*/ | |||||
#if !defined(LUA_USE_C89) | |||||
#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | |||||
#else | |||||
#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) | |||||
#endif | |||||
/* | |||||
@@ lua_strx2number converts an hexadecimal numeric string to a number. | |||||
** In C99, 'strtod' does that conversion. Otherwise, you can | |||||
** leave 'lua_strx2number' undefined and Lua will provide its own | |||||
** implementation. | |||||
*/ | |||||
#if !defined(LUA_USE_C89) | |||||
#define lua_strx2number(s,p) lua_str2number(s,p) | |||||
#endif | |||||
/* | |||||
@@ lua_number2strx converts a float to an hexadecimal numeric string. | |||||
** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. | |||||
** Otherwise, you can leave 'lua_number2strx' undefined and Lua will | |||||
** provide its own implementation. | |||||
*/ | |||||
#if !defined(LUA_USE_C89) | |||||
#define lua_number2strx(L,b,sz,f,n) ((void)L, l_sprintf(b,sz,f,n)) | |||||
#endif | |||||
/* | |||||
** 'strtof' and 'opf' variants for math functions are not valid in | |||||
** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the | |||||
** availability of these variants. ('math.h' is already included in | |||||
** all files that use these macros.) | |||||
*/ | |||||
#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) | |||||
#undef l_mathop /* variants not available */ | |||||
#undef lua_str2number | |||||
#define l_mathop(op) (lua_Number)op /* no variant */ | |||||
#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) | |||||
#endif | |||||
/* | |||||
@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation | |||||
** functions. It must be a numerical type; Lua will use 'intptr_t' if | |||||
** available, otherwise it will use 'ptrdiff_t' (the nearest thing to | |||||
** 'intptr_t' in C89) | |||||
*/ | |||||
#define LUA_KCONTEXT ptrdiff_t | |||||
#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ | |||||
__STDC_VERSION__ >= 199901L | |||||
#include <stdint.h> | |||||
#if defined(INTPTR_MAX) /* even in C99 this type is optional */ | |||||
#undef LUA_KCONTEXT | |||||
#define LUA_KCONTEXT intptr_t | |||||
#endif | |||||
#endif | |||||
/* | |||||
@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). | |||||
** Change that if you do not want to use C locales. (Code using this | |||||
** macro must include header 'locale.h'.) | |||||
*/ | |||||
#if !defined(lua_getlocaledecpoint) | |||||
#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) | |||||
#endif | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Language Variations | |||||
** ===================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some | |||||
** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from | |||||
** numbers to strings. Define LUA_NOCVTS2N to turn off automatic | |||||
** coercion from strings to numbers. | |||||
*/ | |||||
/* #define LUA_NOCVTN2S */ | |||||
/* #define LUA_NOCVTS2N */ | |||||
/* | |||||
@@ LUA_USE_APICHECK turns on several consistency checks on the C API. | |||||
** Define it as a help when debugging C code. | |||||
*/ | |||||
#if defined(LUA_USE_APICHECK) | |||||
#include <assert.h> | |||||
#define luai_apicheck(l,e) assert(e) | |||||
#endif | |||||
/* }================================================================== */ | |||||
/* | |||||
** {================================================================== | |||||
** Macros that affect the API and must be stable (that is, must be the | |||||
** same when you compile Lua and when you compile code that links to | |||||
** Lua). You probably do not want/need to change them. | |||||
** ===================================================================== | |||||
*/ | |||||
/* | |||||
@@ LUAI_MAXSTACK limits the size of the Lua stack. | |||||
** CHANGE it if you need a different limit. This limit is arbitrary; | |||||
** its only purpose is to stop Lua from consuming unlimited stack | |||||
** space (and to reserve some numbers for pseudo-indices). | |||||
*/ | |||||
#if LUAI_BITSINT >= 32 | |||||
#define LUAI_MAXSTACK 1000000 | |||||
#else | |||||
#define LUAI_MAXSTACK 15000 | |||||
#endif | |||||
/* | |||||
@@ LUA_EXTRASPACE defines the size of a raw memory area associated with | |||||
** a Lua state with very fast access. | |||||
** CHANGE it if you need a different size. | |||||
*/ | |||||
#define LUA_EXTRASPACE (sizeof(void *)) | |||||
/* | |||||
@@ LUA_IDSIZE gives the maximum size for the description of the source | |||||
@@ of a function in debug information. | |||||
** CHANGE it if you want a different size. | |||||
*/ | |||||
#define LUA_IDSIZE 60 | |||||
/* | |||||
@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. | |||||
** CHANGE it if it uses too much C-stack space. (For long double, | |||||
** 'string.format("%.99f", 1e4932)' needs ~5030 bytes, so a | |||||
** smaller buffer would force a memory allocation for each call to | |||||
** 'string.format'.) | |||||
*/ | |||||
#if defined(LUA_FLOAT_LONGDOUBLE) | |||||
#define LUAL_BUFFERSIZE 8192 | |||||
#else | |||||
#define LUAL_BUFFERSIZE ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer))) | |||||
#endif | |||||
/* }================================================================== */ | |||||
/* | |||||
@@ LUA_QL describes how error messages quote program elements. | |||||
** Lua does not use these macros anymore; they are here for | |||||
** compatibility only. | |||||
*/ | |||||
#define LUA_QL(x) "'" x "'" | |||||
#define LUA_QS LUA_QL("%s") | |||||
/* =================================================================== */ | |||||
/* | |||||
** Local configuration. You can use this space to add your redefinitions | |||||
** without modifying the main part of the file. | |||||
*/ | |||||
#endif | |||||
@ -1,58 +0,0 @@ | |||||
/* | |||||
** $Id: lualib.h,v 1.44 2014/02/06 17:32:33 roberto Exp $ | |||||
** Lua standard libraries | |||||
** See Copyright Notice in lua.h | |||||
*/ | |||||
#ifndef lualib_h | |||||
#define lualib_h | |||||
#include "lua.h" | |||||
LUAMOD_API int (luaopen_base) (lua_State *L); | |||||
#define LUA_COLIBNAME "coroutine" | |||||
LUAMOD_API int (luaopen_coroutine) (lua_State *L); | |||||
#define LUA_TABLIBNAME "table" | |||||
LUAMOD_API int (luaopen_table) (lua_State *L); | |||||
#define LUA_IOLIBNAME "io" | |||||
LUAMOD_API int (luaopen_io) (lua_State *L); | |||||
#define LUA_OSLIBNAME "os" | |||||
LUAMOD_API int (luaopen_os) (lua_State *L); | |||||
#define LUA_STRLIBNAME "string" | |||||
LUAMOD_API int (luaopen_string) (lua_State *L); | |||||
#define LUA_UTF8LIBNAME "utf8" | |||||
LUAMOD_API int (luaopen_utf8) (lua_State *L); | |||||
#define LUA_BITLIBNAME "bit32" | |||||
LUAMOD_API int (luaopen_bit32) (lua_State *L); | |||||
#define LUA_MATHLIBNAME "math" | |||||
LUAMOD_API int (luaopen_math) (lua_State *L); | |||||
#define LUA_DBLIBNAME "debug" | |||||
LUAMOD_API int (luaopen_debug) (lua_State *L); | |||||
#define LUA_LOADLIBNAME "package" | |||||
LUAMOD_API int (luaopen_package) (lua_State *L); | |||||
/* open all previous libraries */ | |||||
LUALIB_API void (luaL_openlibs) (lua_State *L); | |||||
#if !defined(lua_assert) | |||||
#define lua_assert(x) ((void)0) | |||||
#endif | |||||
#endif |
@ -1,150 +0,0 @@ | |||||
pthreads-win32 - a POSIX threads library for Microsoft Windows | |||||
This file is Copyrighted | |||||
------------------------ | |||||
This file is covered under the following Copyright: | |||||
Copyright (C) 2001,2006 Ross P. Johnson | |||||
All rights reserved. | |||||
Everyone is permitted to copy and distribute verbatim copies | |||||
of this license document, but changing it is not allowed. | |||||
Pthreads-win32 is covered by the GNU Lesser General Public License | |||||
------------------------------------------------------------------ | |||||
Pthreads-win32 is open software; you can redistribute it and/or | |||||
modify it under the terms of the GNU Lesser General Public License | |||||
as published by the Free Software Foundation version 2.1 of the | |||||
License. | |||||
Pthreads-win32 is several binary link libraries, several modules, | |||||
associated interface definition files and scripts used to control | |||||
its compilation and installation. | |||||
Pthreads-win32 is distributed in the hope that it will be useful, | |||||
but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||||
GNU Lesser General Public License for more details. | |||||
A copy of the GNU Lesser General Public License is distributed with | |||||
pthreads-win32 under the filename: | |||||
COPYING.LIB | |||||
You should have received a copy of the version 2.1 GNU Lesser General | |||||
Public License with pthreads-win32; if not, write to: | |||||
Free Software Foundation, Inc. | |||||
59 Temple Place | |||||
Suite 330 | |||||
Boston, MA 02111-1307 | |||||
USA | |||||
The contact addresses for pthreads-win32 is as follows: | |||||
Web: http://sources.redhat.com/pthreads-win32 | |||||
Email: Ross Johnson | |||||
Please use: Firstname.Lastname@homemail.com.au | |||||
Pthreads-win32 copyrights and exception files | |||||
--------------------------------------------- | |||||
With the exception of the files listed below, Pthreads-win32 | |||||
is covered under the following GNU Lesser General Public License | |||||
Copyrights: | |||||
Pthreads-win32 - POSIX Threads Library for Win32 | |||||
Copyright(C) 1998 John E. Bossom | |||||
Copyright(C) 1999,2006 Pthreads-win32 contributors | |||||
The current list of contributors is contained | |||||
in the file CONTRIBUTORS included with the source | |||||
code distribution. The current list of CONTRIBUTORS | |||||
can also be seen at the following WWW location: | |||||
http://sources.redhat.com/pthreads-win32/contributors.html | |||||
Contact Email: Ross Johnson | |||||
Please use: Firstname.Lastname@homemail.com.au | |||||
These files are not covered under one of the Copyrights listed above: | |||||
COPYING | |||||
COPYING.LIB | |||||
tests/rwlock7.c | |||||
This file, COPYING, is distributed under the Copyright found at the | |||||
top of this file. It is important to note that you may distribute | |||||
verbatim copies of this file but you may not modify this file. | |||||
The file COPYING.LIB, which contains a copy of the version 2.1 | |||||
GNU Lesser General Public License, is itself copyrighted by the | |||||
Free Software Foundation, Inc. Please note that the Free Software | |||||
Foundation, Inc. does NOT have a copyright over Pthreads-win32, | |||||
only the COPYING.LIB that is supplied with pthreads-win32. | |||||
The file tests/rwlock7.c is derived from code written by | |||||
Dave Butenhof for his book 'Programming With POSIX(R) Threads'. | |||||
The original code was obtained by free download from his website | |||||
http://home.earthlink.net/~anneart/family/Threads/source.html | |||||
and did not contain a copyright or author notice. It is assumed to | |||||
be freely distributable. | |||||
In all cases one may use and distribute these exception files freely. | |||||
And because one may freely distribute the LGPL covered files, the | |||||
entire pthreads-win32 source may be freely used and distributed. | |||||
General Copyleft and License info | |||||
--------------------------------- | |||||
For general information on Copylefts, see: | |||||
http://www.gnu.org/copyleft/ | |||||
For information on GNU Lesser General Public Licenses, see: | |||||
http://www.gnu.org/copyleft/lesser.html | |||||
http://www.gnu.org/copyleft/lesser.txt | |||||
Why pthreads-win32 did not use the GNU General Public License | |||||
------------------------------------------------------------- | |||||
The goal of the pthreads-win32 project has been to | |||||
provide a quality and complete implementation of the POSIX | |||||
threads API for Microsoft Windows within the limits imposed | |||||
by virtue of it being a stand-alone library and not | |||||
linked directly to other POSIX compliant libraries. For | |||||
example, some functions and features, such as those based | |||||
on POSIX signals, are missing. | |||||
Pthreads-win32 is a library, available in several different | |||||
versions depending on supported compilers, and may be used | |||||
as a dynamically linked module or a statically linked set of | |||||
binary modules. It is not an application on it's own. | |||||
It was fully intended that pthreads-win32 be usable with | |||||
commercial software not covered by either the GPL or the LGPL | |||||
licenses. Pthreads-win32 has many contributors to it's | |||||
code base, many of whom have done so because they have | |||||
used the library in commercial or proprietry software | |||||
projects. | |||||
Releasing pthreads-win32 under the LGPL ensures that the | |||||
library can be used widely, while at the same time ensures | |||||
that bug fixes and improvements to the pthreads-win32 code | |||||
itself is returned to benefit all current and future users | |||||
of the library. | |||||
Although pthreads-win32 makes it possible for applications | |||||
that use POSIX threads to be ported to Win32 platforms, the | |||||
broader goal of the project is to encourage the use of open | |||||
standards, and in particular, to make it just a little easier | |||||
for developers writing Win32 applications to consider | |||||
widening the potential market for their products. |
@ -1,183 +0,0 @@ | |||||
/* | |||||
* Module: sched.h | |||||
* | |||||
* Purpose: | |||||
* Provides an implementation of POSIX realtime extensions | |||||
* as defined in | |||||
* | |||||
* POSIX 1003.1b-1993 (POSIX.1b) | |||||
* | |||||
* -------------------------------------------------------------------------- | |||||
* | |||||
* Pthreads-win32 - POSIX Threads Library for Win32 | |||||
* Copyright(C) 1998 John E. Bossom | |||||
* Copyright(C) 1999,2005 Pthreads-win32 contributors | |||||
* | |||||
* Contact Email: rpj@callisto.canberra.edu.au | |||||
* | |||||
* The current list of contributors is contained | |||||
* in the file CONTRIBUTORS included with the source | |||||
* code distribution. The list can also be seen at the | |||||
* following World Wide Web location: | |||||
* http://sources.redhat.com/pthreads-win32/contributors.html | |||||
* | |||||
* This library is free software; you can redistribute it and/or | |||||
* modify it under the terms of the GNU Lesser General Public | |||||
* License as published by the Free Software Foundation; either | |||||
* version 2 of the License, or (at your option) any later version. | |||||
* | |||||
* This library is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||||
* Lesser General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU Lesser General Public | |||||
* License along with this library in the file COPYING.LIB; | |||||
* if not, write to the Free Software Foundation, Inc., | |||||
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | |||||
*/ | |||||
#if !defined(_SCHED_H) | |||||
#define _SCHED_H | |||||
#undef PTW32_SCHED_LEVEL | |||||
#if defined(_POSIX_SOURCE) | |||||
#define PTW32_SCHED_LEVEL 0 | |||||
/* Early POSIX */ | |||||
#endif | |||||
#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 | |||||
#undef PTW32_SCHED_LEVEL | |||||
#define PTW32_SCHED_LEVEL 1 | |||||
/* Include 1b, 1c and 1d */ | |||||
#endif | |||||
#if defined(INCLUDE_NP) | |||||
#undef PTW32_SCHED_LEVEL | |||||
#define PTW32_SCHED_LEVEL 2 | |||||
/* Include Non-Portable extensions */ | |||||
#endif | |||||
#define PTW32_SCHED_LEVEL_MAX 3 | |||||
#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_SCHED_LEVEL) | |||||
#define PTW32_SCHED_LEVEL PTW32_SCHED_LEVEL_MAX | |||||
/* Include everything */ | |||||
#endif | |||||
#if defined(__GNUC__) && !defined(__declspec) | |||||
# error Please upgrade your GNU compiler to one that supports __declspec. | |||||
#endif | |||||
/* | |||||
* When building the library, you should define PTW32_BUILD so that | |||||
* the variables/functions are exported correctly. When using the library, | |||||
* do NOT define PTW32_BUILD, and then the variables/functions will | |||||
* be imported correctly. | |||||
*/ | |||||
#if !defined(PTW32_STATIC_LIB) | |||||
# if defined(PTW32_BUILD) | |||||
# define PTW32_DLLPORT __declspec (dllexport) | |||||
# else | |||||
# define PTW32_DLLPORT __declspec (dllimport) | |||||
# endif | |||||
#else | |||||
# define PTW32_DLLPORT | |||||
#endif | |||||
/* | |||||
* This is a duplicate of what is in the autoconf config.h, | |||||
* which is only used when building the pthread-win32 libraries. | |||||
*/ | |||||
#if !defined(PTW32_CONFIG_H) | |||||
# if defined(WINCE) | |||||
# define NEED_ERRNO | |||||
# define NEED_SEM | |||||
# endif | |||||
# if defined(__MINGW64__) | |||||
# define HAVE_STRUCT_TIMESPEC | |||||
# define HAVE_MODE_T | |||||
# elif defined(_UWIN) || defined(__MINGW32__) | |||||
# define HAVE_MODE_T | |||||
# endif | |||||
#endif | |||||
/* | |||||
* | |||||
*/ | |||||
#if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX | |||||
#if defined(NEED_ERRNO) | |||||
#include "need_errno.h" | |||||
#else | |||||
#include <errno.h> | |||||
#endif | |||||
#endif /* PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX */ | |||||
#if (defined(__MINGW64__) || defined(__MINGW32__)) || defined(_UWIN) | |||||
# if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX | |||||
/* For pid_t */ | |||||
# include <sys/types.h> | |||||
/* Required by Unix 98 */ | |||||
# include <time.h> | |||||
# else | |||||
typedef int pid_t; | |||||
# endif | |||||
#else | |||||
typedef int pid_t; | |||||
#endif | |||||
/* Thread scheduling policies */ | |||||
enum { | |||||
SCHED_OTHER = 0, | |||||
SCHED_FIFO, | |||||
SCHED_RR, | |||||
SCHED_MIN = SCHED_OTHER, | |||||
SCHED_MAX = SCHED_RR | |||||
}; | |||||
struct sched_param { | |||||
int sched_priority; | |||||
}; | |||||
#if defined(__cplusplus) | |||||
extern "C" | |||||
{ | |||||
#endif /* __cplusplus */ | |||||
PTW32_DLLPORT int __cdecl sched_yield (void); | |||||
PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy); | |||||
PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy); | |||||
PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy); | |||||
PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid); | |||||
/* | |||||
* Note that this macro returns ENOTSUP rather than | |||||
* ENOSYS as might be expected. However, returning ENOSYS | |||||
* should mean that sched_get_priority_{min,max} are | |||||
* not implemented as well as sched_rr_get_interval. | |||||
* This is not the case, since we just don't support | |||||
* round-robin scheduling. Therefore I have chosen to | |||||
* return the same value as sched_setscheduler when | |||||
* SCHED_RR is passed to it. | |||||
*/ | |||||
#define sched_rr_get_interval(_pid, _interval) \ | |||||
( errno = ENOTSUP, (int) -1 ) | |||||
#if defined(__cplusplus) | |||||
} /* End of extern "C" */ | |||||
#endif /* __cplusplus */ | |||||
#undef PTW32_SCHED_LEVEL | |||||
#undef PTW32_SCHED_LEVEL_MAX | |||||
#endif /* !_SCHED_H */ | |||||
@ -1,169 +0,0 @@ | |||||
/* | |||||
* Module: semaphore.h | |||||
* | |||||
* Purpose: | |||||
* Semaphores aren't actually part of the PThreads standard. | |||||
* They are defined by the POSIX Standard: | |||||
* | |||||
* POSIX 1003.1b-1993 (POSIX.1b) | |||||
* | |||||
* -------------------------------------------------------------------------- | |||||
* | |||||
* Pthreads-win32 - POSIX Threads Library for Win32 | |||||
* Copyright(C) 1998 John E. Bossom | |||||
* Copyright(C) 1999,2005 Pthreads-win32 contributors | |||||
* | |||||
* Contact Email: rpj@callisto.canberra.edu.au | |||||
* | |||||
* The current list of contributors is contained | |||||
* in the file CONTRIBUTORS included with the source | |||||
* code distribution. The list can also be seen at the | |||||
* following World Wide Web location: | |||||
* http://sources.redhat.com/pthreads-win32/contributors.html | |||||
* | |||||
* This library is free software; you can redistribute it and/or | |||||
* modify it under the terms of the GNU Lesser General Public | |||||
* License as published by the Free Software Foundation; either | |||||
* version 2 of the License, or (at your option) any later version. | |||||
* | |||||
* This library is distributed in the hope that it will be useful, | |||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of | |||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |||||
* Lesser General Public License for more details. | |||||
* | |||||
* You should have received a copy of the GNU Lesser General Public | |||||
* License along with this library in the file COPYING.LIB; | |||||
* if not, write to the Free Software Foundation, Inc., | |||||
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA | |||||
*/ | |||||
#if !defined( SEMAPHORE_H ) | |||||
#define SEMAPHORE_H | |||||
#undef PTW32_SEMAPHORE_LEVEL | |||||
#if defined(_POSIX_SOURCE) | |||||
#define PTW32_SEMAPHORE_LEVEL 0 | |||||
/* Early POSIX */ | |||||
#endif | |||||
#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 | |||||
#undef PTW32_SEMAPHORE_LEVEL | |||||
#define PTW32_SEMAPHORE_LEVEL 1 | |||||
/* Include 1b, 1c and 1d */ | |||||
#endif | |||||
#if defined(INCLUDE_NP) | |||||
#undef PTW32_SEMAPHORE_LEVEL | |||||
#define PTW32_SEMAPHORE_LEVEL 2 | |||||
/* Include Non-Portable extensions */ | |||||
#endif | |||||
#define PTW32_SEMAPHORE_LEVEL_MAX 3 | |||||
#if !defined(PTW32_SEMAPHORE_LEVEL) | |||||
#define PTW32_SEMAPHORE_LEVEL PTW32_SEMAPHORE_LEVEL_MAX | |||||
/* Include everything */ | |||||
#endif | |||||
#if defined(__GNUC__) && ! defined (__declspec) | |||||
# error Please upgrade your GNU compiler to one that supports __declspec. | |||||
#endif | |||||
/* | |||||
* When building the library, you should define PTW32_BUILD so that | |||||
* the variables/functions are exported correctly. When using the library, | |||||
* do NOT define PTW32_BUILD, and then the variables/functions will | |||||
* be imported correctly. | |||||
*/ | |||||
#if !defined(PTW32_STATIC_LIB) | |||||
# if defined(PTW32_BUILD) | |||||
# define PTW32_DLLPORT __declspec (dllexport) | |||||
# else | |||||
# define PTW32_DLLPORT __declspec (dllimport) | |||||
# endif | |||||
#else | |||||
# define PTW32_DLLPORT | |||||
#endif | |||||
/* | |||||
* This is a duplicate of what is in the autoconf config.h, | |||||
* which is only used when building the pthread-win32 libraries. | |||||
*/ | |||||
#if !defined(PTW32_CONFIG_H) | |||||
# if defined(WINCE) | |||||
# define NEED_ERRNO | |||||
# define NEED_SEM | |||||
# endif | |||||
# if defined(__MINGW64__) | |||||
# define HAVE_STRUCT_TIMESPEC | |||||
# define HAVE_MODE_T | |||||
# elif defined(_UWIN) || defined(__MINGW32__) | |||||
# define HAVE_MODE_T | |||||
# endif | |||||
#endif | |||||
/* | |||||
* | |||||
*/ | |||||
#if PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX | |||||
#if defined(NEED_ERRNO) | |||||
#include "need_errno.h" | |||||
#else | |||||
#include <errno.h> | |||||
#endif | |||||
#endif /* PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX */ | |||||
#define _POSIX_SEMAPHORES | |||||
#if defined(__cplusplus) | |||||
extern "C" | |||||
{ | |||||
#endif /* __cplusplus */ | |||||
#if !defined(HAVE_MODE_T) | |||||
typedef unsigned int mode_t; | |||||
#endif | |||||
typedef struct sem_t_ * sem_t; | |||||
PTW32_DLLPORT int __cdecl sem_init (sem_t * sem, | |||||
int pshared, | |||||
unsigned int value); | |||||
PTW32_DLLPORT int __cdecl sem_destroy (sem_t * sem); | |||||
PTW32_DLLPORT int __cdecl sem_trywait (sem_t * sem); | |||||
PTW32_DLLPORT int __cdecl sem_wait (sem_t * sem); | |||||
PTW32_DLLPORT int __cdecl sem_timedwait (sem_t * sem, | |||||
const struct timespec * abstime); | |||||
PTW32_DLLPORT int __cdecl sem_post (sem_t * sem); | |||||
PTW32_DLLPORT int __cdecl sem_post_multiple (sem_t * sem, | |||||
int count); | |||||
PTW32_DLLPORT int __cdecl sem_open (const char * name, | |||||
int oflag, | |||||
mode_t mode, | |||||
unsigned int value); | |||||
PTW32_DLLPORT int __cdecl sem_close (sem_t * sem); | |||||
PTW32_DLLPORT int __cdecl sem_unlink (const char * name); | |||||
PTW32_DLLPORT int __cdecl sem_getvalue (sem_t * sem, | |||||
int * sval); | |||||
#if defined(__cplusplus) | |||||
} /* End of extern "C" */ | |||||
#endif /* __cplusplus */ | |||||
#undef PTW32_SEMAPHORE_LEVEL | |||||
#undef PTW32_SEMAPHORE_LEVEL_MAX | |||||
#endif /* !SEMAPHORE_H */ |