candle 0.0.1

data/lib/candle/generators/lua/wax/lib/lua/lopcodes.c

@@ -0,0 +1,102 @@
+/*
+** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
+** See Copyright Notice in lua.h
+*/
+
+
+#define lopcodes_c
+#define LUA_CORE
+
+
+#include "lopcodes.h"
+
+
+/* ORDER OP */
+
+const char *const luaP_opnames[NUM_OPCODES+1] = {
+  "MOVE",
+  "LOADK",
+  "LOADBOOL",
+  "LOADNIL",
+  "GETUPVAL",
+  "GETGLOBAL",
+  "GETTABLE",
+  "SETGLOBAL",
+  "SETUPVAL",
+  "SETTABLE",
+  "NEWTABLE",
+  "SELF",
+  "ADD",
+  "SUB",
+  "MUL",
+  "DIV",
+  "MOD",
+  "POW",
+  "UNM",
+  "NOT",
+  "LEN",
+  "CONCAT",
+  "JMP",
+  "EQ",
+  "LT",
+  "LE",
+  "TEST",
+  "TESTSET",
+  "CALL",
+  "TAILCALL",
+  "RETURN",
+  "FORLOOP",
+  "FORPREP",
+  "TFORLOOP",
+  "SETLIST",
+  "CLOSE",
+  "CLOSURE",
+  "VARARG",
+  NULL
+};
+
+
+#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
+
+const lu_byte luaP_opmodes[NUM_OPCODES] = {
+/*       T  A    B       C     mode           opcode    */
+  opmode(0, 1, OpArgR, OpArgN, iABC)         /* OP_MOVE */
+ ,opmode(0, 1, OpArgK, OpArgN, iABx)        /* OP_LOADK */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_LOADBOOL */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_LOADNIL */
+ ,opmode(0, 1, OpArgU, OpArgN, iABC)        /* OP_GETUPVAL */
+ ,opmode(0, 1, OpArgK, OpArgN, iABx)        /* OP_GETGLOBAL */
+ ,opmode(0, 1, OpArgR, OpArgK, iABC)        /* OP_GETTABLE */
+ ,opmode(0, 0, OpArgK, OpArgN, iABx)        /* OP_SETGLOBAL */
+ ,opmode(0, 0, OpArgU, OpArgN, iABC)        /* OP_SETUPVAL */
+ ,opmode(0, 0, OpArgK, OpArgK, iABC)        /* OP_SETTABLE */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_NEWTABLE */
+ ,opmode(0, 1, OpArgR, OpArgK, iABC)        /* OP_SELF */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_ADD */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_SUB */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_MUL */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_DIV */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_MOD */
+ ,opmode(0, 1, OpArgK, OpArgK, iABC)        /* OP_POW */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_UNM */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_NOT */
+ ,opmode(0, 1, OpArgR, OpArgN, iABC)        /* OP_LEN */
+ ,opmode(0, 1, OpArgR, OpArgR, iABC)        /* OP_CONCAT */
+ ,opmode(0, 0, OpArgR, OpArgN, iAsBx)        /* OP_JMP */
+ ,opmode(1, 0, OpArgK, OpArgK, iABC)        /* OP_EQ */
+ ,opmode(1, 0, OpArgK, OpArgK, iABC)        /* OP_LT */
+ ,opmode(1, 0, OpArgK, OpArgK, iABC)        /* OP_LE */
+ ,opmode(1, 1, OpArgR, OpArgU, iABC)        /* OP_TEST */
+ ,opmode(1, 1, OpArgR, OpArgU, iABC)        /* OP_TESTSET */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_CALL */
+ ,opmode(0, 1, OpArgU, OpArgU, iABC)        /* OP_TAILCALL */
+ ,opmode(0, 0, OpArgU, OpArgN, iABC)        /* OP_RETURN */
+ ,opmode(0, 1, OpArgR, OpArgN, iAsBx)        /* OP_FORLOOP */
+ ,opmode(0, 1, OpArgR, OpArgN, iAsBx)        /* OP_FORPREP */
+ ,opmode(1, 0, OpArgN, OpArgU, iABC)        /* OP_TFORLOOP */
+ ,opmode(0, 0, OpArgU, OpArgU, iABC)        /* OP_SETLIST */
+ ,opmode(0, 0, OpArgN, OpArgN, iABC)        /* OP_CLOSE */
+ ,opmode(0, 1, OpArgU, OpArgN, iABx)        /* OP_CLOSURE */
+ ,opmode(0, 1, OpArgU, OpArgN, iABC)        /* OP_VARARG */
+};
+

data/lib/candle/generators/lua/wax/lib/lua/lopcodes.h

@@ -0,0 +1,268 @@
+/*
+** $Id: lopcodes.h,v 1.125.1.1 2007/12/27 13:02:25 roberto Exp $
+** Opcodes for Lua virtual machine
+** See Copyright Notice in lua.h
+*/
+
+#ifndef lopcodes_h
+#define lopcodes_h
+
+#include "llimits.h"
+
+
+/*===========================================================================
+  We assume that instructions are unsigned numbers.
+  All instructions have an opcode in the first 6 bits.
+  Instructions can have the following fields:
+    `A' : 8 bits
+    `B' : 9 bits
+    `C' : 9 bits
+    `Bx' : 18 bits (`B' and `C' together)
+    `sBx' : signed Bx
+
+  A signed argument is represented in excess K; that is, the number
+  value is the unsigned value minus K. K is exactly the maximum value
+  for that argument (so that -max is represented by 0, and +max is
+  represented by 2*max), which is half the maximum for the corresponding
+  unsigned argument.
+===========================================================================*/
+
+
+enum OpMode {iABC, iABx, iAsBx};  /* basic instruction format */
+
+
+/*
+** size and position of opcode arguments.
+*/
+#define SIZE_C        9
+#define SIZE_B        9
+#define SIZE_Bx        (SIZE_C + SIZE_B)
+#define SIZE_A        8
+
+#define SIZE_OP        6
+
+#define POS_OP        0
+#define POS_A        (POS_OP + SIZE_OP)
+#define POS_C        (POS_A + SIZE_A)
+#define POS_B        (POS_C + SIZE_C)
+#define POS_Bx        POS_C
+
+
+/*
+** limits for opcode arguments.
+** we use (signed) int to manipulate most arguments,
+** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
+*/
+#if SIZE_Bx < LUAI_BITSINT-1
+#define MAXARG_Bx        ((1<<SIZE_Bx)-1)
+#define MAXARG_sBx        (MAXARG_Bx>>1)         /* `sBx' is signed */
+#else
+#define MAXARG_Bx        MAX_INT
+#define MAXARG_sBx        MAX_INT
+#endif
+
+
+#define MAXARG_A        ((1<<SIZE_A)-1)
+#define MAXARG_B        ((1<<SIZE_B)-1)
+#define MAXARG_C        ((1<<SIZE_C)-1)
+
+
+/* creates a mask with `n' 1 bits at position `p' */
+#define MASK1(n,p)    ((~((~(Instruction)0)<<n))<<p)
+
+/* creates a mask with `n' 0 bits at position `p' */
+#define MASK0(n,p)    (~MASK1(n,p))
+
+/*
+** the following macros help to manipulate instructions
+*/
+
+#define GET_OPCODE(i)    (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0)))
+#define SET_OPCODE(i,o)    ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
+        ((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
+
+#define GETARG_A(i)    (cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0)))
+#define SETARG_A(i,u)    ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
+        ((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A))))
+
+#define GETARG_B(i)    (cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0)))
+#define SETARG_B(i,b)    ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
+        ((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B))))
+
+#define GETARG_C(i)    (cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0)))
+#define SETARG_C(i,b)    ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
+        ((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C))))
+
+#define GETARG_Bx(i)    (cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0)))
+#define SETARG_Bx(i,b)    ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
+        ((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx))))
+
+#define GETARG_sBx(i)    (GETARG_Bx(i)-MAXARG_sBx)
+#define SETARG_sBx(i,b)    SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
+
+
+#define CREATE_ABC(o,a,b,c)    ((cast(Instruction, o)<<POS_OP) \
+            | (cast(Instruction, a)<<POS_A) \
+            | (cast(Instruction, b)<<POS_B) \
+            | (cast(Instruction, c)<<POS_C))
+
+#define CREATE_ABx(o,a,bc)    ((cast(Instruction, o)<<POS_OP) \
+            | (cast(Instruction, a)<<POS_A) \
+            | (cast(Instruction, bc)<<POS_Bx))
+
+
+/*
+** Macros to operate RK indices
+*/
+
+/* this bit 1 means constant (0 means register) */
+#define BITRK        (1 << (SIZE_B - 1))
+
+/* test whether value is a constant */
+#define ISK(x)        ((x) & BITRK)
+
+/* gets the index of the constant */
+#define INDEXK(r)    ((int)(r) & ~BITRK)
+
+#define MAXINDEXRK    (BITRK - 1)
+
+/* code a constant index as a RK value */
+#define RKASK(x)    ((x) | BITRK)
+
+
+/*
+** invalid register that fits in 8 bits
+*/
+#define NO_REG        MAXARG_A
+
+
+/*
+** R(x) - register
+** Kst(x) - constant (in constant table)
+** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
+*/
+
+
+/*
+** grep "ORDER OP" if you change these enums
+*/
+
+typedef enum {
+/*----------------------------------------------------------------------
+name        args    description
+------------------------------------------------------------------------*/
+OP_MOVE,/*    A B    R(A) := R(B)                    */
+OP_LOADK,/*    A Bx    R(A) := Kst(Bx)                    */
+OP_LOADBOOL,/*    A B C    R(A) := (Bool)B; if (C) pc++            */
+OP_LOADNIL,/*    A B    R(A) := ... := R(B) := nil            */
+OP_GETUPVAL,/*    A B    R(A) := UpValue[B]                */
+
+OP_GETGLOBAL,/*    A Bx    R(A) := Gbl[Kst(Bx)]                */
+OP_GETTABLE,/*    A B C    R(A) := R(B)[RK(C)]                */
+
+OP_SETGLOBAL,/*    A Bx    Gbl[Kst(Bx)] := R(A)                */
+OP_SETUPVAL,/*    A B    UpValue[B] := R(A)                */
+OP_SETTABLE,/*    A B C    R(A)[RK(B)] := RK(C)                */
+
+OP_NEWTABLE,/*    A B C    R(A) := {} (size = B,C)                */
+
+OP_SELF,/*    A B C    R(A+1) := R(B); R(A) := R(B)[RK(C)]        */
+
+OP_ADD,/*    A B C    R(A) := RK(B) + RK(C)                */
+OP_SUB,/*    A B C    R(A) := RK(B) - RK(C)                */
+OP_MUL,/*    A B C    R(A) := RK(B) * RK(C)                */
+OP_DIV,/*    A B C    R(A) := RK(B) / RK(C)                */
+OP_MOD,/*    A B C    R(A) := RK(B) % RK(C)                */
+OP_POW,/*    A B C    R(A) := RK(B) ^ RK(C)                */
+OP_UNM,/*    A B    R(A) := -R(B)                    */
+OP_NOT,/*    A B    R(A) := not R(B)                */
+OP_LEN,/*    A B    R(A) := length of R(B)                */
+
+OP_CONCAT,/*    A B C    R(A) := R(B).. ... ..R(C)            */
+
+OP_JMP,/*    sBx    pc+=sBx                    */
+
+OP_EQ,/*    A B C    if ((RK(B) == RK(C)) ~= A) then pc++        */
+OP_LT,/*    A B C    if ((RK(B) <  RK(C)) ~= A) then pc++          */
+OP_LE,/*    A B C    if ((RK(B) <= RK(C)) ~= A) then pc++          */
+
+OP_TEST,/*    A C    if not (R(A) <=> C) then pc++            */ 
+OP_TESTSET,/*    A B C    if (R(B) <=> C) then R(A) := R(B) else pc++    */ 
+
+OP_CALL,/*    A B C    R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
+OP_TAILCALL,/*    A B C    return R(A)(R(A+1), ... ,R(A+B-1))        */
+OP_RETURN,/*    A B    return R(A), ... ,R(A+B-2)    (see note)    */
+
+OP_FORLOOP,/*    A sBx    R(A)+=R(A+2);
+            if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
+OP_FORPREP,/*    A sBx    R(A)-=R(A+2); pc+=sBx                */
+
+OP_TFORLOOP,/*    A C    R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2)); 
+                        if R(A+3) ~= nil then R(A+2)=R(A+3) else pc++    */ 
+OP_SETLIST,/*    A B C    R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B    */
+
+OP_CLOSE,/*    A     close all variables in the stack up to (>=) R(A)*/
+OP_CLOSURE,/*    A Bx    R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))    */
+
+OP_VARARG/*    A B    R(A), R(A+1), ..., R(A+B-1) = vararg        */
+} OpCode;
+
+
+#define NUM_OPCODES    (cast(int, OP_VARARG) + 1)
+
+
+
+/*===========================================================================
+  Notes:
+  (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
+      and can be 0: OP_CALL then sets `top' to last_result+1, so
+      next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
+
+  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
+      set top (like in OP_CALL with C == 0).
+
+  (*) In OP_RETURN, if (B == 0) then return up to `top'
+
+  (*) In OP_SETLIST, if (B == 0) then B = `top';
+      if (C == 0) then next `instruction' is real C
+
+  (*) For comparisons, A specifies what condition the test should accept
+      (true or false).
+
+  (*) All `skips' (pc++) assume that next instruction is a jump
+===========================================================================*/
+
+
+/*
+** masks for instruction properties. The format is:
+** bits 0-1: op mode
+** bits 2-3: C arg mode
+** bits 4-5: B arg mode
+** bit 6: instruction set register A
+** bit 7: operator is a test
+*/  
+
+enum OpArgMask {
+  OpArgN,  /* argument is not used */
+  OpArgU,  /* argument is used */
+  OpArgR,  /* argument is a register or a jump offset */
+  OpArgK   /* argument is a constant or register/constant */
+};
+
+LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
+
+#define getOpMode(m)    (cast(enum OpMode, luaP_opmodes[m] & 3))
+#define getBMode(m)    (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
+#define getCMode(m)    (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
+#define testAMode(m)    (luaP_opmodes[m] & (1 << 6))
+#define testTMode(m)    (luaP_opmodes[m] & (1 << 7))
+
+
+LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
+
+
+/* number of list items to accumulate before a SETLIST instruction */
+#define LFIELDS_PER_FLUSH    50
+
+
+#endif

data/lib/candle/generators/lua/wax/lib/lua/loslib.c

@@ -0,0 +1,243 @@
+/*
+** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $
+** Standard Operating System library
+** See Copyright Notice in lua.h
+*/
+
+
+#include <errno.h>
+#include <locale.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#define loslib_c
+#define LUA_LIB
+
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "lualib.h"
+
+
+static int os_pushresult (lua_State *L, int i, const char *filename) {
+  int en = errno;  /* calls to Lua API may change this value */
+  if (i) {
+    lua_pushboolean(L, 1);
+    return 1;
+  }
+  else {
+    lua_pushnil(L);
+    lua_pushfstring(L, "%s: %s", filename, strerror(en));
+    lua_pushinteger(L, en);
+    return 3;
+  }
+}
+
+
+static int os_execute (lua_State *L) {
+  lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
+  return 1;
+}
+
+
+static int os_remove (lua_State *L) {
+  const char *filename = luaL_checkstring(L, 1);
+  return os_pushresult(L, remove(filename) == 0, filename);
+}
+
+
+static int os_rename (lua_State *L) {
+  const char *fromname = luaL_checkstring(L, 1);
+  const char *toname = luaL_checkstring(L, 2);
+  return os_pushresult(L, rename(fromname, toname) == 0, fromname);
+}
+
+
+static int os_tmpname (lua_State *L) {
+  char buff[LUA_TMPNAMBUFSIZE];
+  int err;
+  lua_tmpnam(buff, err);
+  if (err)
+    return luaL_error(L, "unable to generate a unique filename");
+  lua_pushstring(L, buff);
+  return 1;
+}
+
+
+static int os_getenv (lua_State *L) {
+  lua_pushstring(L, getenv(luaL_checkstring(L, 1)));  /* if NULL push nil */
+  return 1;
+}
+
+
+static int os_clock (lua_State *L) {
+  lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
+  return 1;
+}
+
+
+/*
+** {======================================================
+** Time/Date operations
+** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
+**   wday=%w+1, yday=%j, isdst=? }
+** =======================================================
+*/
+
+static void setfield (lua_State *L, const char *key, int value) {
+  lua_pushinteger(L, value);
+  lua_setfield(L, -2, key);
+}
+
+static void setboolfield (lua_State *L, const char *key, int value) {
+  if (value < 0)  /* undefined? */
+    return;  /* does not set field */
+  lua_pushboolean(L, value);
+  lua_setfield(L, -2, key);
+}
+
+static int getboolfield (lua_State *L, const char *key) {
+  int res;
+  lua_getfield(L, -1, key);
+  res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
+  lua_pop(L, 1);
+  return res;
+}
+
+
+static int getfield (lua_State *L, const char *key, int d) {
+  int res;
+  lua_getfield(L, -1, key);
+  if (lua_isnumber(L, -1))
+    res = (int)lua_tointeger(L, -1);
+  else {
+    if (d < 0)
+      return luaL_error(L, "field " LUA_QS " missing in date table", key);
+    res = d;
+  }
+  lua_pop(L, 1);
+  return res;
+}
+
+
+static int os_date (lua_State *L) {
+  const char *s = luaL_optstring(L, 1, "%c");
+  time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
+  struct tm *stm;
+  if (*s == '!') {  /* UTC? */
+    stm = gmtime(&t);
+    s++;  /* skip `!' */
+  }
+  else
+    stm = localtime(&t);
+  if (stm == NULL)  /* invalid date? */
+    lua_pushnil(L);
+  else if (strcmp(s, "*t") == 0) {
+    lua_createtable(L, 0, 9);  /* 9 = number of fields */
+    setfield(L, "sec", stm->tm_sec);
+    setfield(L, "min", stm->tm_min);
+    setfield(L, "hour", stm->tm_hour);
+    setfield(L, "day", stm->tm_mday);
+    setfield(L, "month", stm->tm_mon+1);
+    setfield(L, "year", stm->tm_year+1900);
+    setfield(L, "wday", stm->tm_wday+1);
+    setfield(L, "yday", stm->tm_yday+1);
+    setboolfield(L, "isdst", stm->tm_isdst);
+  }
+  else {
+    char cc[3];
+    luaL_Buffer b;
+    cc[0] = '%'; cc[2] = '\0';
+    luaL_buffinit(L, &b);
+    for (; *s; s++) {
+      if (*s != '%' || *(s + 1) == '\0')  /* no conversion specifier? */
+        luaL_addchar(&b, *s);
+      else {
+        size_t reslen;
+        char buff[200];  /* should be big enough for any conversion result */
+        cc[1] = *(++s);
+        reslen = strftime(buff, sizeof(buff), cc, stm);
+        luaL_addlstring(&b, buff, reslen);
+      }
+    }
+    luaL_pushresult(&b);
+  }
+  return 1;
+}
+
+
+static int os_time (lua_State *L) {
+  time_t t;
+  if (lua_isnoneornil(L, 1))  /* called without args? */
+    t = time(NULL);  /* get current time */
+  else {
+    struct tm ts;
+    luaL_checktype(L, 1, LUA_TTABLE);
+    lua_settop(L, 1);  /* make sure table is at the top */
+    ts.tm_sec = getfield(L, "sec", 0);
+    ts.tm_min = getfield(L, "min", 0);
+    ts.tm_hour = getfield(L, "hour", 12);
+    ts.tm_mday = getfield(L, "day", -1);
+    ts.tm_mon = getfield(L, "month", -1) - 1;
+    ts.tm_year = getfield(L, "year", -1) - 1900;
+    ts.tm_isdst = getboolfield(L, "isdst");
+    t = mktime(&ts);
+  }
+  if (t == (time_t)(-1))
+    lua_pushnil(L);
+  else
+    lua_pushnumber(L, (lua_Number)t);
+  return 1;
+}
+
+
+static int os_difftime (lua_State *L) {
+  lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
+                             (time_t)(luaL_optnumber(L, 2, 0))));
+  return 1;
+}
+
+/* }====================================================== */
+
+
+static int os_setlocale (lua_State *L) {
+  static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
+                      LC_NUMERIC, LC_TIME};
+  static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
+     "numeric", "time", NULL};
+  const char *l = luaL_optstring(L, 1, NULL);
+  int op = luaL_checkoption(L, 2, "all", catnames);
+  lua_pushstring(L, setlocale(cat[op], l));
+  return 1;
+}
+
+
+static int os_exit (lua_State *L) {
+  exit(luaL_optint(L, 1, EXIT_SUCCESS));
+}
+
+static const luaL_Reg syslib[] = {
+  {"clock",     os_clock},
+  {"date",      os_date},
+  {"difftime",  os_difftime},
+  {"execute",   os_execute},
+  {"exit",      os_exit},
+  {"getenv",    os_getenv},
+  {"remove",    os_remove},
+  {"rename",    os_rename},
+  {"setlocale", os_setlocale},
+  {"time",      os_time},
+  {"tmpname",   os_tmpname},
+  {NULL, NULL}
+};
+
+/* }====================================================== */
+
+
+
+LUALIB_API int luaopen_os (lua_State *L) {
+  luaL_register(L, LUA_OSLIBNAME, syslib);
+  return 1;
+}
+