9 |
10 | #define lmem_c
11 | #define LUA_CORE
12 |
13 | #include "lua.h"
14 |
15 | #include "ldebug.h"
16 | #include "ldo.h"
17 | #include "lmem.h"
18 | #include "lobject.h"
19 | #include "lstate.h"
20 |
21 |
22 |
23 | /*
24 | ** About the realloc function:
25 | ** void * frealloc (void *ud, void *ptr, size_t osize, size_t nsize);
26 | ** (`osize' is the old size, `nsize' is the new size)
27 | **
28 | ** Lua ensures that (ptr == NULL) iff (osize == 0).
29 | **
30 | ** * frealloc(ud, NULL, 0, x) creates a new block of size `x'
31 | **
32 | ** * frealloc(ud, p, x, 0) frees the block `p'
33 | ** (in this specific case, frealloc must return NULL).
34 | ** particularly, frealloc(ud, NULL, 0, 0) does nothing
35 | ** (which is equivalent to free(NULL) in ANSI C)
36 | **
37 | ** frealloc returns NULL if it cannot create or reallocate the area
38 | ** (any reallocation to an equal or smaller size cannot fail!)
39 | */
40 |
41 |
42 |
43 | #define MINSIZEARRAY 4
44 |
45 |
46 | void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
47 | int limit, const char *errormsg) {
48 | void *newblock;
49 | int newsize;
50 | if (*size >= limit/2) { /* cannot double it? */
51 | if (*size >= limit) /* cannot grow even a little? */
52 | luaG_runerror(L, errormsg);
53 | newsize = limit; /* still have at least one free place */
54 | }
55 | else {
56 | newsize = (*size)*2;
57 | if (newsize < MINSIZEARRAY)
58 | newsize = MINSIZEARRAY; /* minimum size */
59 | }
60 | newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
61 | *size = newsize; /* update only when everything else is OK */
62 | return newblock;
63 | }
64 |
65 |
66 | void *luaM_toobig (lua_State *L) {
67 | luaG_runerror(L, "memory allocation error: block too big");
68 | return NULL; /* to avoid warnings */
69 | }
70 |
71 |
72 |
73 | /*
74 | ** generic allocation routine.
75 | */
76 | void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
77 | global_State *g = G(L);
78 | lua_assert((osize == 0) == (block == NULL));
79 | block = (*g->frealloc)(g->ud, block, osize, nsize);
80 | if (block == NULL && nsize > 0)
81 | luaD_throw(L, LUA_ERRMEM);
82 | lua_assert((nsize == 0) == (block == NULL));
83 | g->totalbytes = (g->totalbytes - osize) + nsize;
84 | return block;
85 | }
86 |
87 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lparser.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lparser.h,v 1.57.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Lua Parser
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lparser_h
8 | #define lparser_h
9 |
10 | #include "llimits.h"
11 | #include "lobject.h"
12 | #include "lzio.h"
13 |
14 |
15 | /*
16 | ** Expression descriptor
17 | */
18 |
19 | typedef enum {
20 | VVOID, /* no value */
21 | VNIL,
22 | VTRUE,
23 | VFALSE,
24 | VK, /* info = index of constant in `k' */
25 | VKNUM, /* nval = numerical value */
26 | VLOCAL, /* info = local register */
27 | VUPVAL, /* info = index of upvalue in `upvalues' */
28 | VGLOBAL, /* info = index of table; aux = index of global name in `k' */
29 | VINDEXED, /* info = table register; aux = index register (or `k') */
30 | VJMP, /* info = instruction pc */
31 | VRELOCABLE, /* info = instruction pc */
32 | VNONRELOC, /* info = result register */
33 | VCALL, /* info = instruction pc */
34 | VVARARG /* info = instruction pc */
35 | } expkind;
36 |
37 | typedef struct expdesc {
38 | expkind k;
39 | union {
40 | struct { int info, aux; } s;
41 | lua_Number nval;
42 | } u;
43 | int t; /* patch list of `exit when true' */
44 | int f; /* patch list of `exit when false' */
45 | } expdesc;
46 |
47 |
48 | typedef struct upvaldesc {
49 | lu_byte k;
50 | lu_byte info;
51 | } upvaldesc;
52 |
53 |
54 | struct BlockCnt; /* defined in lparser.c */
55 |
56 |
57 | /* state needed to generate code for a given function */
58 | typedef struct FuncState {
59 | Proto *f; /* current function header */
60 | Table *h; /* table to find (and reuse) elements in `k' */
61 | struct FuncState *prev; /* enclosing function */
62 | struct LexState *ls; /* lexical state */
63 | struct lua_State *L; /* copy of the Lua state */
64 | struct BlockCnt *bl; /* chain of current blocks */
65 | int pc; /* next position to code (equivalent to `ncode') */
66 | int lasttarget; /* `pc' of last `jump target' */
67 | int jpc; /* list of pending jumps to `pc' */
68 | int freereg; /* first free register */
69 | int nk; /* number of elements in `k' */
70 | int np; /* number of elements in `p' */
71 | short nlocvars; /* number of elements in `locvars' */
72 | lu_byte nactvar; /* number of active local variables */
73 | upvaldesc upvalues[LUAI_MAXUPVALUES]; /* upvalues */
74 | unsigned short actvar[LUAI_MAXVARS]; /* declared-variable stack */
75 | } FuncState;
76 |
77 |
78 | LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
79 | const char *name);
80 |
81 |
82 | #endif
83 |
--------------------------------------------------------------------------------
/mLua/src/com/mob/tools/gui/CachePool.java:
--------------------------------------------------------------------------------
1 | package com.mob.tools.gui;
2 |
3 | /**
4 | * 一个简易的LRU缓存池。
5 | *
6 | * 构造实例时需要制定缓存池容量，缓存数据超过制定容量时，会删除队列尾部数据。
7 | * 新数据默认会插在队列头部。每次读取数据时，被读取的项目也会重新被提到队列头部。
8 | * 不接受空key。
9 | * get和put都是同步方法。
10 | */
11 | public class CachePool {
12 | private int capacity;
13 | private int size;
14 | private Node head;
15 | private Node tail;
16 |
17 | public CachePool(int capacity) {
18 | this.capacity = capacity;
19 | }
20 |
21 | public synchronized boolean put(K key, V value) {
22 | if (key == null || capacity <= 0) {
23 | return false;
24 | }
25 |
26 | Node n = null;
27 | while (size >= capacity) {
28 | n = tail;
29 | tail = tail.previous;
30 | tail.next = null;
31 | size--;
32 | }
33 |
34 | if (n == null) {
35 | n = new Node();
36 | }
37 | n.cacheTime = System.currentTimeMillis();
38 | n.key = key;
39 | n.value = value;
40 | n.previous = null;
41 | n.next = head;
42 |
43 | if (size == 0) {
44 | tail = n;
45 | } else {
46 | head.previous = n;
47 | }
48 | head = n;
49 | size++;
50 | return true;
51 | }
52 |
53 | public synchronized V get(K key) {
54 | Node n = head;
55 | while (n != null) {
56 | if (n.key.equals(key)) {
57 | break;
58 | } else {
59 | n = n.next;
60 | }
61 | }
62 |
63 | if (n != null) {
64 | if (n.previous != null) {
65 | if (n.next == null) {
66 | n.previous.next = null;
67 | tail = tail.previous;
68 | } else {
69 | n.previous.next = n.next;
70 | n.next.previous = n.previous;
71 | }
72 |
73 | n.previous = null;
74 | n.next = head;
75 | head.previous = n;
76 | head = n;
77 | }
78 |
79 | return n.value;
80 | }
81 |
82 | return null;
83 | }
84 |
85 | public synchronized void clear() {
86 | head = tail = null;
87 | size = 0;
88 | }
89 |
90 | public synchronized void trimBeforeTime(long time) {
91 | if (capacity <= 0) {
92 | return;
93 | }
94 |
95 | Node n = head;
96 | while (n != null) {
97 | if (n.cacheTime < time) {
98 | if (n.previous != null) {
99 | n.previous.next = n.next;
100 | }
101 | if (n.next != null) {
102 | n.next.previous = n.previous;
103 | }
104 | if (n.equals(head)) {
105 | head = head.next;
106 | }
107 | size--;
108 | }
109 | n = n.next;
110 | }
111 | }
112 |
113 | public int size() {
114 | return size;
115 | }
116 |
117 | private static class Node {
118 | public K key;
119 | public V value;
120 | public Node previous;
121 | public Node next;
122 | private long cacheTime;
123 | }
124 |
125 | }
126 |
--------------------------------------------------------------------------------
/mLua/src/m/lua/LuaObject.java:
--------------------------------------------------------------------------------
1 | package m.lua;
2 |
3 | public class LuaObject {
4 | int ref;
5 | Lua lua;
6 |
7 | public int type() {
8 | lua.rawGetI(Lua.LUA_REGISTRYINDEX, ref);
9 | int type = lua.type(-1);
10 | lua.pop(1);
11 | return type;
12 | }
13 |
14 | public LuaObject getField(String fieldName) {
15 | lua.rawGetI(Lua.LUA_REGISTRYINDEX, ref);
16 | lua.pushString(fieldName);
17 | lua.getTable(-2);
18 | lua.remove(-2);
19 | lua.pushValue(-1);
20 | int ref = lua.Lref(Lua.LUA_REGISTRYINDEX);;
21 | lua.pop(1);
22 |
23 | LuaObject field = new LuaObject();
24 | field.lua = lua;
25 | field.ref = ref;
26 | return field;
27 | }
28 |
29 | public Object call(Object[] args, int nres) throws Throwable {
30 | if (type() != Lua.LUA_TFUNCTION) {
31 | throw new Throwable("Invalid object. Not a function, table or userdata .");
32 | }
33 |
34 | int top = lua.getTop();
35 | lua.rawGetI(Lua.LUA_REGISTRYINDEX, ref);
36 | int nargs;
37 | if (args != null) {
38 | nargs = args.length;
39 | for (int i = 0; i < nargs; i++) {
40 | pushObjectValue(args[i]);
41 | }
42 | } else {
43 | nargs = 0;
44 | }
45 |
46 | int err = lua.pcall(nargs, nres, 0);
47 | if (err != 0) {
48 | String str;
49 | if (lua.isString(-1)) {
50 | str = lua.toString(-1);
51 | lua.pop(1);
52 | } else {
53 | str = "";
54 | }
55 |
56 | if (err == Lua.LUA_ERRRUN) {
57 | throw new Throwable("Runtime error. " + str);
58 | } else if (err == Lua.LUA_ERRMEM) {
59 | throw new Throwable("Memory allocation error. " + str);
60 | } else if (err == Lua.LUA_ERRERR) {
61 | throw new Throwable("Error while running the error handler function. " + str);
62 | } else {
63 | throw new Throwable("Lua Error code " + err + ". " + str);
64 | }
65 | }
66 |
67 | if (nres == Lua.LUA_MULTRET) {
68 | nres = lua.getTop() - top;
69 | }
70 |
71 | if (lua.getTop() - top < nres) {
72 | throw new Throwable("Invalid Number of Results .");
73 | }
74 |
75 | Object[] res = new Object[nres];
76 | for (int i = nres; i > 0; i--) {
77 | res[i - 1] = lua.toJavaObject(-1);
78 | lua.pop(1);
79 | }
80 | if (nres > 0) {
81 | return res[0];
82 | } else {
83 | return null;
84 | }
85 | }
86 |
87 | private void pushObjectValue(Object obj) throws Throwable {
88 | if (obj == null) {
89 | lua.pushNil();
90 | } else if (obj instanceof JavaFunction) {
91 | lua.pushJavaFunction((JavaFunction) obj);
92 | } else if (obj instanceof LuaObject) {
93 | lua.rawGetI(Lua.LUA_REGISTRYINDEX, ((LuaObject) obj).ref);
94 | } else {
95 | lua.pushJavaObject(obj);
96 | }
97 | }
98 |
99 | public String toString() {
100 | return String.valueOf(ref);
101 | }
102 |
103 | }
104 |
--------------------------------------------------------------------------------
/mLua/jni/lua/llimits.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: llimits.h,v 1.69.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Limits, basic types, and some other `installation-dependent' definitions
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef llimits_h
8 | #define llimits_h
9 |
10 |
11 | #include
12 | #include
13 |
14 |
15 | #include "lua.h"
16 |
17 |
18 | typedef LUAI_UINT32 lu_int32;
19 |
20 | typedef LUAI_UMEM lu_mem;
21 |
22 | typedef LUAI_MEM l_mem;
23 |
24 |
25 |
26 | /* chars used as small naturals (so that `char' is reserved for characters) */
27 | typedef unsigned char lu_byte;
28 |
29 |
30 | #define MAX_SIZET ((size_t)(~(size_t)0)-2)
31 |
32 | #define MAX_LUMEM ((lu_mem)(~(lu_mem)0)-2)
33 |
34 |
35 | #define MAX_INT (INT_MAX-2) /* maximum value of an int (-2 for safety) */
36 |
37 | /*
38 | ** conversion of pointer to integer
39 | ** this is for hashing only; there is no problem if the integer
40 | ** cannot hold the whole pointer value
41 | */
42 | #define IntPoint(p) ((unsigned int)(lu_mem)(p))
43 |
44 |
45 |
46 | /* type to ensure maximum alignment */
47 | typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
48 |
49 |
50 | /* result of a `usual argument conversion' over lua_Number */
51 | typedef LUAI_UACNUMBER l_uacNumber;
52 |
53 |
54 | /* internal assertions for in-house debugging */
55 | #ifdef lua_assert
56 |
57 | #define check_exp(c,e) (lua_assert(c), (e))
58 | #define api_check(l,e) lua_assert(e)
59 |
60 | #else
61 |
62 | #define lua_assert(c) ((void)0)
63 | #define check_exp(c,e) (e)
64 | #define api_check luai_apicheck
65 |
66 | #endif
67 |
68 |
69 | #ifndef UNUSED
70 | #define UNUSED(x) ((void)(x)) /* to avoid warnings */
71 | #endif
72 |
73 |
74 | #ifndef cast
75 | #define cast(t, exp) ((t)(exp))
76 | #endif
77 |
78 | #define cast_byte(i) cast(lu_byte, (i))
79 | #define cast_num(i) cast(lua_Number, (i))
80 | #define cast_int(i) cast(int, (i))
81 |
82 |
83 |
84 | /*
85 | ** type for virtual-machine instructions
86 | ** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
87 | */
88 | typedef lu_int32 Instruction;
89 |
90 |
91 |
92 | /* maximum stack for a Lua function */
93 | #define MAXSTACK 250
94 |
95 |
96 |
97 | /* minimum size for the string table (must be power of 2) */
98 | #ifndef MINSTRTABSIZE
99 | #define MINSTRTABSIZE 32
100 | #endif
101 |
102 |
103 | /* minimum size for string buffer */
104 | #ifndef LUA_MINBUFFER
105 | #define LUA_MINBUFFER 32
106 | #endif
107 |
108 |
109 | #ifndef lua_lock
110 | #define lua_lock(L) ((void) 0)
111 | #define lua_unlock(L) ((void) 0)
112 | #endif
113 |
114 | #ifndef luai_threadyield
115 | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);}
116 | #endif
117 |
118 |
119 | /*
120 | ** macro to control inclusion of some hard tests on stack reallocation
121 | */
122 | #ifndef HARDSTACKTESTS
123 | #define condhardstacktests(x) ((void)0)
124 | #else
125 | #define condhardstacktests(x) x
126 | #endif
127 |
128 | #endif
129 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lcode.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lcode.h,v 1.48.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Code generator for Lua
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lcode_h
8 | #define lcode_h
9 |
10 | #include "llex.h"
11 | #include "lobject.h"
12 | #include "lopcodes.h"
13 | #include "lparser.h"
14 |
15 |
16 | /*
17 | ** Marks the end of a patch list. It is an invalid value both as an absolute
18 | ** address, and as a list link (would link an element to itself).
19 | */
20 | #define NO_JUMP (-1)
21 |
22 |
23 | /*
24 | ** grep "ORDER OPR" if you change these enums
25 | */
26 | typedef enum BinOpr {
27 | OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW,
28 | OPR_CONCAT,
29 | OPR_NE, OPR_EQ,
30 | OPR_LT, OPR_LE, OPR_GT, OPR_GE,
31 | OPR_AND, OPR_OR,
32 | OPR_NOBINOPR
33 | } BinOpr;
34 |
35 |
36 | typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
37 |
38 |
39 | #define getcode(fs,e) ((fs)->f->code[(e)->u.s.info])
40 |
41 | #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
42 |
43 | #define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET)
44 |
45 | LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
46 | LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
47 | LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
48 | LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
49 | LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
50 | LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
51 | LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
52 | LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r);
53 | LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
54 | LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
55 | LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e);
56 | LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e);
57 | LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e);
58 | LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
59 | LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
60 | LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e);
61 | LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
62 | LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults);
63 | LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
64 | LUAI_FUNC int luaK_jump (FuncState *fs);
65 | LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
66 | LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
67 | LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
68 | LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
69 | LUAI_FUNC int luaK_getlabel (FuncState *fs);
70 | LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
71 | LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
72 | LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
73 | LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
74 |
75 |
76 | #endif
77 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lopcodes.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lopcodes.c,v 1.37.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** See Copyright Notice in lua.h
4 | */
5 |
6 |
7 | #define lopcodes_c
8 | #define LUA_CORE
9 |
10 |
11 | #include "lopcodes.h"
12 |
13 |
14 | /* ORDER OP */
15 |
16 | const char *const luaP_opnames[NUM_OPCODES+1] = {
17 | "MOVE",
18 | "LOADK",
19 | "LOADBOOL",
20 | "LOADNIL",
21 | "GETUPVAL",
22 | "GETGLOBAL",
23 | "GETTABLE",
24 | "SETGLOBAL",
25 | "SETUPVAL",
26 | "SETTABLE",
27 | "NEWTABLE",
28 | "SELF",
29 | "ADD",
30 | "SUB",
31 | "MUL",
32 | "DIV",
33 | "MOD",
34 | "POW",
35 | "UNM",
36 | "NOT",
37 | "LEN",
38 | "CONCAT",
39 | "JMP",
40 | "EQ",
41 | "LT",
42 | "LE",
43 | "TEST",
44 | "TESTSET",
45 | "CALL",
46 | "TAILCALL",
47 | "RETURN",
48 | "FORLOOP",
49 | "FORPREP",
50 | "TFORLOOP",
51 | "SETLIST",
52 | "CLOSE",
53 | "CLOSURE",
54 | "VARARG",
55 | NULL
56 | };
57 |
58 |
59 | #define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
60 |
61 | const lu_byte luaP_opmodes[NUM_OPCODES] = {
62 | /* T A B C mode opcode */
63 | opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */
64 | ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */
65 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */
66 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LOADNIL */
67 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */
68 | ,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_GETGLOBAL */
69 | ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */
70 | ,opmode(0, 0, OpArgK, OpArgN, iABx) /* OP_SETGLOBAL */
71 | ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */
72 | ,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */
73 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */
74 | ,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */
75 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */
76 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */
77 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */
78 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */
79 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */
80 | ,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */
81 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */
82 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */
83 | ,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */
84 | ,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */
85 | ,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */
86 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */
87 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */
88 | ,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */
89 | ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TEST */
90 | ,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */
91 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */
92 | ,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */
93 | ,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */
94 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */
95 | ,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */
96 | ,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TFORLOOP */
97 | ,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */
98 | ,opmode(0, 0, OpArgN, OpArgN, iABC) /* OP_CLOSE */
99 | ,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */
100 | ,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */
101 | };
102 |
103 |
--------------------------------------------------------------------------------
/mLua/src/m/lua/LuaWrapper.java:
--------------------------------------------------------------------------------
1 | package m.lua;
2 |
3 | import java.util.HashMap;
4 | import java.util.Map.Entry;
5 |
6 | public class LuaWrapper {
7 | private HashMap objects;
8 | private HashMap functions;
9 | private SourceLoader loader;
10 | private Lua lua;
11 |
12 | public LuaWrapper() {
13 | objects = new HashMap();
14 | functions = new HashMap();
15 | }
16 |
17 | public void setSourceLoader(SourceLoader loader) {
18 | this.loader = loader;
19 | }
20 |
21 | public void addJavaObject(String name, Object object) {
22 | objects.put(name, object);
23 | }
24 |
25 | public void addJavaFunction(String name, JavaFunction function) {
26 | functions.put(name, function);
27 | }
28 |
29 | public synchronized void start(String path) throws Throwable {
30 | if (lua == null) {
31 | openLua();
32 | overwriteRequire();
33 | pushJavaObjects();
34 | pushJavaFunctions();
35 | eval(path);
36 | }
37 | }
38 |
39 | private void openLua() throws Throwable {
40 | lua = new Lua();
41 | lua.open();
42 | lua.openLibs();
43 | }
44 |
45 | private void overwriteRequire() throws Throwable {
46 | JavaFunction requireImpl = new JavaFunction() {
47 | public Object execute(Object[] args) throws Throwable {
48 | String name = (String) args[0];
49 |
50 | byte[] bytes = null;
51 | if (loader != null) {
52 | bytes = loader.loadFile(name);
53 | }
54 |
55 | if (bytes == null) {
56 | throw new Throwable("Cannot load module " + name);
57 | } else {
58 | lua.LloadBuffer(bytes, bytes.length, name);
59 | }
60 |
61 | return name;
62 | }
63 | };
64 |
65 | lua.getGlobal("package");
66 | lua.getField(-1, "loaders");
67 | int nLoaders = lua.objlen(-1);
68 |
69 | lua.pushJavaFunction(requireImpl);
70 | lua.rawSetI(-2, nLoaders + 1);
71 | lua.pop(1);
72 | }
73 |
74 | private void pushJavaObjects() throws Throwable {
75 | for (Entry ent : objects.entrySet()) {
76 | lua.pushJavaObject(ent.getValue());
77 | lua.setGlobal(ent.getKey());
78 | }
79 | objects.clear();
80 | }
81 |
82 | private void pushJavaFunctions() throws Throwable {
83 | for (Entry ent : functions.entrySet()) {
84 | lua.pushJavaFunction(ent.getValue());
85 | lua.setGlobal(ent.getKey());
86 | }
87 | functions.clear();
88 | }
89 |
90 | private void eval(String path) throws Throwable {
91 | byte[] script = null;
92 | if (loader != null) {
93 | script = loader.loadFile(path);
94 | }
95 | if (script == null) {
96 | throw new Throwable();
97 | }
98 |
99 | int ok = lua.LloadString(new String(script, "utf-8"));
100 | if (ok == 0) {
101 | lua.getGlobal("debug");
102 | lua.getField(-1, "traceback");
103 | lua.remove(-2);
104 | lua.insert(-2);
105 | ok = lua.pcall(0, 0, -2);
106 | if (ok == 0) {
107 | return;
108 | }
109 | }
110 |
111 | String msg = lua.toString(-1);
112 | throw new Throwable(errorReason(ok) + ": " + msg);
113 | }
114 |
115 | private String errorReason(int error) {
116 | switch (error) {
117 | case 4: return "Out of memory";
118 | case 3: return "Syntax error";
119 | case 2: return "Runtime error";
120 | case 1: return "Yield error";
121 | }
122 | return "Unknown error " + error;
123 | }
124 |
125 | public synchronized void stop() {
126 | if (lua != null) {
127 | lua.close();
128 | lua = null;
129 | }
130 | }
131 |
132 | }
133 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lstring.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lstring.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** String table (keeps all strings handled by Lua)
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 |
10 | #define lstring_c
11 | #define LUA_CORE
12 |
13 | #include "lua.h"
14 |
15 | #include "lmem.h"
16 | #include "lobject.h"
17 | #include "lstate.h"
18 | #include "lstring.h"
19 |
20 |
21 |
22 | void luaS_resize (lua_State *L, int newsize) {
23 | GCObject **newhash;
24 | stringtable *tb;
25 | int i;
26 | if (G(L)->gcstate == GCSsweepstring)
27 | return; /* cannot resize during GC traverse */
28 | newhash = luaM_newvector(L, newsize, GCObject *);
29 | tb = &G(L)->strt;
30 | for (i=0; isize; i++) {
33 | GCObject *p = tb->hash[i];
34 | while (p) { /* for each node in the list */
35 | GCObject *next = p->gch.next; /* save next */
36 | unsigned int h = gco2ts(p)->hash;
37 | int h1 = lmod(h, newsize); /* new position */
38 | lua_assert(cast_int(h%newsize) == lmod(h, newsize));
39 | p->gch.next = newhash[h1]; /* chain it */
40 | newhash[h1] = p;
41 | p = next;
42 | }
43 | }
44 | luaM_freearray(L, tb->hash, tb->size, TString *);
45 | tb->size = newsize;
46 | tb->hash = newhash;
47 | }
48 |
49 |
50 | static TString *newlstr (lua_State *L, const char *str, size_t l,
51 | unsigned int h) {
52 | TString *ts;
53 | stringtable *tb;
54 | if (l+1 > (MAX_SIZET - sizeof(TString))/sizeof(char))
55 | luaM_toobig(L);
56 | ts = cast(TString *, luaM_malloc(L, (l+1)*sizeof(char)+sizeof(TString)));
57 | ts->tsv.len = l;
58 | ts->tsv.hash = h;
59 | ts->tsv.marked = luaC_white(G(L));
60 | ts->tsv.tt = LUA_TSTRING;
61 | ts->tsv.reserved = 0;
62 | memcpy(ts+1, str, l*sizeof(char));
63 | ((char *)(ts+1))[l] = '\0'; /* ending 0 */
64 | tb = &G(L)->strt;
65 | h = lmod(h, tb->size);
66 | ts->tsv.next = tb->hash[h]; /* chain new entry */
67 | tb->hash[h] = obj2gco(ts);
68 | tb->nuse++;
69 | if (tb->nuse > cast(lu_int32, tb->size) && tb->size <= MAX_INT/2)
70 | luaS_resize(L, tb->size*2); /* too crowded */
71 | return ts;
72 | }
73 |
74 |
75 | TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
76 | GCObject *o;
77 | unsigned int h = cast(unsigned int, l); /* seed */
78 | size_t step = (l>>5)+1; /* if string is too long, don't hash all its chars */
79 | size_t l1;
80 | for (l1=l; l1>=step; l1-=step) /* compute hash */
81 | h = h ^ ((h<<5)+(h>>2)+cast(unsigned char, str[l1-1]));
82 | for (o = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
83 | o != NULL;
84 | o = o->gch.next) {
85 | TString *ts = rawgco2ts(o);
86 | if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
87 | /* string may be dead */
88 | if (isdead(G(L), o)) changewhite(o);
89 | return ts;
90 | }
91 | }
92 | return newlstr(L, str, l, h); /* not found */
93 | }
94 |
95 |
96 | Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
97 | Udata *u;
98 | if (s > MAX_SIZET - sizeof(Udata))
99 | luaM_toobig(L);
100 | u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
101 | u->uv.marked = luaC_white(G(L)); /* is not finalized */
102 | u->uv.tt = LUA_TUSERDATA;
103 | u->uv.len = s;
104 | u->uv.metatable = NULL;
105 | u->uv.env = e;
106 | /* chain it on udata list (after main thread) */
107 | u->uv.next = G(L)->mainthread->next;
108 | G(L)->mainthread->next = obj2gco(u);
109 | return u;
110 | }
111 |
112 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lgc.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lgc.h,v 2.15.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Garbage Collector
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lgc_h
8 | #define lgc_h
9 |
10 |
11 | #include "lobject.h"
12 |
13 |
14 | /*
15 | ** Possible states of the Garbage Collector
16 | */
17 | #define GCSpause 0
18 | #define GCSpropagate 1
19 | #define GCSsweepstring 2
20 | #define GCSsweep 3
21 | #define GCSfinalize 4
22 |
23 |
24 | /*
25 | ** some userful bit tricks
26 | */
27 | #define resetbits(x,m) ((x) &= cast(lu_byte, ~(m)))
28 | #define setbits(x,m) ((x) |= (m))
29 | #define testbits(x,m) ((x) & (m))
30 | #define bitmask(b) (1<<(b))
31 | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2))
32 | #define l_setbit(x,b) setbits(x, bitmask(b))
33 | #define resetbit(x,b) resetbits(x, bitmask(b))
34 | #define testbit(x,b) testbits(x, bitmask(b))
35 | #define set2bits(x,b1,b2) setbits(x, (bit2mask(b1, b2)))
36 | #define reset2bits(x,b1,b2) resetbits(x, (bit2mask(b1, b2)))
37 | #define test2bits(x,b1,b2) testbits(x, (bit2mask(b1, b2)))
38 |
39 |
40 |
41 | /*
42 | ** Layout for bit use in `marked' field:
43 | ** bit 0 - object is white (type 0)
44 | ** bit 1 - object is white (type 1)
45 | ** bit 2 - object is black
46 | ** bit 3 - for userdata: has been finalized
47 | ** bit 3 - for tables: has weak keys
48 | ** bit 4 - for tables: has weak values
49 | ** bit 5 - object is fixed (should not be collected)
50 | ** bit 6 - object is "super" fixed (only the main thread)
51 | */
52 |
53 |
54 | #define WHITE0BIT 0
55 | #define WHITE1BIT 1
56 | #define BLACKBIT 2
57 | #define FINALIZEDBIT 3
58 | #define KEYWEAKBIT 3
59 | #define VALUEWEAKBIT 4
60 | #define FIXEDBIT 5
61 | #define SFIXEDBIT 6
62 | #define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT)
63 |
64 |
65 | #define iswhite(x) test2bits((x)->gch.marked, WHITE0BIT, WHITE1BIT)
66 | #define isblack(x) testbit((x)->gch.marked, BLACKBIT)
67 | #define isgray(x) (!isblack(x) && !iswhite(x))
68 |
69 | #define otherwhite(g) (g->currentwhite ^ WHITEBITS)
70 | #define isdead(g,v) ((v)->gch.marked & otherwhite(g) & WHITEBITS)
71 |
72 | #define changewhite(x) ((x)->gch.marked ^= WHITEBITS)
73 | #define gray2black(x) l_setbit((x)->gch.marked, BLACKBIT)
74 |
75 | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x)))
76 |
77 | #define luaC_white(g) cast(lu_byte, (g)->currentwhite & WHITEBITS)
78 |
79 |
80 | #define luaC_checkGC(L) { \
81 | condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1)); \
82 | if (G(L)->totalbytes >= G(L)->GCthreshold) \
83 | luaC_step(L); }
84 |
85 |
86 | #define luaC_barrier(L,p,v) { if (valiswhite(v) && isblack(obj2gco(p))) \
87 | luaC_barrierf(L,obj2gco(p),gcvalue(v)); }
88 |
89 | #define luaC_barriert(L,t,v) { if (valiswhite(v) && isblack(obj2gco(t))) \
90 | luaC_barrierback(L,t); }
91 |
92 | #define luaC_objbarrier(L,p,o) \
93 | { if (iswhite(obj2gco(o)) && isblack(obj2gco(p))) \
94 | luaC_barrierf(L,obj2gco(p),obj2gco(o)); }
95 |
96 | #define luaC_objbarriert(L,t,o) \
97 | { if (iswhite(obj2gco(o)) && isblack(obj2gco(t))) luaC_barrierback(L,t); }
98 |
99 | LUAI_FUNC size_t luaC_separateudata (lua_State *L, int all);
100 | LUAI_FUNC void luaC_callGCTM (lua_State *L);
101 | LUAI_FUNC void luaC_freeall (lua_State *L);
102 | LUAI_FUNC void luaC_step (lua_State *L);
103 | LUAI_FUNC void luaC_fullgc (lua_State *L);
104 | LUAI_FUNC void luaC_link (lua_State *L, GCObject *o, lu_byte tt);
105 | LUAI_FUNC void luaC_linkupval (lua_State *L, UpVal *uv);
106 | LUAI_FUNC void luaC_barrierf (lua_State *L, GCObject *o, GCObject *v);
107 | LUAI_FUNC void luaC_barrierback (lua_State *L, Table *t);
108 |
109 |
110 | #endif
111 |
--------------------------------------------------------------------------------
/mLua/jni/lua/ldump.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ldump.c,v 2.8.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** save precompiled Lua chunks
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #include
8 |
9 | #define ldump_c
10 | #define LUA_CORE
11 |
12 | #include "lua.h"
13 |
14 | #include "lobject.h"
15 | #include "lstate.h"
16 | #include "lundump.h"
17 |
18 | typedef struct {
19 | lua_State* L;
20 | lua_Writer writer;
21 | void* data;
22 | int strip;
23 | int status;
24 | } DumpState;
25 |
26 | #define DumpMem(b,n,size,D) DumpBlock(b,(n)*(size),D)
27 | #define DumpVar(x,D) DumpMem(&x,1,sizeof(x),D)
28 |
29 | static void DumpBlock(const void* b, size_t size, DumpState* D)
30 | {
31 | if (D->status==0)
32 | {
33 | lua_unlock(D->L);
34 | D->status=(*D->writer)(D->L,b,size,D->data);
35 | lua_lock(D->L);
36 | }
37 | }
38 |
39 | static void DumpChar(int y, DumpState* D)
40 | {
41 | char x=(char)y;
42 | DumpVar(x,D);
43 | }
44 |
45 | static void DumpInt(int x, DumpState* D)
46 | {
47 | DumpVar(x,D);
48 | }
49 |
50 | static void DumpNumber(lua_Number x, DumpState* D)
51 | {
52 | DumpVar(x,D);
53 | }
54 |
55 | static void DumpVector(const void* b, int n, size_t size, DumpState* D)
56 | {
57 | DumpInt(n,D);
58 | DumpMem(b,n,size,D);
59 | }
60 |
61 | static void DumpString(const TString* s, DumpState* D)
62 | {
63 | if (s==NULL || getstr(s)==NULL)
64 | {
65 | size_t size=0;
66 | DumpVar(size,D);
67 | }
68 | else
69 | {
70 | size_t size=s->tsv.len+1; /* include trailing '\0' */
71 | DumpVar(size,D);
72 | DumpBlock(getstr(s),size,D);
73 | }
74 | }
75 |
76 | #define DumpCode(f,D) DumpVector(f->code,f->sizecode,sizeof(Instruction),D)
77 |
78 | static void DumpFunction(const Proto* f, const TString* p, DumpState* D);
79 |
80 | static void DumpConstants(const Proto* f, DumpState* D)
81 | {
82 | int i,n=f->sizek;
83 | DumpInt(n,D);
84 | for (i=0; ik[i];
87 | DumpChar(ttype(o),D);
88 | switch (ttype(o))
89 | {
90 | case LUA_TNIL:
91 | break;
92 | case LUA_TBOOLEAN:
93 | DumpChar(bvalue(o),D);
94 | break;
95 | case LUA_TNUMBER:
96 | DumpNumber(nvalue(o),D);
97 | break;
98 | case LUA_TSTRING:
99 | DumpString(rawtsvalue(o),D);
100 | break;
101 | default:
102 | lua_assert(0); /* cannot happen */
103 | break;
104 | }
105 | }
106 | n=f->sizep;
107 | DumpInt(n,D);
108 | for (i=0; ip[i],f->source,D);
109 | }
110 |
111 | static void DumpDebug(const Proto* f, DumpState* D)
112 | {
113 | int i,n;
114 | n= (D->strip) ? 0 : f->sizelineinfo;
115 | DumpVector(f->lineinfo,n,sizeof(int),D);
116 | n= (D->strip) ? 0 : f->sizelocvars;
117 | DumpInt(n,D);
118 | for (i=0; ilocvars[i].varname,D);
121 | DumpInt(f->locvars[i].startpc,D);
122 | DumpInt(f->locvars[i].endpc,D);
123 | }
124 | n= (D->strip) ? 0 : f->sizeupvalues;
125 | DumpInt(n,D);
126 | for (i=0; iupvalues[i],D);
127 | }
128 |
129 | static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
130 | {
131 | DumpString((f->source==p || D->strip) ? NULL : f->source,D);
132 | DumpInt(f->linedefined,D);
133 | DumpInt(f->lastlinedefined,D);
134 | DumpChar(f->nups,D);
135 | DumpChar(f->numparams,D);
136 | DumpChar(f->is_vararg,D);
137 | DumpChar(f->maxstacksize,D);
138 | DumpCode(f,D);
139 | DumpConstants(f,D);
140 | DumpDebug(f,D);
141 | }
142 |
143 | static void DumpHeader(DumpState* D)
144 | {
145 | char h[LUAC_HEADERSIZE];
146 | luaU_header(h);
147 | DumpBlock(h,LUAC_HEADERSIZE,D);
148 | }
149 |
150 | /*
151 | ** dump Lua function as precompiled chunk
152 | */
153 | int luaU_dump (lua_State* L, const Proto* f, lua_Writer w, void* data, int strip)
154 | {
155 | DumpState D;
156 | D.L=L;
157 | D.writer=w;
158 | D.data=data;
159 | D.strip=strip;
160 | D.status=0;
161 | DumpHeader(&D);
162 | DumpFunction(f,NULL,&D);
163 | return D.status;
164 | }
165 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # 介绍
2 |
3 | 当下多数在java下执行lua脚本的程序都是用了**luajava**。然而luajava存在一些严重的问题，它会将byte数组和string等同对待，而且它的反射执行效率比较低。为了弥补这些问题，我参考luajava，重写了它的java和jni代码，并以mLua为名重新发布。
4 |
5 | # 特点描述
6 |
7 | 和luajava类似的，mLua也有内置的全局lua函数；java对象和lua对象可以通过jni层代码进行交换。但是mLua禁止lua直接操作java对象，如果想在lua中使用java对象，必须使用内置的全局函数实现。
8 |
9 | mLua区分byte数组和string。在mLua中，java的byte数组对lua端而言，只是一个普通的userdata。
10 |
11 | 在跨语言数据交换的时候，string是被复制的，因此当一个string从lua传递到java后再于lua中修改它，它在java端的对应版本并不会随着改变。
12 |
13 | 将lua端的number传递给java后，会被优先解释为byte类型，否则将依照byte - short - int - long - float - double链条来尝试解释。
14 |
15 | mLua不对外暴露lua解析器实例，所有的操作都基于MLua实例完成。
16 |
17 | # java端方法描述
18 |
19 | mLua的java端方法集中在MLua中：
20 |
21 | 方法名称 | 方法解释
22 | --------------------------- | -------------
23 | setBasedir(String) | 设置lua代码的最外层目录，所有lua代码都应该存放在这个目录或其子目录下
24 | pushGlobal(String, Object) | 设置全局lua的全局变量或函数，可以push普通的Object，或者JavaFunction。
后者表示一个lua函数的java实现。只有在start方法执行前，设置的数据才会生
效
25 | start(String) | 启动lua解析器，传递的参数表示lua代码的入口文件
26 | stop() | 停止lua解析器并释放资源
27 |
28 | 除此之外，JavaFunction也是使用者可能需要用到的接口。它表示一个lua函数的java实现。其回调方法execute(Object[])方法会传入从lua端输入的数据，并输出一个结果传回lua端。如果方法本身不需要返回数据，则返回null即可。
29 |
30 | # lua端函数描述
31 |
32 | 在mLua下，lua原来的require、print函数已经被改写。
33 |
34 | ## require
35 |
36 | require必须使用设置在java端的basedir为根目录的相对路径引用其他lua脚本：
37 |
38 | ``` lua
39 | require "dir1/dir2/script1"
40 | require "script2"
41 | ```
42 |
43 | ## print
44 |
45 | 支持输出一个或多个对象，但是不能将string与java对象作拼接：
46 |
47 | ``` lua
48 | -- 正确的做法 --
49 | print("hello mLua")
50 | print("context: ", getContext())
51 | print("string " .. 111)
52 |
53 | -- 错误的做法 --
54 | print("context: " .. getContext())
55 | ```
56 |
57 | 通过逗号分隔的对象会在java端以tab号分隔显示
58 |
59 | ## 操作java对象
60 |
61 | mLua也采用反射来操作java对象，不过**mobTools**的ReflectHelper具备缓存功能，理论上会比luajava每次直接反射更快。mLua提供了如下的内置函数：
62 |
63 | 函数名称 | 函数解释
64 | --------------------------------------------- | ----------
65 | import(className) | 向ReflectHelper类缓存中导入一个类，此函数将返回一个
string，用于后续代码从缓存中重新获取导入的类实例
66 | import(name, className) | 向ReflectHelper类缓存中导入一个类，并将此缓存的key
设置为指定名称
67 | new(className, ...) | 构造一个java实例，参数className是import函数的返回值，
后续参数为java构造方法的输入参数
68 | invokeStatic(className, methodName, ...) | 调用一个java的静态方法
69 | invoke(receiver, methodName, ...) | 调用一个Java的实例方法
70 | getStatic(className, fieldName) | 获取一个java的静态字段
71 | setStatic(className, fieldName, value) | 设置一个java的静态字段
72 | get(receiver, fieldName) | 获取一个java的实例字段
73 | set(receiver, fieldName, value) | 设置一个java的实例字段
74 | createProxy(proxyTable, ...) | 构造一个java接口代理。参数proxyTable是一个lua的table，
其中的key必须与java接口类的方法名称相同，key对应的
value是一个lua的function，function的参数列表和返回值也
必须与java接口相同。proxyTable后的参数是被实现的接口
列表名称，皆为string，由import函数返回。此函数将返回一
个java接口代理实例，可将此实例传回java端并进行操作，
当实例中的接口函数被调用时，mLua会调用proxyTable中的
对应funtion代码完成操作
75 |
76 | # 例子
77 |
78 | ## java端代码
79 |
80 | ``` java
81 | public class MainActivity extends Activity {
82 | private MLua lua;
83 |
84 | protected void onCreate(Bundle savedInstanceState) {
85 | super.onCreate(savedInstanceState);
86 | // 构造一个解析器实例
87 | lua = new MLua();
88 | // 设置lua代码存放位置
89 | lua.setBasedir("/sdcard/mLua/LuaTest");
90 | // push全局对象
91 | lua.pushGlobal("getContext", new JavaFunction() {
92 | public Object execute(Object[] args) throws Throwable {
93 | return getApplication();
94 | }
95 | });
96 | try {
97 | // 启动解析器，设置main.lua为入口代码
98 | lua.start("main");
99 | } catch (Throwable e) {
100 | e.printStackTrace();
101 | }
102 | }
103 |
104 | protected void onDestroy() {
105 | // 关闭解析器
106 | lua.stop();
107 | super.onDestroy();
108 | }
109 | }
110 | ```
111 |
112 | ## lua端代码
113 |
114 | ``` lua
115 | -- 导入ReflectHelper.ReflectRunnable类，并命名为ReflectRunnable --
116 | import("ReflectRunnable", "com.mob.tools.utils.ReflectHelper$ReflectRunnable")
117 |
118 | local function main()
119 | -- 演示print和invoke --
120 | print("hello world from mLua")
121 | local context = getContext()
122 | print("current context: ", context)
123 | local packageName = invoke(context, "getPackageName")
124 | print("packageName: ", packageName)
125 |
126 | -- 演示java接口代理 --
127 | local luaCode = {
128 | run = function(arg)
129 | print("luaCode.run(), input: ", arg)
130 | return "yoyoyo"
131 | end
132 | }
133 | local proxy = createProxy(luaCode, "ReflectRunnable")
134 | local res = invoke(proxy, "run", packageName)
135 | print("luaCode.run(), output: ", res)
136 |
137 | -- 演示数组复制 --
138 | local bArray = new("[B", 16)
139 | for i = 0, 15 do
140 | set(bArray, "[" .. i .. "]", i + 1)
141 | end
142 |
143 | local bArray2 = new("[B", get(bArray, "length"))
144 | invokeStatic("System", "arraycopy", bArray, 0, bArray2, 0, 16)
145 |
146 | for i = 0, 15 do
147 | print("bArray2[" .. i .. "]: ", get(bArray2, "[" .. i .. "]"))
148 | end
149 | end
150 |
151 | main()
152 | ```
153 |
154 | # 扩展
155 |
156 | mLua默认只能从文件系统中加载lua代码，但是如果对MLua的setBasedir方法进行重写，以其他的方式实现SourceLoader，则可以加载任意方式的lua代码，包括assets中的，和加密的。
157 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lfunc.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lfunc.c,v 2.12.1.2 2007/12/28 14:58:43 roberto Exp $
3 | ** Auxiliary functions to manipulate prototypes and closures
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 |
10 | #define lfunc_c
11 | #define LUA_CORE
12 |
13 | #include "lua.h"
14 |
15 | #include "lfunc.h"
16 | #include "lgc.h"
17 | #include "lmem.h"
18 | #include "lobject.h"
19 | #include "lstate.h"
20 |
21 |
22 |
23 | Closure *luaF_newCclosure (lua_State *L, int nelems, Table *e) {
24 | Closure *c = cast(Closure *, luaM_malloc(L, sizeCclosure(nelems)));
25 | luaC_link(L, obj2gco(c), LUA_TFUNCTION);
26 | c->c.isC = 1;
27 | c->c.env = e;
28 | c->c.nupvalues = cast_byte(nelems);
29 | return c;
30 | }
31 |
32 |
33 | Closure *luaF_newLclosure (lua_State *L, int nelems, Table *e) {
34 | Closure *c = cast(Closure *, luaM_malloc(L, sizeLclosure(nelems)));
35 | luaC_link(L, obj2gco(c), LUA_TFUNCTION);
36 | c->l.isC = 0;
37 | c->l.env = e;
38 | c->l.nupvalues = cast_byte(nelems);
39 | while (nelems--) c->l.upvals[nelems] = NULL;
40 | return c;
41 | }
42 |
43 |
44 | UpVal *luaF_newupval (lua_State *L) {
45 | UpVal *uv = luaM_new(L, UpVal);
46 | luaC_link(L, obj2gco(uv), LUA_TUPVAL);
47 | uv->v = &uv->u.value;
48 | setnilvalue(uv->v);
49 | return uv;
50 | }
51 |
52 |
53 | UpVal *luaF_findupval (lua_State *L, StkId level) {
54 | global_State *g = G(L);
55 | GCObject **pp = &L->openupval;
56 | UpVal *p;
57 | UpVal *uv;
58 | while (*pp != NULL && (p = ngcotouv(*pp))->v >= level) {
59 | lua_assert(p->v != &p->u.value);
60 | if (p->v == level) { /* found a corresponding upvalue? */
61 | if (isdead(g, obj2gco(p))) /* is it dead? */
62 | changewhite(obj2gco(p)); /* ressurect it */
63 | return p;
64 | }
65 | pp = &p->next;
66 | }
67 | uv = luaM_new(L, UpVal); /* not found: create a new one */
68 | uv->tt = LUA_TUPVAL;
69 | uv->marked = luaC_white(g);
70 | uv->v = level; /* current value lives in the stack */
71 | uv->next = *pp; /* chain it in the proper position */
72 | *pp = obj2gco(uv);
73 | uv->u.l.prev = &g->uvhead; /* double link it in `uvhead' list */
74 | uv->u.l.next = g->uvhead.u.l.next;
75 | uv->u.l.next->u.l.prev = uv;
76 | g->uvhead.u.l.next = uv;
77 | lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
78 | return uv;
79 | }
80 |
81 |
82 | static void unlinkupval (UpVal *uv) {
83 | lua_assert(uv->u.l.next->u.l.prev == uv && uv->u.l.prev->u.l.next == uv);
84 | uv->u.l.next->u.l.prev = uv->u.l.prev; /* remove from `uvhead' list */
85 | uv->u.l.prev->u.l.next = uv->u.l.next;
86 | }
87 |
88 |
89 | void luaF_freeupval (lua_State *L, UpVal *uv) {
90 | if (uv->v != &uv->u.value) /* is it open? */
91 | unlinkupval(uv); /* remove from open list */
92 | luaM_free(L, uv); /* free upvalue */
93 | }
94 |
95 |
96 | void luaF_close (lua_State *L, StkId level) {
97 | UpVal *uv;
98 | global_State *g = G(L);
99 | while (L->openupval != NULL && (uv = ngcotouv(L->openupval))->v >= level) {
100 | GCObject *o = obj2gco(uv);
101 | lua_assert(!isblack(o) && uv->v != &uv->u.value);
102 | L->openupval = uv->next; /* remove from `open' list */
103 | if (isdead(g, o))
104 | luaF_freeupval(L, uv); /* free upvalue */
105 | else {
106 | unlinkupval(uv);
107 | setobj(L, &uv->u.value, uv->v);
108 | uv->v = &uv->u.value; /* now current value lives here */
109 | luaC_linkupval(L, uv); /* link upvalue into `gcroot' list */
110 | }
111 | }
112 | }
113 |
114 |
115 | Proto *luaF_newproto (lua_State *L) {
116 | Proto *f = luaM_new(L, Proto);
117 | luaC_link(L, obj2gco(f), LUA_TPROTO);
118 | f->k = NULL;
119 | f->sizek = 0;
120 | f->p = NULL;
121 | f->sizep = 0;
122 | f->code = NULL;
123 | f->sizecode = 0;
124 | f->sizelineinfo = 0;
125 | f->sizeupvalues = 0;
126 | f->nups = 0;
127 | f->upvalues = NULL;
128 | f->numparams = 0;
129 | f->is_vararg = 0;
130 | f->maxstacksize = 0;
131 | f->lineinfo = NULL;
132 | f->sizelocvars = 0;
133 | f->locvars = NULL;
134 | f->linedefined = 0;
135 | f->lastlinedefined = 0;
136 | f->source = NULL;
137 | return f;
138 | }
139 |
140 |
141 | void luaF_freeproto (lua_State *L, Proto *f) {
142 | luaM_freearray(L, f->code, f->sizecode, Instruction);
143 | luaM_freearray(L, f->p, f->sizep, Proto *);
144 | luaM_freearray(L, f->k, f->sizek, TValue);
145 | luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
146 | luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
147 | luaM_freearray(L, f->upvalues, f->sizeupvalues, TString *);
148 | luaM_free(L, f);
149 | }
150 |
151 |
152 | void luaF_freeclosure (lua_State *L, Closure *c) {
153 | int size = (c->c.isC) ? sizeCclosure(c->c.nupvalues) :
154 | sizeLclosure(c->l.nupvalues);
155 | luaM_freemem(L, c, size);
156 | }
157 |
158 |
159 | /*
160 | ** Look for n-th local variable at line `line' in function `func'.
161 | ** Returns NULL if not found.
162 | */
163 | const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
164 | int i;
165 | for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) {
166 | if (pc < f->locvars[i].endpc) { /* is variable active? */
167 | local_number--;
168 | if (local_number == 0)
169 | return getstr(f->locvars[i].varname);
170 | }
171 | }
172 | return NULL; /* not found */
173 | }
174 |
175 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lundump.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lundump.c,v 2.7.1.4 2008/04/04 19:51:41 roberto Exp $
3 | ** load precompiled Lua chunks
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #include
8 |
9 | #define lundump_c
10 | #define LUA_CORE
11 |
12 | #include "lua.h"
13 |
14 | #include "ldebug.h"
15 | #include "ldo.h"
16 | #include "lfunc.h"
17 | #include "lmem.h"
18 | #include "lobject.h"
19 | #include "lstring.h"
20 | #include "lundump.h"
21 | #include "lzio.h"
22 |
23 | typedef struct {
24 | lua_State* L;
25 | ZIO* Z;
26 | Mbuffer* b;
27 | const char* name;
28 | } LoadState;
29 |
30 | #ifdef LUAC_TRUST_BINARIES
31 | #define IF(c,s)
32 | #define error(S,s)
33 | #else
34 | #define IF(c,s) if (c) error(S,s)
35 |
36 | static void error(LoadState* S, const char* why)
37 | {
38 | luaO_pushfstring(S->L,"%s: %s in precompiled chunk",S->name,why);
39 | luaD_throw(S->L,LUA_ERRSYNTAX);
40 | }
41 | #endif
42 |
43 | #define LoadMem(S,b,n,size) LoadBlock(S,b,(n)*(size))
44 | #define LoadByte(S) (lu_byte)LoadChar(S)
45 | #define LoadVar(S,x) LoadMem(S,&x,1,sizeof(x))
46 | #define LoadVector(S,b,n,size) LoadMem(S,b,n,size)
47 |
48 | static void LoadBlock(LoadState* S, void* b, size_t size)
49 | {
50 | size_t r=luaZ_read(S->Z,b,size);
51 | IF (r!=0, "unexpected end");
52 | }
53 |
54 | static int LoadChar(LoadState* S)
55 | {
56 | char x;
57 | LoadVar(S,x);
58 | return x;
59 | }
60 |
61 | static int LoadInt(LoadState* S)
62 | {
63 | int x;
64 | LoadVar(S,x);
65 | IF (x<0, "bad integer");
66 | return x;
67 | }
68 |
69 | static lua_Number LoadNumber(LoadState* S)
70 | {
71 | lua_Number x;
72 | LoadVar(S,x);
73 | return x;
74 | }
75 |
76 | static TString* LoadString(LoadState* S)
77 | {
78 | size_t size;
79 | LoadVar(S,size);
80 | if (size==0)
81 | return NULL;
82 | else
83 | {
84 | char* s=luaZ_openspace(S->L,S->b,size);
85 | LoadBlock(S,s,size);
86 | return luaS_newlstr(S->L,s,size-1); /* remove trailing '\0' */
87 | }
88 | }
89 |
90 | static void LoadCode(LoadState* S, Proto* f)
91 | {
92 | int n=LoadInt(S);
93 | f->code=luaM_newvector(S->L,n,Instruction);
94 | f->sizecode=n;
95 | LoadVector(S,f->code,n,sizeof(Instruction));
96 | }
97 |
98 | static Proto* LoadFunction(LoadState* S, TString* p);
99 |
100 | static void LoadConstants(LoadState* S, Proto* f)
101 | {
102 | int i,n;
103 | n=LoadInt(S);
104 | f->k=luaM_newvector(S->L,n,TValue);
105 | f->sizek=n;
106 | for (i=0; ik[i]);
107 | for (i=0; ik[i];
110 | int t=LoadChar(S);
111 | switch (t)
112 | {
113 | case LUA_TNIL:
114 | setnilvalue(o);
115 | break;
116 | case LUA_TBOOLEAN:
117 | setbvalue(o,LoadChar(S)!=0);
118 | break;
119 | case LUA_TNUMBER:
120 | setnvalue(o,LoadNumber(S));
121 | break;
122 | case LUA_TSTRING:
123 | setsvalue2n(S->L,o,LoadString(S));
124 | break;
125 | default:
126 | error(S,"bad constant");
127 | break;
128 | }
129 | }
130 | n=LoadInt(S);
131 | f->p=luaM_newvector(S->L,n,Proto*);
132 | f->sizep=n;
133 | for (i=0; ip[i]=NULL;
134 | for (i=0; ip[i]=LoadFunction(S,f->source);
135 | }
136 |
137 | static void LoadDebug(LoadState* S, Proto* f)
138 | {
139 | int i,n;
140 | n=LoadInt(S);
141 | f->lineinfo=luaM_newvector(S->L,n,int);
142 | f->sizelineinfo=n;
143 | LoadVector(S,f->lineinfo,n,sizeof(int));
144 | n=LoadInt(S);
145 | f->locvars=luaM_newvector(S->L,n,LocVar);
146 | f->sizelocvars=n;
147 | for (i=0; ilocvars[i].varname=NULL;
148 | for (i=0; ilocvars[i].varname=LoadString(S);
151 | f->locvars[i].startpc=LoadInt(S);
152 | f->locvars[i].endpc=LoadInt(S);
153 | }
154 | n=LoadInt(S);
155 | f->upvalues=luaM_newvector(S->L,n,TString*);
156 | f->sizeupvalues=n;
157 | for (i=0; iupvalues[i]=NULL;
158 | for (i=0; iupvalues[i]=LoadString(S);
159 | }
160 |
161 | static Proto* LoadFunction(LoadState* S, TString* p)
162 | {
163 | Proto* f;
164 | if (++S->L->nCcalls > LUAI_MAXCCALLS) error(S,"code too deep");
165 | f=luaF_newproto(S->L);
166 | setptvalue2s(S->L,S->L->top,f); incr_top(S->L);
167 | f->source=LoadString(S); if (f->source==NULL) f->source=p;
168 | f->linedefined=LoadInt(S);
169 | f->lastlinedefined=LoadInt(S);
170 | f->nups=LoadByte(S);
171 | f->numparams=LoadByte(S);
172 | f->is_vararg=LoadByte(S);
173 | f->maxstacksize=LoadByte(S);
174 | LoadCode(S,f);
175 | LoadConstants(S,f);
176 | LoadDebug(S,f);
177 | IF (!luaG_checkcode(f), "bad code");
178 | S->L->top--;
179 | S->L->nCcalls--;
180 | return f;
181 | }
182 |
183 | static void LoadHeader(LoadState* S)
184 | {
185 | char h[LUAC_HEADERSIZE];
186 | char s[LUAC_HEADERSIZE];
187 | luaU_header(h);
188 | LoadBlock(S,s,LUAC_HEADERSIZE);
189 | IF (memcmp(h,s,LUAC_HEADERSIZE)!=0, "bad header");
190 | }
191 |
192 | /*
193 | ** load precompiled chunk
194 | */
195 | Proto* luaU_undump (lua_State* L, ZIO* Z, Mbuffer* buff, const char* name)
196 | {
197 | LoadState S;
198 | if (*name=='@' || *name=='=')
199 | S.name=name+1;
200 | else if (*name==LUA_SIGNATURE[0])
201 | S.name="binary string";
202 | else
203 | S.name=name;
204 | S.L=L;
205 | S.Z=Z;
206 | S.b=buff;
207 | LoadHeader(&S);
208 | return LoadFunction(&S,luaS_newliteral(L,"=?"));
209 | }
210 |
211 | /*
212 | * make header
213 | */
214 | void luaU_header (char* h)
215 | {
216 | int x=1;
217 | memcpy(h,LUA_SIGNATURE,sizeof(LUA_SIGNATURE)-1);
218 | h+=sizeof(LUA_SIGNATURE)-1;
219 | *h++=(char)LUAC_VERSION;
220 | *h++=(char)LUAC_FORMAT;
221 | *h++=(char)*(char*)&x; /* endianness */
222 | *h++=(char)sizeof(int);
223 | *h++=(char)sizeof(size_t);
224 | *h++=(char)sizeof(Instruction);
225 | *h++=(char)sizeof(lua_Number);
226 | *h++=(char)(((lua_Number)0.5)==0); /* is lua_Number integral? */
227 | }
228 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lstate.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lstate.h,v 2.24.1.2 2008/01/03 15:20:39 roberto Exp $
3 | ** Global State
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #ifndef lstate_h
8 | #define lstate_h
9 |
10 | #include "lua.h"
11 |
12 | #include "lobject.h"
13 | #include "ltm.h"
14 | #include "lzio.h"
15 |
16 |
17 |
18 | struct lua_longjmp; /* defined in ldo.c */
19 |
20 |
21 | /* table of globals */
22 | #define gt(L) (&L->l_gt)
23 |
24 | /* registry */
25 | #define registry(L) (&G(L)->l_registry)
26 |
27 |
28 | /* extra stack space to handle TM calls and some other extras */
29 | #define EXTRA_STACK 5
30 |
31 |
32 | #define BASIC_CI_SIZE 8
33 |
34 | #define BASIC_STACK_SIZE (2*LUA_MINSTACK)
35 |
36 |
37 |
38 | typedef struct stringtable {
39 | GCObject **hash;
40 | lu_int32 nuse; /* number of elements */
41 | int size;
42 | } stringtable;
43 |
44 |
45 | /*
46 | ** informations about a call
47 | */
48 | typedef struct CallInfo {
49 | StkId base; /* base for this function */
50 | StkId func; /* function index in the stack */
51 | StkId top; /* top for this function */
52 | const Instruction *savedpc;
53 | int nresults; /* expected number of results from this function */
54 | int tailcalls; /* number of tail calls lost under this entry */
55 | } CallInfo;
56 |
57 |
58 |
59 | #define curr_func(L) (clvalue(L->ci->func))
60 | #define ci_func(ci) (clvalue((ci)->func))
61 | #define f_isLua(ci) (!ci_func(ci)->c.isC)
62 | #define isLua(ci) (ttisfunction((ci)->func) && f_isLua(ci))
63 |
64 |
65 | /*
66 | ** `global state', shared by all threads of this state
67 | */
68 | typedef struct global_State {
69 | stringtable strt; /* hash table for strings */
70 | lua_Alloc frealloc; /* function to reallocate memory */
71 | void *ud; /* auxiliary data to `frealloc' */
72 | lu_byte currentwhite;
73 | lu_byte gcstate; /* state of garbage collector */
74 | int sweepstrgc; /* position of sweep in `strt' */
75 | GCObject *rootgc; /* list of all collectable objects */
76 | GCObject **sweepgc; /* position of sweep in `rootgc' */
77 | GCObject *gray; /* list of gray objects */
78 | GCObject *grayagain; /* list of objects to be traversed atomically */
79 | GCObject *weak; /* list of weak tables (to be cleared) */
80 | GCObject *tmudata; /* last element of list of userdata to be GC */
81 | Mbuffer buff; /* temporary buffer for string concatentation */
82 | lu_mem GCthreshold;
83 | lu_mem totalbytes; /* number of bytes currently allocated */
84 | lu_mem estimate; /* an estimate of number of bytes actually in use */
85 | lu_mem gcdept; /* how much GC is `behind schedule' */
86 | int gcpause; /* size of pause between successive GCs */
87 | int gcstepmul; /* GC `granularity' */
88 | lua_CFunction panic; /* to be called in unprotected errors */
89 | TValue l_registry;
90 | struct lua_State *mainthread;
91 | UpVal uvhead; /* head of double-linked list of all open upvalues */
92 | struct Table *mt[NUM_TAGS]; /* metatables for basic types */
93 | TString *tmname[TM_N]; /* array with tag-method names */
94 | } global_State;
95 |
96 |
97 | /*
98 | ** `per thread' state
99 | */
100 | struct lua_State {
101 | CommonHeader;
102 | lu_byte status;
103 | StkId top; /* first free slot in the stack */
104 | StkId base; /* base of current function */
105 | global_State *l_G;
106 | CallInfo *ci; /* call info for current function */
107 | const Instruction *savedpc; /* `savedpc' of current function */
108 | StkId stack_last; /* last free slot in the stack */
109 | StkId stack; /* stack base */
110 | CallInfo *end_ci; /* points after end of ci array*/
111 | CallInfo *base_ci; /* array of CallInfo's */
112 | int stacksize;
113 | int size_ci; /* size of array `base_ci' */
114 | unsigned short nCcalls; /* number of nested C calls */
115 | unsigned short baseCcalls; /* nested C calls when resuming coroutine */
116 | lu_byte hookmask;
117 | lu_byte allowhook;
118 | int basehookcount;
119 | int hookcount;
120 | lua_Hook hook;
121 | TValue l_gt; /* table of globals */
122 | TValue env; /* temporary place for environments */
123 | GCObject *openupval; /* list of open upvalues in this stack */
124 | GCObject *gclist;
125 | struct lua_longjmp *errorJmp; /* current error recover point */
126 | ptrdiff_t errfunc; /* current error handling function (stack index) */
127 | };
128 |
129 |
130 | #define G(L) (L->l_G)
131 |
132 |
133 | /*
134 | ** Union of all collectable objects
135 | */
136 | union GCObject {
137 | GCheader gch;
138 | union TString ts;
139 | union Udata u;
140 | union Closure cl;
141 | struct Table h;
142 | struct Proto p;
143 | struct UpVal uv;
144 | struct lua_State th; /* thread */
145 | };
146 |
147 |
148 | /* macros to convert a GCObject into a specific value */
149 | #define rawgco2ts(o) check_exp((o)->gch.tt == LUA_TSTRING, &((o)->ts))
150 | #define gco2ts(o) (&rawgco2ts(o)->tsv)
151 | #define rawgco2u(o) check_exp((o)->gch.tt == LUA_TUSERDATA, &((o)->u))
152 | #define gco2u(o) (&rawgco2u(o)->uv)
153 | #define gco2cl(o) check_exp((o)->gch.tt == LUA_TFUNCTION, &((o)->cl))
154 | #define gco2h(o) check_exp((o)->gch.tt == LUA_TTABLE, &((o)->h))
155 | #define gco2p(o) check_exp((o)->gch.tt == LUA_TPROTO, &((o)->p))
156 | #define gco2uv(o) check_exp((o)->gch.tt == LUA_TUPVAL, &((o)->uv))
157 | #define ngcotouv(o) \
158 | check_exp((o) == NULL || (o)->gch.tt == LUA_TUPVAL, &((o)->uv))
159 | #define gco2th(o) check_exp((o)->gch.tt == LUA_TTHREAD, &((o)->th))
160 |
161 | /* macro to convert any Lua object into a GCObject */
162 | #define obj2gco(v) (cast(GCObject *, (v)))
163 |
164 |
165 | LUAI_FUNC lua_State *luaE_newthread (lua_State *L);
166 | LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
167 |
168 | #endif
169 |
170 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lobject.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lobject.c,v 2.22.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Some generic functions over Lua objects
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 | #include
8 | #include
9 | #include
10 | #include
11 | #include
12 |
13 | #define lobject_c
14 | #define LUA_CORE
15 |
16 | #include "lua.h"
17 |
18 | #include "ldo.h"
19 | #include "lmem.h"
20 | #include "lobject.h"
21 | #include "lstate.h"
22 | #include "lstring.h"
23 | #include "lvm.h"
24 |
25 |
26 |
27 | const TValue luaO_nilobject_ = {{NULL}, LUA_TNIL};
28 |
29 |
30 | /*
31 | ** converts an integer to a "floating point byte", represented as
32 | ** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
33 | ** eeeee != 0 and (xxx) otherwise.
34 | */
35 | int luaO_int2fb (unsigned int x) {
36 | int e = 0; /* expoent */
37 | while (x >= 16) {
38 | x = (x+1) >> 1;
39 | e++;
40 | }
41 | if (x < 8) return x;
42 | else return ((e+1) << 3) | (cast_int(x) - 8);
43 | }
44 |
45 |
46 | /* converts back */
47 | int luaO_fb2int (int x) {
48 | int e = (x >> 3) & 31;
49 | if (e == 0) return x;
50 | else return ((x & 7)+8) << (e - 1);
51 | }
52 |
53 |
54 | int luaO_log2 (unsigned int x) {
55 | static const lu_byte log_2[256] = {
56 | 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
57 | 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
58 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
59 | 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
60 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
61 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
62 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
63 | 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
64 | };
65 | int l = -1;
66 | while (x >= 256) { l += 8; x >>= 8; }
67 | return l + log_2[x];
68 |
69 | }
70 |
71 |
72 | int luaO_rawequalObj (const TValue *t1, const TValue *t2) {
73 | if (ttype(t1) != ttype(t2)) return 0;
74 | else switch (ttype(t1)) {
75 | case LUA_TNIL:
76 | return 1;
77 | case LUA_TNUMBER:
78 | return luai_numeq(nvalue(t1), nvalue(t2));
79 | case LUA_TBOOLEAN:
80 | return bvalue(t1) == bvalue(t2); /* boolean true must be 1 !! */
81 | case LUA_TLIGHTUSERDATA:
82 | return pvalue(t1) == pvalue(t2);
83 | default:
84 | lua_assert(iscollectable(t1));
85 | return gcvalue(t1) == gcvalue(t2);
86 | }
87 | }
88 |
89 |
90 | int luaO_str2d (const char *s, lua_Number *result) {
91 | char *endptr;
92 | *result = lua_str2number(s, &endptr);
93 | if (endptr == s) return 0; /* conversion failed */
94 | if (*endptr == 'x' || *endptr == 'X') /* maybe an hexadecimal constant? */
95 | *result = cast_num(strtoul(s, &endptr, 16));
96 | if (*endptr == '\0') return 1; /* most common case */
97 | while (isspace(cast(unsigned char, *endptr))) endptr++;
98 | if (*endptr != '\0') return 0; /* invalid trailing characters? */
99 | return 1;
100 | }
101 |
102 |
103 |
104 | static void pushstr (lua_State *L, const char *str) {
105 | setsvalue2s(L, L->top, luaS_new(L, str));
106 | incr_top(L);
107 | }
108 |
109 |
110 | /* this function handles only `%d', `%c', %f, %p, and `%s' formats */
111 | const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
112 | int n = 1;
113 | pushstr(L, "");
114 | for (;;) {
115 | const char *e = strchr(fmt, '%');
116 | if (e == NULL) break;
117 | setsvalue2s(L, L->top, luaS_newlstr(L, fmt, e-fmt));
118 | incr_top(L);
119 | switch (*(e+1)) {
120 | case 's': {
121 | const char *s = va_arg(argp, char *);
122 | if (s == NULL) s = "(null)";
123 | pushstr(L, s);
124 | break;
125 | }
126 | case 'c': {
127 | char buff[2];
128 | buff[0] = cast(char, va_arg(argp, int));
129 | buff[1] = '\0';
130 | pushstr(L, buff);
131 | break;
132 | }
133 | case 'd': {
134 | setnvalue(L->top, cast_num(va_arg(argp, int)));
135 | incr_top(L);
136 | break;
137 | }
138 | case 'f': {
139 | setnvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
140 | incr_top(L);
141 | break;
142 | }
143 | case 'p': {
144 | char buff[4*sizeof(void *) + 8]; /* should be enough space for a `%p' */
145 | sprintf(buff, "%p", va_arg(argp, void *));
146 | pushstr(L, buff);
147 | break;
148 | }
149 | case '%': {
150 | pushstr(L, "%");
151 | break;
152 | }
153 | default: {
154 | char buff[3];
155 | buff[0] = '%';
156 | buff[1] = *(e+1);
157 | buff[2] = '\0';
158 | pushstr(L, buff);
159 | break;
160 | }
161 | }
162 | n += 2;
163 | fmt = e+2;
164 | }
165 | pushstr(L, fmt);
166 | luaV_concat(L, n+1, cast_int(L->top - L->base) - 1);
167 | L->top -= n;
168 | return svalue(L->top - 1);
169 | }
170 |
171 |
172 | const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) {
173 | const char *msg;
174 | va_list argp;
175 | va_start(argp, fmt);
176 | msg = luaO_pushvfstring(L, fmt, argp);
177 | va_end(argp);
178 | return msg;
179 | }
180 |
181 |
182 | void luaO_chunkid (char *out, const char *source, size_t bufflen) {
183 | if (*source == '=') {
184 | strncpy(out, source+1, bufflen); /* remove first char */
185 | out[bufflen-1] = '\0'; /* ensures null termination */
186 | }
187 | else { /* out = "source", or "...source" */
188 | if (*source == '@') {
189 | size_t l;
190 | source++; /* skip the `@' */
191 | bufflen -= sizeof(" '...' ");
192 | l = strlen(source);
193 | strcpy(out, "");
194 | if (l > bufflen) {
195 | source += (l-bufflen); /* get last part of file name */
196 | strcat(out, "...");
197 | }
198 | strcat(out, source);
199 | }
200 | else { /* out = [string "string"] */
201 | size_t len = strcspn(source, "\n\r"); /* stop at first newline */
202 | bufflen -= sizeof(" [string \"...\"] ");
203 | if (len > bufflen) len = bufflen;
204 | strcpy(out, "[string \"");
205 | if (source[len] != '\0') { /* must truncate? */
206 | strncat(out, source, len);
207 | strcat(out, "...");
208 | }
209 | else
210 | strcat(out, source);
211 | strcat(out, "\"]");
212 | }
213 | }
214 | }
215 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lauxlib.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Auxiliary functions for building Lua libraries
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #ifndef lauxlib_h
9 | #define lauxlib_h
10 |
11 |
12 | #include
13 | #include
14 |
15 | #include "lua.h"
16 |
17 |
18 | #if defined(LUA_COMPAT_GETN)
19 | LUALIB_API int (luaL_getn) (lua_State *L, int t);
20 | LUALIB_API void (luaL_setn) (lua_State *L, int t, int n);
21 | #else
22 | #define luaL_getn(L,i) ((int)lua_objlen(L, i))
23 | #define luaL_setn(L,i,j) ((void)0) /* no op! */
24 | #endif
25 |
26 | #if defined(LUA_COMPAT_OPENLIB)
27 | #define luaI_openlib luaL_openlib
28 | #endif
29 |
30 |
31 | /* extra error code for `luaL_load' */
32 | #define LUA_ERRFILE (LUA_ERRERR+1)
33 |
34 |
35 | typedef struct luaL_Reg {
36 | const char *name;
37 | lua_CFunction func;
38 | } luaL_Reg;
39 |
40 |
41 |
42 | LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname,
43 | const luaL_Reg *l, int nup);
44 | LUALIB_API void (luaL_register) (lua_State *L, const char *libname,
45 | const luaL_Reg *l);
46 | LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
47 | LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
48 | LUALIB_API int (luaL_typerror) (lua_State *L, int narg, const char *tname);
49 | LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
50 | LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
51 | size_t *l);
52 | LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
53 | const char *def, size_t *l);
54 | LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
55 | LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
56 |
57 | LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
58 | LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
59 | lua_Integer def);
60 |
61 | LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
62 | LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
63 | LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
64 |
65 | LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
66 | LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
67 |
68 | LUALIB_API void (luaL_where) (lua_State *L, int lvl);
69 | LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
70 |
71 | LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
72 | const char *const lst[]);
73 |
74 | LUALIB_API int (luaL_ref) (lua_State *L, int t);
75 | LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
76 |
77 | LUALIB_API int (luaL_loadfile) (lua_State *L, const char *filename);
78 | LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz,
79 | const char *name);
80 | LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
81 |
82 | LUALIB_API lua_State *(luaL_newstate) (void);
83 |
84 |
85 | LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
86 | const char *r);
87 |
88 | LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
89 | const char *fname, int szhint);
90 |
91 |
92 |
93 |
94 | /*
95 | ** ===============================================================
96 | ** some useful macros
97 | ** ===============================================================
98 | */
99 |
100 | #define luaL_argcheck(L, cond,numarg,extramsg) \
101 | ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
102 | #define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
103 | #define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
104 | #define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
105 | #define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
106 | #define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
107 | #define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
108 |
109 | #define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
110 |
111 | #define luaL_dofile(L, fn) \
112 | (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
113 |
114 | #define luaL_dostring(L, s) \
115 | (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
116 |
117 | #define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
118 |
119 | #define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
120 |
121 | /*
122 | ** {======================================================
123 | ** Generic Buffer manipulation
124 | ** =======================================================
125 | */
126 |
127 |
128 |
129 | typedef struct luaL_Buffer {
130 | char *p; /* current position in buffer */
131 | int lvl; /* number of strings in the stack (level) */
132 | lua_State *L;
133 | char buffer[LUAL_BUFFERSIZE];
134 | } luaL_Buffer;
135 |
136 | #define luaL_addchar(B,c) \
137 | ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
138 | (*(B)->p++ = (char)(c)))
139 |
140 | /* compatibility only */
141 | #define luaL_putchar(B,c) luaL_addchar(B,c)
142 |
143 | #define luaL_addsize(B,n) ((B)->p += (n))
144 |
145 | LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
146 | LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B);
147 | LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
148 | LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
149 | LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
150 | LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
151 |
152 |
153 | /* }====================================================== */
154 |
155 |
156 | /* compatibility with ref system */
157 |
158 | /* pre-defined references */
159 | #define LUA_NOREF (-2)
160 | #define LUA_REFNIL (-1)
161 |
162 | #define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \
163 | (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0))
164 |
165 | #define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref))
166 |
167 | #define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref))
168 |
169 |
170 | #define luaL_reg luaL_Reg
171 |
172 | #endif
173 |
174 |
175 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lstate.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lstate.c,v 2.36.1.2 2008/01/03 15:20:39 roberto Exp $
3 | ** Global State
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 |
10 | #define lstate_c
11 | #define LUA_CORE
12 |
13 | #include "lua.h"
14 |
15 | #include "ldebug.h"
16 | #include "ldo.h"
17 | #include "lfunc.h"
18 | #include "lgc.h"
19 | #include "llex.h"
20 | #include "lmem.h"
21 | #include "lstate.h"
22 | #include "lstring.h"
23 | #include "ltable.h"
24 | #include "ltm.h"
25 |
26 |
27 | #define state_size(x) (sizeof(x) + LUAI_EXTRASPACE)
28 | #define fromstate(l) (cast(lu_byte *, (l)) - LUAI_EXTRASPACE)
29 | #define tostate(l) (cast(lua_State *, cast(lu_byte *, l) + LUAI_EXTRASPACE))
30 |
31 |
32 | /*
33 | ** Main thread combines a thread state and the global state
34 | */
35 | typedef struct LG {
36 | lua_State l;
37 | global_State g;
38 | } LG;
39 |
40 |
41 |
42 | static void stack_init (lua_State *L1, lua_State *L) {
43 | /* initialize CallInfo array */
44 | L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
45 | L1->ci = L1->base_ci;
46 | L1->size_ci = BASIC_CI_SIZE;
47 | L1->end_ci = L1->base_ci + L1->size_ci - 1;
48 | /* initialize stack array */
49 | L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
50 | L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
51 | L1->top = L1->stack;
52 | L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
53 | /* initialize first ci */
54 | L1->ci->func = L1->top;
55 | setnilvalue(L1->top++); /* `function' entry for this `ci' */
56 | L1->base = L1->ci->base = L1->top;
57 | L1->ci->top = L1->top + LUA_MINSTACK;
58 | }
59 |
60 |
61 | static void freestack (lua_State *L, lua_State *L1) {
62 | luaM_freearray(L, L1->base_ci, L1->size_ci, CallInfo);
63 | luaM_freearray(L, L1->stack, L1->stacksize, TValue);
64 | }
65 |
66 |
67 | /*
68 | ** open parts that may cause memory-allocation errors
69 | */
70 | static void f_luaopen (lua_State *L, void *ud) {
71 | global_State *g = G(L);
72 | UNUSED(ud);
73 | stack_init(L, L); /* init stack */
74 | sethvalue(L, gt(L), luaH_new(L, 0, 2)); /* table of globals */
75 | sethvalue(L, registry(L), luaH_new(L, 0, 2)); /* registry */
76 | luaS_resize(L, MINSTRTABSIZE); /* initial size of string table */
77 | luaT_init(L);
78 | luaX_init(L);
79 | luaS_fix(luaS_newliteral(L, MEMERRMSG));
80 | g->GCthreshold = 4*g->totalbytes;
81 | }
82 |
83 |
84 | static void preinit_state (lua_State *L, global_State *g) {
85 | G(L) = g;
86 | L->stack = NULL;
87 | L->stacksize = 0;
88 | L->errorJmp = NULL;
89 | L->hook = NULL;
90 | L->hookmask = 0;
91 | L->basehookcount = 0;
92 | L->allowhook = 1;
93 | resethookcount(L);
94 | L->openupval = NULL;
95 | L->size_ci = 0;
96 | L->nCcalls = L->baseCcalls = 0;
97 | L->status = 0;
98 | L->base_ci = L->ci = NULL;
99 | L->savedpc = NULL;
100 | L->errfunc = 0;
101 | setnilvalue(gt(L));
102 | }
103 |
104 |
105 | static void close_state (lua_State *L) {
106 | global_State *g = G(L);
107 | luaF_close(L, L->stack); /* close all upvalues for this thread */
108 | luaC_freeall(L); /* collect all objects */
109 | lua_assert(g->rootgc == obj2gco(L));
110 | lua_assert(g->strt.nuse == 0);
111 | luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
112 | luaZ_freebuffer(L, &g->buff);
113 | freestack(L, L);
114 | lua_assert(g->totalbytes == sizeof(LG));
115 | (*g->frealloc)(g->ud, fromstate(L), state_size(LG), 0);
116 | }
117 |
118 |
119 | lua_State *luaE_newthread (lua_State *L) {
120 | lua_State *L1 = tostate(luaM_malloc(L, state_size(lua_State)));
121 | luaC_link(L, obj2gco(L1), LUA_TTHREAD);
122 | preinit_state(L1, G(L));
123 | stack_init(L1, L); /* init stack */
124 | setobj2n(L, gt(L1), gt(L)); /* share table of globals */
125 | L1->hookmask = L->hookmask;
126 | L1->basehookcount = L->basehookcount;
127 | L1->hook = L->hook;
128 | resethookcount(L1);
129 | lua_assert(iswhite(obj2gco(L1)));
130 | return L1;
131 | }
132 |
133 |
134 | void luaE_freethread (lua_State *L, lua_State *L1) {
135 | luaF_close(L1, L1->stack); /* close all upvalues for this thread */
136 | lua_assert(L1->openupval == NULL);
137 | luai_userstatefree(L1);
138 | freestack(L, L1);
139 | luaM_freemem(L, fromstate(L1), state_size(lua_State));
140 | }
141 |
142 |
143 | LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
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;
153 | g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
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; imt[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
188 | luai_userstateopen(L);
189 | return L;
190 | }
191 |
192 |
193 | static void callallgcTM (lua_State *L, void *ud) {
194 | UNUSED(ud);
195 | luaC_callGCTM(L); /* call GC metamethods for all udata */
196 | }
197 |
198 |
199 | LUA_API void lua_close (lua_State *L) {
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);
211 | luai_userstateclose(L);
212 | close_state(L);
213 | }
214 |
215 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lmathlib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lmathlib.c,v 1.67.1.1 2007/12/27 13:02:25 roberto Exp $
3 | ** Standard mathematical library
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 | #include
10 |
11 | #define lmathlib_c
12 | #define LUA_LIB
13 |
14 | #include "lua.h"
15 |
16 | #include "lauxlib.h"
17 | #include "lualib.h"
18 |
19 |
20 | #undef PI
21 | #define PI (3.14159265358979323846)
22 | #define RADIANS_PER_DEGREE (PI/180.0)
23 |
24 |
25 |
26 | static int math_abs (lua_State *L) {
27 | lua_pushnumber(L, fabs(luaL_checknumber(L, 1)));
28 | return 1;
29 | }
30 |
31 | static int math_sin (lua_State *L) {
32 | lua_pushnumber(L, sin(luaL_checknumber(L, 1)));
33 | return 1;
34 | }
35 |
36 | static int math_sinh (lua_State *L) {
37 | lua_pushnumber(L, sinh(luaL_checknumber(L, 1)));
38 | return 1;
39 | }
40 |
41 | static int math_cos (lua_State *L) {
42 | lua_pushnumber(L, cos(luaL_checknumber(L, 1)));
43 | return 1;
44 | }
45 |
46 | static int math_cosh (lua_State *L) {
47 | lua_pushnumber(L, cosh(luaL_checknumber(L, 1)));
48 | return 1;
49 | }
50 |
51 | static int math_tan (lua_State *L) {
52 | lua_pushnumber(L, tan(luaL_checknumber(L, 1)));
53 | return 1;
54 | }
55 |
56 | static int math_tanh (lua_State *L) {
57 | lua_pushnumber(L, tanh(luaL_checknumber(L, 1)));
58 | return 1;
59 | }
60 |
61 | static int math_asin (lua_State *L) {
62 | lua_pushnumber(L, asin(luaL_checknumber(L, 1)));
63 | return 1;
64 | }
65 |
66 | static int math_acos (lua_State *L) {
67 | lua_pushnumber(L, acos(luaL_checknumber(L, 1)));
68 | return 1;
69 | }
70 |
71 | static int math_atan (lua_State *L) {
72 | lua_pushnumber(L, atan(luaL_checknumber(L, 1)));
73 | return 1;
74 | }
75 |
76 | static int math_atan2 (lua_State *L) {
77 | lua_pushnumber(L, atan2(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
78 | return 1;
79 | }
80 |
81 | static int math_ceil (lua_State *L) {
82 | lua_pushnumber(L, ceil(luaL_checknumber(L, 1)));
83 | return 1;
84 | }
85 |
86 | static int math_floor (lua_State *L) {
87 | lua_pushnumber(L, floor(luaL_checknumber(L, 1)));
88 | return 1;
89 | }
90 |
91 | static int math_fmod (lua_State *L) {
92 | lua_pushnumber(L, fmod(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
93 | return 1;
94 | }
95 |
96 | static int math_modf (lua_State *L) {
97 | double ip;
98 | double fp = modf(luaL_checknumber(L, 1), &ip);
99 | lua_pushnumber(L, ip);
100 | lua_pushnumber(L, fp);
101 | return 2;
102 | }
103 |
104 | static int math_sqrt (lua_State *L) {
105 | lua_pushnumber(L, sqrt(luaL_checknumber(L, 1)));
106 | return 1;
107 | }
108 |
109 | static int math_pow (lua_State *L) {
110 | lua_pushnumber(L, pow(luaL_checknumber(L, 1), luaL_checknumber(L, 2)));
111 | return 1;
112 | }
113 |
114 | static int math_log (lua_State *L) {
115 | lua_pushnumber(L, log(luaL_checknumber(L, 1)));
116 | return 1;
117 | }
118 |
119 | static int math_log10 (lua_State *L) {
120 | lua_pushnumber(L, log10(luaL_checknumber(L, 1)));
121 | return 1;
122 | }
123 |
124 | static int math_exp (lua_State *L) {
125 | lua_pushnumber(L, exp(luaL_checknumber(L, 1)));
126 | return 1;
127 | }
128 |
129 | static int math_deg (lua_State *L) {
130 | lua_pushnumber(L, luaL_checknumber(L, 1)/RADIANS_PER_DEGREE);
131 | return 1;
132 | }
133 |
134 | static int math_rad (lua_State *L) {
135 | lua_pushnumber(L, luaL_checknumber(L, 1)*RADIANS_PER_DEGREE);
136 | return 1;
137 | }
138 |
139 | static int math_frexp (lua_State *L) {
140 | int e;
141 | lua_pushnumber(L, frexp(luaL_checknumber(L, 1), &e));
142 | lua_pushinteger(L, e);
143 | return 2;
144 | }
145 |
146 | static int math_ldexp (lua_State *L) {
147 | lua_pushnumber(L, ldexp(luaL_checknumber(L, 1), luaL_checkint(L, 2)));
148 | return 1;
149 | }
150 |
151 |
152 |
153 | static int math_min (lua_State *L) {
154 | int n = lua_gettop(L); /* number of arguments */
155 | lua_Number dmin = luaL_checknumber(L, 1);
156 | int i;
157 | for (i=2; i<=n; i++) {
158 | lua_Number d = luaL_checknumber(L, i);
159 | if (d < dmin)
160 | dmin = d;
161 | }
162 | lua_pushnumber(L, dmin);
163 | return 1;
164 | }
165 |
166 |
167 | static int math_max (lua_State *L) {
168 | int n = lua_gettop(L); /* number of arguments */
169 | lua_Number dmax = luaL_checknumber(L, 1);
170 | int i;
171 | for (i=2; i<=n; i++) {
172 | lua_Number d = luaL_checknumber(L, i);
173 | if (d > dmax)
174 | dmax = d;
175 | }
176 | lua_pushnumber(L, dmax);
177 | return 1;
178 | }
179 |
180 |
181 | static int math_random (lua_State *L) {
182 | /* the `%' avoids the (rare) case of r==1, and is needed also because on
183 | some systems (SunOS!) `rand()' may return a value larger than RAND_MAX */
184 | lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
185 | switch (lua_gettop(L)) { /* check number of arguments */
186 | case 0: { /* no arguments */
187 | lua_pushnumber(L, r); /* Number between 0 and 1 */
188 | break;
189 | }
190 | case 1: { /* only upper limit */
191 | int u = luaL_checkint(L, 1);
192 | luaL_argcheck(L, 1<=u, 1, "interval is empty");
193 | lua_pushnumber(L, floor(r*u)+1); /* int between 1 and `u' */
194 | break;
195 | }
196 | case 2: { /* lower and upper limits */
197 | int l = luaL_checkint(L, 1);
198 | int u = luaL_checkint(L, 2);
199 | luaL_argcheck(L, l<=u, 2, "interval is empty");
200 | lua_pushnumber(L, floor(r*(u-l+1))+l); /* int between `l' and `u' */
201 | break;
202 | }
203 | default: return luaL_error(L, "wrong number of arguments");
204 | }
205 | return 1;
206 | }
207 |
208 |
209 | static int math_randomseed (lua_State *L) {
210 | srand(luaL_checkint(L, 1));
211 | return 0;
212 | }
213 |
214 |
215 | static const luaL_Reg mathlib[] = {
216 | {"abs", math_abs},
217 | {"acos", math_acos},
218 | {"asin", math_asin},
219 | {"atan2", math_atan2},
220 | {"atan", math_atan},
221 | {"ceil", math_ceil},
222 | {"cosh", math_cosh},
223 | {"cos", math_cos},
224 | {"deg", math_deg},
225 | {"exp", math_exp},
226 | {"floor", math_floor},
227 | {"fmod", math_fmod},
228 | {"frexp", math_frexp},
229 | {"ldexp", math_ldexp},
230 | {"log10", math_log10},
231 | {"log", math_log},
232 | {"max", math_max},
233 | {"min", math_min},
234 | {"modf", math_modf},
235 | {"pow", math_pow},
236 | {"rad", math_rad},
237 | {"random", math_random},
238 | {"randomseed", math_randomseed},
239 | {"sinh", math_sinh},
240 | {"sin", math_sin},
241 | {"sqrt", math_sqrt},
242 | {"tanh", math_tanh},
243 | {"tan", math_tan},
244 | {NULL, NULL}
245 | };
246 |
247 |
248 | /*
249 | ** Open math library
250 | */
251 | LUALIB_API int luaopen_math (lua_State *L) {
252 | luaL_register(L, LUA_MATHLIBNAME, mathlib);
253 | lua_pushnumber(L, PI);
254 | lua_setfield(L, -2, "pi");
255 | lua_pushnumber(L, HUGE_VAL);
256 | lua_setfield(L, -2, "huge");
257 | #if defined(LUA_COMPAT_MOD)
258 | lua_getfield(L, -1, "fmod");
259 | lua_setfield(L, -2, "mod");
260 | #endif
261 | return 1;
262 | }
263 |
264 |
--------------------------------------------------------------------------------
/mLua/jni/lua/loslib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: loslib.c,v 1.19.1.3 2008/01/18 16:38:18 roberto Exp $
3 | ** Standard Operating System library
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 | #include
12 | #include
13 |
14 | #define loslib_c
15 | #define LUA_LIB
16 |
17 | #include "lua.h"
18 |
19 | #include "lauxlib.h"
20 | #include "lualib.h"
21 |
22 |
23 | static int os_pushresult (lua_State *L, int i, const char *filename) {
24 | int en = errno; /* calls to Lua API may change this value */
25 | if (i) {
26 | lua_pushboolean(L, 1);
27 | return 1;
28 | }
29 | else {
30 | lua_pushnil(L);
31 | lua_pushfstring(L, "%s: %s", filename, strerror(en));
32 | lua_pushinteger(L, en);
33 | return 3;
34 | }
35 | }
36 |
37 |
38 | static int os_execute (lua_State *L) {
39 | lua_pushinteger(L, system(luaL_optstring(L, 1, NULL)));
40 | return 1;
41 | }
42 |
43 |
44 | static int os_remove (lua_State *L) {
45 | const char *filename = luaL_checkstring(L, 1);
46 | return os_pushresult(L, remove(filename) == 0, filename);
47 | }
48 |
49 |
50 | static int os_rename (lua_State *L) {
51 | const char *fromname = luaL_checkstring(L, 1);
52 | const char *toname = luaL_checkstring(L, 2);
53 | return os_pushresult(L, rename(fromname, toname) == 0, fromname);
54 | }
55 |
56 |
57 | static int os_tmpname (lua_State *L) {
58 | char buff[LUA_TMPNAMBUFSIZE];
59 | int err;
60 | lua_tmpnam(buff, err);
61 | if (err)
62 | return luaL_error(L, "unable to generate a unique filename");
63 | lua_pushstring(L, buff);
64 | return 1;
65 | }
66 |
67 |
68 | static int os_getenv (lua_State *L) {
69 | lua_pushstring(L, getenv(luaL_checkstring(L, 1))); /* if NULL push nil */
70 | return 1;
71 | }
72 |
73 |
74 | static int os_clock (lua_State *L) {
75 | lua_pushnumber(L, ((lua_Number)clock())/(lua_Number)CLOCKS_PER_SEC);
76 | return 1;
77 | }
78 |
79 |
80 | /*
81 | ** {======================================================
82 | ** Time/Date operations
83 | ** { year=%Y, month=%m, day=%d, hour=%H, min=%M, sec=%S,
84 | ** wday=%w+1, yday=%j, isdst=? }
85 | ** =======================================================
86 | */
87 |
88 | static void setfield (lua_State *L, const char *key, int value) {
89 | lua_pushinteger(L, value);
90 | lua_setfield(L, -2, key);
91 | }
92 |
93 | static void setboolfield (lua_State *L, const char *key, int value) {
94 | if (value < 0) /* undefined? */
95 | return; /* does not set field */
96 | lua_pushboolean(L, value);
97 | lua_setfield(L, -2, key);
98 | }
99 |
100 | static int getboolfield (lua_State *L, const char *key) {
101 | int res;
102 | lua_getfield(L, -1, key);
103 | res = lua_isnil(L, -1) ? -1 : lua_toboolean(L, -1);
104 | lua_pop(L, 1);
105 | return res;
106 | }
107 |
108 |
109 | static int getfield (lua_State *L, const char *key, int d) {
110 | int res;
111 | lua_getfield(L, -1, key);
112 | if (lua_isnumber(L, -1))
113 | res = (int)lua_tointeger(L, -1);
114 | else {
115 | if (d < 0)
116 | return luaL_error(L, "field " LUA_QS " missing in date table", key);
117 | res = d;
118 | }
119 | lua_pop(L, 1);
120 | return res;
121 | }
122 |
123 |
124 | static int os_date (lua_State *L) {
125 | const char *s = luaL_optstring(L, 1, "%c");
126 | time_t t = luaL_opt(L, (time_t)luaL_checknumber, 2, time(NULL));
127 | struct tm *stm;
128 | if (*s == '!') { /* UTC? */
129 | stm = gmtime(&t);
130 | s++; /* skip `!' */
131 | }
132 | else
133 | stm = localtime(&t);
134 | if (stm == NULL) /* invalid date? */
135 | lua_pushnil(L);
136 | else if (strcmp(s, "*t") == 0) {
137 | lua_createtable(L, 0, 9); /* 9 = number of fields */
138 | setfield(L, "sec", stm->tm_sec);
139 | setfield(L, "min", stm->tm_min);
140 | setfield(L, "hour", stm->tm_hour);
141 | setfield(L, "day", stm->tm_mday);
142 | setfield(L, "month", stm->tm_mon+1);
143 | setfield(L, "year", stm->tm_year+1900);
144 | setfield(L, "wday", stm->tm_wday+1);
145 | setfield(L, "yday", stm->tm_yday+1);
146 | setboolfield(L, "isdst", stm->tm_isdst);
147 | }
148 | else {
149 | char cc[3];
150 | luaL_Buffer b;
151 | cc[0] = '%'; cc[2] = '\0';
152 | luaL_buffinit(L, &b);
153 | for (; *s; s++) {
154 | if (*s != '%' || *(s + 1) == '\0') /* no conversion specifier? */
155 | luaL_addchar(&b, *s);
156 | else {
157 | size_t reslen;
158 | char buff[200]; /* should be big enough for any conversion result */
159 | cc[1] = *(++s);
160 | reslen = strftime(buff, sizeof(buff), cc, stm);
161 | luaL_addlstring(&b, buff, reslen);
162 | }
163 | }
164 | luaL_pushresult(&b);
165 | }
166 | return 1;
167 | }
168 |
169 |
170 | static int os_time (lua_State *L) {
171 | time_t t;
172 | if (lua_isnoneornil(L, 1)) /* called without args? */
173 | t = time(NULL); /* get current time */
174 | else {
175 | struct tm ts;
176 | luaL_checktype(L, 1, LUA_TTABLE);
177 | lua_settop(L, 1); /* make sure table is at the top */
178 | ts.tm_sec = getfield(L, "sec", 0);
179 | ts.tm_min = getfield(L, "min", 0);
180 | ts.tm_hour = getfield(L, "hour", 12);
181 | ts.tm_mday = getfield(L, "day", -1);
182 | ts.tm_mon = getfield(L, "month", -1) - 1;
183 | ts.tm_year = getfield(L, "year", -1) - 1900;
184 | ts.tm_isdst = getboolfield(L, "isdst");
185 | t = mktime(&ts);
186 | }
187 | if (t == (time_t)(-1))
188 | lua_pushnil(L);
189 | else
190 | lua_pushnumber(L, (lua_Number)t);
191 | return 1;
192 | }
193 |
194 |
195 | static int os_difftime (lua_State *L) {
196 | lua_pushnumber(L, difftime((time_t)(luaL_checknumber(L, 1)),
197 | (time_t)(luaL_optnumber(L, 2, 0))));
198 | return 1;
199 | }
200 |
201 | /* }====================================================== */
202 |
203 |
204 | static int os_setlocale (lua_State *L) {
205 | static const int cat[] = {LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY,
206 | LC_NUMERIC, LC_TIME};
207 | static const char *const catnames[] = {"all", "collate", "ctype", "monetary",
208 | "numeric", "time", NULL};
209 | const char *l = luaL_optstring(L, 1, NULL);
210 | int op = luaL_checkoption(L, 2, "all", catnames);
211 | lua_pushstring(L, setlocale(cat[op], l));
212 | return 1;
213 | }
214 |
215 |
216 | static int os_exit (lua_State *L) {
217 | exit(luaL_optint(L, 1, EXIT_SUCCESS));
218 | }
219 |
220 | static const luaL_Reg syslib[] = {
221 | {"clock", os_clock},
222 | {"date", os_date},
223 | {"difftime", os_difftime},
224 | {"execute", os_execute},
225 | {"exit", os_exit},
226 | {"getenv", os_getenv},
227 | {"remove", os_remove},
228 | {"rename", os_rename},
229 | {"setlocale", os_setlocale},
230 | {"time", os_time},
231 | {"tmpname", os_tmpname},
232 | {NULL, NULL}
233 | };
234 |
235 | /* }====================================================== */
236 |
237 |
238 |
239 | LUALIB_API int luaopen_os (lua_State *L) {
240 | luaL_register(L, LUA_OSLIBNAME, syslib);
241 | return 1;
242 | }
243 |
244 |
--------------------------------------------------------------------------------
/mLua/jni/lua/ltablib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ltablib.c,v 1.38.1.3 2008/02/14 16:46:58 roberto Exp $
3 | ** Library for Table Manipulation
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 |
10 | #define ltablib_c
11 | #define LUA_LIB
12 |
13 | #include "lua.h"
14 |
15 | #include "lauxlib.h"
16 | #include "lualib.h"
17 |
18 |
19 | #define aux_getn(L,n) (luaL_checktype(L, n, LUA_TTABLE), luaL_getn(L, n))
20 |
21 |
22 | static int foreachi (lua_State *L) {
23 | int i;
24 | int n = aux_getn(L, 1);
25 | luaL_checktype(L, 2, LUA_TFUNCTION);
26 | for (i=1; i <= n; i++) {
27 | lua_pushvalue(L, 2); /* function */
28 | lua_pushinteger(L, i); /* 1st argument */
29 | lua_rawgeti(L, 1, i); /* 2nd argument */
30 | lua_call(L, 2, 1);
31 | if (!lua_isnil(L, -1))
32 | return 1;
33 | lua_pop(L, 1); /* remove nil result */
34 | }
35 | return 0;
36 | }
37 |
38 |
39 | static int foreach (lua_State *L) {
40 | luaL_checktype(L, 1, LUA_TTABLE);
41 | luaL_checktype(L, 2, LUA_TFUNCTION);
42 | lua_pushnil(L); /* first key */
43 | while (lua_next(L, 1)) {
44 | lua_pushvalue(L, 2); /* function */
45 | lua_pushvalue(L, -3); /* key */
46 | lua_pushvalue(L, -3); /* value */
47 | lua_call(L, 2, 1);
48 | if (!lua_isnil(L, -1))
49 | return 1;
50 | lua_pop(L, 2); /* remove value and result */
51 | }
52 | return 0;
53 | }
54 |
55 |
56 | static int maxn (lua_State *L) {
57 | lua_Number max = 0;
58 | luaL_checktype(L, 1, LUA_TTABLE);
59 | lua_pushnil(L); /* first key */
60 | while (lua_next(L, 1)) {
61 | lua_pop(L, 1); /* remove value */
62 | if (lua_type(L, -1) == LUA_TNUMBER) {
63 | lua_Number v = lua_tonumber(L, -1);
64 | if (v > max) max = v;
65 | }
66 | }
67 | lua_pushnumber(L, max);
68 | return 1;
69 | }
70 |
71 |
72 | static int getn (lua_State *L) {
73 | lua_pushinteger(L, aux_getn(L, 1));
74 | return 1;
75 | }
76 |
77 |
78 | static int setn (lua_State *L) {
79 | luaL_checktype(L, 1, LUA_TTABLE);
80 | #ifndef luaL_setn
81 | luaL_setn(L, 1, luaL_checkint(L, 2));
82 | #else
83 | luaL_error(L, LUA_QL("setn") " is obsolete");
84 | #endif
85 | lua_pushvalue(L, 1);
86 | return 1;
87 | }
88 |
89 |
90 | static int tinsert (lua_State *L) {
91 | int e = aux_getn(L, 1) + 1; /* first empty element */
92 | int pos; /* where to insert new element */
93 | switch (lua_gettop(L)) {
94 | case 2: { /* called with only 2 arguments */
95 | pos = e; /* insert new element at the end */
96 | break;
97 | }
98 | case 3: {
99 | int i;
100 | pos = luaL_checkint(L, 2); /* 2nd argument is the position */
101 | if (pos > e) e = pos; /* `grow' array if necessary */
102 | for (i = e; i > pos; i--) { /* move up elements */
103 | lua_rawgeti(L, 1, i-1);
104 | lua_rawseti(L, 1, i); /* t[i] = t[i-1] */
105 | }
106 | break;
107 | }
108 | default: {
109 | return luaL_error(L, "wrong number of arguments to " LUA_QL("insert"));
110 | }
111 | }
112 | luaL_setn(L, 1, e); /* new size */
113 | lua_rawseti(L, 1, pos); /* t[pos] = v */
114 | return 0;
115 | }
116 |
117 |
118 | static int tremove (lua_State *L) {
119 | int e = aux_getn(L, 1);
120 | int pos = luaL_optint(L, 2, e);
121 | if (!(1 <= pos && pos <= e)) /* position is outside bounds? */
122 | return 0; /* nothing to remove */
123 | luaL_setn(L, 1, e - 1); /* t.n = n-1 */
124 | lua_rawgeti(L, 1, pos); /* result = t[pos] */
125 | for ( ;pos= P */
226 | while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
227 | if (i>u) luaL_error(L, "invalid order function for sorting");
228 | lua_pop(L, 1); /* remove a[i] */
229 | }
230 | /* repeat --j until a[j] <= P */
231 | while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
232 | if (j>1) /* `sBx' is signed */
59 | #else
60 | #define MAXARG_Bx MAX_INT
61 | #define MAXARG_sBx MAX_INT
62 | #endif
63 |
64 |
65 | #define MAXARG_A ((1<>POS_OP) & MASK1(SIZE_OP,0)))
81 | #define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
82 | ((cast(Instruction, o)<>POS_A) & MASK1(SIZE_A,0)))
85 | #define SETARG_A(i,u) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
86 | ((cast(Instruction, u)<>POS_B) & MASK1(SIZE_B,0)))
89 | #define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
90 | ((cast(Instruction, b)<>POS_C) & MASK1(SIZE_C,0)))
93 | #define SETARG_C(i,b) ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
94 | ((cast(Instruction, b)<>POS_Bx) & MASK1(SIZE_Bx,0)))
97 | #define SETARG_Bx(i,b) ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \
98 | ((cast(Instruction, b)< C) then pc++ */
190 | OP_TESTSET,/* A B C if (R(B) <=> C) then R(A) := R(B) else pc++ */
191 |
192 | OP_CALL,/* A B C R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
193 | OP_TAILCALL,/* A B C return R(A)(R(A+1), ... ,R(A+B-1)) */
194 | OP_RETURN,/* A B return R(A), ... ,R(A+B-2) (see note) */
195 |
196 | OP_FORLOOP,/* A sBx R(A)+=R(A+2);
197 | if R(A) =) R(A)*/
205 | OP_CLOSURE,/* A Bx R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n)) */
206 |
207 | OP_VARARG/* A B R(A), R(A+1), ..., R(A+B-1) = vararg */
208 | } OpCode;
209 |
210 |
211 | #define NUM_OPCODES (cast(int, OP_VARARG) + 1)
212 |
213 |
214 |
215 | /*===========================================================================
216 | Notes:
217 | (*) In OP_CALL, if (B == 0) then B = top. C is the number of returns - 1,
218 | and can be 0: OP_CALL then sets `top' to last_result+1, so
219 | next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
220 |
221 | (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
222 | set top (like in OP_CALL with C == 0).
223 |
224 | (*) In OP_RETURN, if (B == 0) then return up to `top'
225 |
226 | (*) In OP_SETLIST, if (B == 0) then B = `top';
227 | if (C == 0) then next `instruction' is real C
228 |
229 | (*) For comparisons, A specifies what condition the test should accept
230 | (true or false).
231 |
232 | (*) All `skips' (pc++) assume that next instruction is a jump
233 | ===========================================================================*/
234 |
235 |
236 | /*
237 | ** masks for instruction properties. The format is:
238 | ** bits 0-1: op mode
239 | ** bits 2-3: C arg mode
240 | ** bits 4-5: B arg mode
241 | ** bit 6: instruction set register A
242 | ** bit 7: operator is a test
243 | */
244 |
245 | enum OpArgMask {
246 | OpArgN, /* argument is not used */
247 | OpArgU, /* argument is used */
248 | OpArgR, /* argument is a register or a jump offset */
249 | OpArgK /* argument is a constant or register/constant */
250 | };
251 |
252 | LUAI_DATA const lu_byte luaP_opmodes[NUM_OPCODES];
253 |
254 | #define getOpMode(m) (cast(enum OpMode, luaP_opmodes[m] & 3))
255 | #define getBMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
256 | #define getCMode(m) (cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
257 | #define testAMode(m) (luaP_opmodes[m] & (1 << 6))
258 | #define testTMode(m) (luaP_opmodes[m] & (1 << 7))
259 |
260 |
261 | LUAI_DATA const char *const luaP_opnames[NUM_OPCODES+1]; /* opcode names */
262 |
263 |
264 | /* number of list items to accumulate before a SETLIST instruction */
265 | #define LFIELDS_PER_FLUSH 50
266 |
267 |
268 | #endif
269 |
--------------------------------------------------------------------------------
/mLua/src/m/lua/MLua.java:
--------------------------------------------------------------------------------
1 | package m.lua;
2 |
3 | import java.io.ByteArrayOutputStream;
4 | import java.io.File;
5 | import java.io.FileInputStream;
6 | import java.lang.reflect.InvocationHandler;
7 | import java.lang.reflect.Method;
8 | import java.lang.reflect.Proxy;
9 |
10 | import android.util.Log;
11 |
12 | import com.mob.tools.utils.ReflectHelper;
13 |
14 | public class MLua {
15 | private static final String TAG = "mLua";
16 | private LuaWrapper lua;
17 |
18 | public MLua() {
19 | lua = new LuaWrapper();
20 | registerFunctions();
21 | }
22 |
23 | public void setBasedir(final String basedir) {
24 | lua.setSourceLoader(new SourceLoader() {
25 | public byte[] loadFile(String path) throws Throwable {
26 | File file = new File(basedir, path);
27 | if (!file.exists() && !path.endsWith(".lua")) {
28 | file = new File(basedir, path + ".lua");
29 | }
30 |
31 | if (file.exists()) {
32 | FileInputStream fis = new FileInputStream(file);
33 | ByteArrayOutputStream baos = new ByteArrayOutputStream();
34 | byte[] buf = new byte[1024];
35 | int len = fis.read(buf);
36 | while (len > 0) {
37 | baos.write(buf, 0, len);
38 | len = fis.read(buf);
39 | }
40 | baos.close();
41 | fis.close();
42 | return baos.toByteArray();
43 | }
44 | return null;
45 | }
46 | });
47 | }
48 |
49 | public void start(String launcher) throws Throwable {
50 | lua.start(launcher);
51 | }
52 |
53 | public void stop() {
54 | lua.stop();
55 | }
56 |
57 | private void registerFunctions() {
58 | addPrint();
59 | addToChar();
60 | addToInt();
61 | addToFloat();
62 |
63 | addImportClass();
64 | addNewInstance();
65 | addInvokeStaticMethod();
66 | addInvokeInstanceMethod();
67 | addGetStaticField();
68 | addSetStaticField();
69 | addGetInstanceField();
70 | addSetInstanceField();
71 | addGetClass();
72 | addCreateProxy();
73 | }
74 |
75 | public void pushGlobal(String name, Object value) {
76 | if (value instanceof JavaFunction) {
77 | lua.addJavaFunction(name, (JavaFunction) value);
78 | } else {
79 | lua.addJavaObject(name, value);
80 | }
81 | }
82 |
83 | // ================================================
84 |
85 | private void addPrint() {
86 | lua.addJavaFunction("print", new JavaFunction() {
87 | public Object execute(Object[] args) throws Throwable {
88 | StringBuffer sb = new StringBuffer();
89 | if (args == null) {
90 | sb.append("null");
91 | } else {
92 | for (Object arg : args) {
93 | if (sb.length() > 0) {
94 | sb.append('\t');
95 | }
96 | sb.append(arg);
97 | }
98 | }
99 | Log.d(TAG, sb.toString());
100 | return null;
101 | }
102 | });
103 | }
104 |
105 | private void addToChar() {
106 | lua.addJavaFunction("toChar", new JavaFunction() {
107 | public Object execute(Object[] args) throws Throwable {
108 | Double d = (Double) args[0];
109 | return (char) d.shortValue();
110 | }
111 | });
112 | }
113 |
114 | private void addToInt() {
115 | lua.addJavaFunction("toInt", new JavaFunction() {
116 | public Object execute(Object[] args) throws Throwable {
117 | Double d = (Double) args[0];
118 | double dValue = d.doubleValue();
119 | if (dValue > Integer.MAX_VALUE || dValue < Integer.MIN_VALUE) {
120 | return d.longValue();
121 | } else if (dValue > Short.MAX_VALUE || dValue < Short.MIN_VALUE) {
122 | return d.intValue();
123 | } else if (dValue > Byte.MAX_VALUE || dValue < Byte.MIN_VALUE) {
124 | return d.shortValue();
125 | } else {
126 | return d.byteValue();
127 | }
128 | }
129 | });
130 | }
131 |
132 | private void addToFloat() {
133 | lua.addJavaFunction("toFloat", new JavaFunction() {
134 | public Object execute(Object[] args) throws Throwable {
135 | Double d = (Double) args[0];
136 | return d.floatValue();
137 | }
138 | });
139 | }
140 |
141 | // ================================================
142 |
143 | private void addImportClass() {
144 | lua.addJavaFunction("import", new JavaFunction() {
145 | public Object execute(Object[] args) throws Throwable {
146 | String ret = null;
147 | if (args.length == 1) {
148 | String className = (String) args[0];
149 | ret = ReflectHelper.importClass(className);
150 | } else {
151 | String name = (String) args[0];
152 | String className = (String) args[1];
153 | ret = ReflectHelper.importClass(name, className);
154 | }
155 | return ret;
156 | }
157 | });
158 | }
159 |
160 | private void addNewInstance() {
161 | lua.addJavaFunction("new", new JavaFunction() {
162 | public Object execute(Object[] args) throws Throwable {
163 | String className = (String) args[0];
164 | Object ret;
165 | if (args.length > 1) {
166 | Object[] params = new Object[args.length - 1];
167 | System.arraycopy(args, 1, params, 0, params.length);
168 | ret = ReflectHelper.newInstance(className, params);
169 | } else {
170 | ret = ReflectHelper.newInstance(className);
171 | }
172 | return ret;
173 | }
174 | });
175 | }
176 |
177 | private void addInvokeStaticMethod() {
178 | lua.addJavaFunction("invokeStatic", new JavaFunction() {
179 | public Object execute(Object[] args) throws Throwable {
180 | String className = (String) args[0];
181 | String methodName = (String) args[1];
182 | Object ret;
183 | if (args.length > 2) {
184 | Object[] params = new Object[args.length - 2];
185 | System.arraycopy(args, 2, params, 0, params.length);
186 | ret = ReflectHelper.invokeStaticMethod(className, methodName, params);
187 | } else {
188 | ret = ReflectHelper.invokeStaticMethod(className, methodName);
189 | }
190 | return ret;
191 | }
192 | });
193 | }
194 |
195 | private void addInvokeInstanceMethod() {
196 | lua.addJavaFunction("invoke", new JavaFunction() {
197 | public Object execute(Object[] args) throws Throwable {
198 | Object receiver = args[0];
199 | String methodName = (String) args[1];
200 | Object ret;
201 | if (args.length > 2) {
202 | Object[] params = new Object[args.length - 2];
203 | System.arraycopy(args, 2, params, 0, params.length);
204 | ret = ReflectHelper.invokeInstanceMethod(receiver, methodName, params);
205 | } else {
206 | ret = ReflectHelper.invokeInstanceMethod(receiver, methodName);
207 | }
208 | return ret;
209 | }
210 | });
211 | }
212 |
213 | private void addGetStaticField() {
214 | lua.addJavaFunction("getStatic", new JavaFunction() {
215 | public Object execute(Object[] args) throws Throwable {
216 | String className = (String) args[0];
217 | String fieldName = (String) args[1];
218 | return ReflectHelper.getStaticField(className, fieldName);
219 | }
220 | });
221 | }
222 |
223 | private void addSetStaticField() {
224 | lua.addJavaFunction("setStatic", new JavaFunction() {
225 | public Object execute(Object[] args) throws Throwable {
226 | String className = (String) args[0];
227 | String fieldName = (String) args[1];
228 | Object value = args[2];
229 | ReflectHelper.setStaticField(className, fieldName, value);
230 | return null;
231 | }
232 | });
233 | }
234 |
235 | private void addGetInstanceField() {
236 | lua.addJavaFunction("get", new JavaFunction() {
237 | public Object execute(Object[] args) throws Throwable {
238 | Object receiver = args[0];
239 | String fieldName = (String) args[1];
240 | return ReflectHelper.getInstanceField(receiver, fieldName);
241 | }
242 | });
243 | }
244 |
245 | private void addSetInstanceField() {
246 | lua.addJavaFunction("set", new JavaFunction() {
247 | public Object execute(Object[] args) throws Throwable {
248 | Object receiver = args[0];
249 | String fieldName = (String) args[1];
250 | Object value = args[2];
251 | ReflectHelper.setInstanceField(receiver, fieldName, value);
252 | return null;
253 | }
254 | });
255 | }
256 |
257 | private void addGetClass() {
258 | lua.addJavaFunction("getClass", new JavaFunction() {
259 | public Object execute(Object[] args) throws Throwable {
260 | String name = (String) args[0];
261 | return ReflectHelper.getClass(name);
262 | }
263 | });
264 | }
265 |
266 | private void addCreateProxy() {
267 | lua.addJavaFunction("createProxy", new JavaFunction() {
268 | public Object execute(Object[] args) throws Throwable {
269 | final LuaObject table = (LuaObject) args[0];
270 | Class[] proxyIntefaces = new Class[args.length - 1];
271 | for (int i = 0; i < proxyIntefaces.length; i++) {
272 | String name = (String) args[i + 1];
273 | proxyIntefaces[i] = ReflectHelper.getClass(name);
274 | }
275 |
276 | ClassLoader loader = getClass().getClassLoader();
277 | InvocationHandler handler = new InvocationHandler() {
278 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
279 | LuaObject function = table.getField(method.getName());
280 | Class retType = method.getReturnType();
281 | if (retType.equals(Void.class) || retType.equals(void.class)) {
282 | return function.call(args, 0);
283 | } else {
284 | return function.call(args, 1);
285 | }
286 | }
287 | };
288 |
289 | return Proxy.newProxyInstance(loader, proxyIntefaces, handler);
290 | }
291 | });
292 | }
293 |
294 | }
295 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lobject.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lobject.h,v 2.20.1.2 2008/08/06 13:29:48 roberto Exp $
3 | ** Type definitions for Lua objects
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #ifndef lobject_h
9 | #define lobject_h
10 |
11 |
12 | #include
13 |
14 |
15 | #include "llimits.h"
16 | #include "lua.h"
17 |
18 |
19 | /* tags for values visible from Lua */
20 | #define LAST_TAG LUA_TTHREAD
21 |
22 | #define NUM_TAGS (LAST_TAG+1)
23 |
24 |
25 | /*
26 | ** Extra tags for non-values
27 | */
28 | #define LUA_TPROTO (LAST_TAG+1)
29 | #define LUA_TUPVAL (LAST_TAG+2)
30 | #define LUA_TDEADKEY (LAST_TAG+3)
31 |
32 |
33 | /*
34 | ** Union of all collectable objects
35 | */
36 | typedef union GCObject GCObject;
37 |
38 |
39 | /*
40 | ** Common Header for all collectable objects (in macro form, to be
41 | ** included in other objects)
42 | */
43 | #define CommonHeader GCObject *next; lu_byte tt; lu_byte marked
44 |
45 |
46 | /*
47 | ** Common header in struct form
48 | */
49 | typedef struct GCheader {
50 | CommonHeader;
51 | } GCheader;
52 |
53 |
54 |
55 |
56 | /*
57 | ** Union of all Lua values
58 | */
59 | typedef union {
60 | GCObject *gc;
61 | void *p;
62 | lua_Number n;
63 | int b;
64 | } Value;
65 |
66 |
67 | /*
68 | ** Tagged Values
69 | */
70 |
71 | #define TValuefields Value value; int tt
72 |
73 | typedef struct lua_TValue {
74 | TValuefields;
75 | } TValue;
76 |
77 |
78 | /* Macros to test type */
79 | #define ttisnil(o) (ttype(o) == LUA_TNIL)
80 | #define ttisnumber(o) (ttype(o) == LUA_TNUMBER)
81 | #define ttisstring(o) (ttype(o) == LUA_TSTRING)
82 | #define ttistable(o) (ttype(o) == LUA_TTABLE)
83 | #define ttisfunction(o) (ttype(o) == LUA_TFUNCTION)
84 | #define ttisboolean(o) (ttype(o) == LUA_TBOOLEAN)
85 | #define ttisuserdata(o) (ttype(o) == LUA_TUSERDATA)
86 | #define ttisthread(o) (ttype(o) == LUA_TTHREAD)
87 | #define ttislightuserdata(o) (ttype(o) == LUA_TLIGHTUSERDATA)
88 |
89 | /* Macros to access values */
90 | #define ttype(o) ((o)->tt)
91 | #define gcvalue(o) check_exp(iscollectable(o), (o)->value.gc)
92 | #define pvalue(o) check_exp(ttislightuserdata(o), (o)->value.p)
93 | #define nvalue(o) check_exp(ttisnumber(o), (o)->value.n)
94 | #define rawtsvalue(o) check_exp(ttisstring(o), &(o)->value.gc->ts)
95 | #define tsvalue(o) (&rawtsvalue(o)->tsv)
96 | #define rawuvalue(o) check_exp(ttisuserdata(o), &(o)->value.gc->u)
97 | #define uvalue(o) (&rawuvalue(o)->uv)
98 | #define clvalue(o) check_exp(ttisfunction(o), &(o)->value.gc->cl)
99 | #define hvalue(o) check_exp(ttistable(o), &(o)->value.gc->h)
100 | #define bvalue(o) check_exp(ttisboolean(o), (o)->value.b)
101 | #define thvalue(o) check_exp(ttisthread(o), &(o)->value.gc->th)
102 |
103 | #define l_isfalse(o) (ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
104 |
105 | /*
106 | ** for internal debug only
107 | */
108 | #define checkconsistency(obj) \
109 | lua_assert(!iscollectable(obj) || (ttype(obj) == (obj)->value.gc->gch.tt))
110 |
111 | #define checkliveness(g,obj) \
112 | lua_assert(!iscollectable(obj) || \
113 | ((ttype(obj) == (obj)->value.gc->gch.tt) && !isdead(g, (obj)->value.gc)))
114 |
115 |
116 | /* Macros to set values */
117 | #define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
118 |
119 | #define setnvalue(obj,x) \
120 | { TValue *i_o=(obj); i_o->value.n=(x); i_o->tt=LUA_TNUMBER; }
121 |
122 | #define setpvalue(obj,x) \
123 | { TValue *i_o=(obj); i_o->value.p=(x); i_o->tt=LUA_TLIGHTUSERDATA; }
124 |
125 | #define setbvalue(obj,x) \
126 | { TValue *i_o=(obj); i_o->value.b=(x); i_o->tt=LUA_TBOOLEAN; }
127 |
128 | #define setsvalue(L,obj,x) \
129 | { TValue *i_o=(obj); \
130 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TSTRING; \
131 | checkliveness(G(L),i_o); }
132 |
133 | #define setuvalue(L,obj,x) \
134 | { TValue *i_o=(obj); \
135 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TUSERDATA; \
136 | checkliveness(G(L),i_o); }
137 |
138 | #define setthvalue(L,obj,x) \
139 | { TValue *i_o=(obj); \
140 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTHREAD; \
141 | checkliveness(G(L),i_o); }
142 |
143 | #define setclvalue(L,obj,x) \
144 | { TValue *i_o=(obj); \
145 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TFUNCTION; \
146 | checkliveness(G(L),i_o); }
147 |
148 | #define sethvalue(L,obj,x) \
149 | { TValue *i_o=(obj); \
150 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TTABLE; \
151 | checkliveness(G(L),i_o); }
152 |
153 | #define setptvalue(L,obj,x) \
154 | { TValue *i_o=(obj); \
155 | i_o->value.gc=cast(GCObject *, (x)); i_o->tt=LUA_TPROTO; \
156 | checkliveness(G(L),i_o); }
157 |
158 |
159 |
160 |
161 | #define setobj(L,obj1,obj2) \
162 | { const TValue *o2=(obj2); TValue *o1=(obj1); \
163 | o1->value = o2->value; o1->tt=o2->tt; \
164 | checkliveness(G(L),o1); }
165 |
166 |
167 | /*
168 | ** different types of sets, according to destination
169 | */
170 |
171 | /* from stack to (same) stack */
172 | #define setobjs2s setobj
173 | /* to stack (not from same stack) */
174 | #define setobj2s setobj
175 | #define setsvalue2s setsvalue
176 | #define sethvalue2s sethvalue
177 | #define setptvalue2s setptvalue
178 | /* from table to same table */
179 | #define setobjt2t setobj
180 | /* to table */
181 | #define setobj2t setobj
182 | /* to new object */
183 | #define setobj2n setobj
184 | #define setsvalue2n setsvalue
185 |
186 | #define setttype(obj, tt) (ttype(obj) = (tt))
187 |
188 |
189 | #define iscollectable(o) (ttype(o) >= LUA_TSTRING)
190 |
191 |
192 |
193 | typedef TValue *StkId; /* index to stack elements */
194 |
195 |
196 | /*
197 | ** String headers for string table
198 | */
199 | typedef union TString {
200 | L_Umaxalign dummy; /* ensures maximum alignment for strings */
201 | struct {
202 | CommonHeader;
203 | lu_byte reserved;
204 | unsigned int hash;
205 | size_t len;
206 | } tsv;
207 | } TString;
208 |
209 |
210 | #define getstr(ts) cast(const char *, (ts) + 1)
211 | #define svalue(o) getstr(rawtsvalue(o))
212 |
213 |
214 |
215 | typedef union Udata {
216 | L_Umaxalign dummy; /* ensures maximum alignment for `local' udata */
217 | struct {
218 | CommonHeader;
219 | struct Table *metatable;
220 | struct Table *env;
221 | size_t len;
222 | } uv;
223 | } Udata;
224 |
225 |
226 |
227 |
228 | /*
229 | ** Function Prototypes
230 | */
231 | typedef struct Proto {
232 | CommonHeader;
233 | TValue *k; /* constants used by the function */
234 | Instruction *code;
235 | struct Proto **p; /* functions defined inside the function */
236 | int *lineinfo; /* map from opcodes to source lines */
237 | struct LocVar *locvars; /* information about local variables */
238 | TString **upvalues; /* upvalue names */
239 | TString *source;
240 | int sizeupvalues;
241 | int sizek; /* size of `k' */
242 | int sizecode;
243 | int sizelineinfo;
244 | int sizep; /* size of `p' */
245 | int sizelocvars;
246 | int linedefined;
247 | int lastlinedefined;
248 | GCObject *gclist;
249 | lu_byte nups; /* number of upvalues */
250 | lu_byte numparams;
251 | lu_byte is_vararg;
252 | lu_byte maxstacksize;
253 | } Proto;
254 |
255 |
256 | /* masks for new-style vararg */
257 | #define VARARG_HASARG 1
258 | #define VARARG_ISVARARG 2
259 | #define VARARG_NEEDSARG 4
260 |
261 |
262 | typedef struct LocVar {
263 | TString *varname;
264 | int startpc; /* first point where variable is active */
265 | int endpc; /* first point where variable is dead */
266 | } LocVar;
267 |
268 |
269 |
270 | /*
271 | ** Upvalues
272 | */
273 |
274 | typedef struct UpVal {
275 | CommonHeader;
276 | TValue *v; /* points to stack or to its own value */
277 | union {
278 | TValue value; /* the value (when closed) */
279 | struct { /* double linked list (when open) */
280 | struct UpVal *prev;
281 | struct UpVal *next;
282 | } l;
283 | } u;
284 | } UpVal;
285 |
286 |
287 | /*
288 | ** Closures
289 | */
290 |
291 | #define ClosureHeader \
292 | CommonHeader; lu_byte isC; lu_byte nupvalues; GCObject *gclist; \
293 | struct Table *env
294 |
295 | typedef struct CClosure {
296 | ClosureHeader;
297 | lua_CFunction f;
298 | TValue upvalue[1];
299 | } CClosure;
300 |
301 |
302 | typedef struct LClosure {
303 | ClosureHeader;
304 | struct Proto *p;
305 | UpVal *upvals[1];
306 | } LClosure;
307 |
308 |
309 | typedef union Closure {
310 | CClosure c;
311 | LClosure l;
312 | } Closure;
313 |
314 |
315 | #define iscfunction(o) (ttype(o) == LUA_TFUNCTION && clvalue(o)->c.isC)
316 | #define isLfunction(o) (ttype(o) == LUA_TFUNCTION && !clvalue(o)->c.isC)
317 |
318 |
319 | /*
320 | ** Tables
321 | */
322 |
323 | typedef union TKey {
324 | struct {
325 | TValuefields;
326 | struct Node *next; /* for chaining */
327 | } nk;
328 | TValue tvk;
329 | } TKey;
330 |
331 |
332 | typedef struct Node {
333 | TValue i_val;
334 | TKey i_key;
335 | } Node;
336 |
337 |
338 | typedef struct Table {
339 | CommonHeader;
340 | lu_byte flags; /* 1<lsizenode))
361 |
362 |
363 | #define luaO_nilobject (&luaO_nilobject_)
364 |
365 | LUAI_DATA const TValue luaO_nilobject_;
366 |
367 | #define ceillog2(x) (luaO_log2((x)-1) + 1)
368 |
369 | LUAI_FUNC int luaO_log2 (unsigned int x);
370 | LUAI_FUNC int luaO_int2fb (unsigned int x);
371 | LUAI_FUNC int luaO_fb2int (int x);
372 | LUAI_FUNC int luaO_rawequalObj (const TValue *t1, const TValue *t2);
373 | LUAI_FUNC int luaO_str2d (const char *s, lua_Number *result);
374 | LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
375 | va_list argp);
376 | LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);
377 | LUAI_FUNC void luaO_chunkid (char *out, const char *source, size_t len);
378 |
379 |
380 | #endif
381 |
382 |
--------------------------------------------------------------------------------
/mLua/jni/lua/ldblib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: ldblib.c,v 1.104.1.4 2009/08/04 18:50:18 roberto Exp $
3 | ** Interface from Lua to its debug API
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 |
12 | #define ldblib_c
13 | #define LUA_LIB
14 |
15 | #include "lua.h"
16 |
17 | #include "lauxlib.h"
18 | #include "lualib.h"
19 |
20 |
21 |
22 | static int db_getregistry (lua_State *L) {
23 | lua_pushvalue(L, LUA_REGISTRYINDEX);
24 | return 1;
25 | }
26 |
27 |
28 | static int db_getmetatable (lua_State *L) {
29 | luaL_checkany(L, 1);
30 | if (!lua_getmetatable(L, 1)) {
31 | lua_pushnil(L); /* no metatable */
32 | }
33 | return 1;
34 | }
35 |
36 |
37 | static int db_setmetatable (lua_State *L) {
38 | int t = lua_type(L, 2);
39 | luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
40 | "nil or table expected");
41 | lua_settop(L, 2);
42 | lua_pushboolean(L, lua_setmetatable(L, 1));
43 | return 1;
44 | }
45 |
46 |
47 | static int db_getfenv (lua_State *L) {
48 | luaL_checkany(L, 1);
49 | lua_getfenv(L, 1);
50 | return 1;
51 | }
52 |
53 |
54 | static int db_setfenv (lua_State *L) {
55 | luaL_checktype(L, 2, LUA_TTABLE);
56 | lua_settop(L, 2);
57 | if (lua_setfenv(L, 1) == 0)
58 | luaL_error(L, LUA_QL("setfenv")
59 | " cannot change environment of given object");
60 | return 1;
61 | }
62 |
63 |
64 | static void settabss (lua_State *L, const char *i, const char *v) {
65 | lua_pushstring(L, v);
66 | lua_setfield(L, -2, i);
67 | }
68 |
69 |
70 | static void settabsi (lua_State *L, const char *i, int v) {
71 | lua_pushinteger(L, v);
72 | lua_setfield(L, -2, i);
73 | }
74 |
75 |
76 | static lua_State *getthread (lua_State *L, int *arg) {
77 | if (lua_isthread(L, 1)) {
78 | *arg = 1;
79 | return lua_tothread(L, 1);
80 | }
81 | else {
82 | *arg = 0;
83 | return L;
84 | }
85 | }
86 |
87 |
88 | static void treatstackoption (lua_State *L, lua_State *L1, const char *fname) {
89 | if (L == L1) {
90 | lua_pushvalue(L, -2);
91 | lua_remove(L, -3);
92 | }
93 | else
94 | lua_xmove(L1, L, 1);
95 | lua_setfield(L, -2, fname);
96 | }
97 |
98 |
99 | static int db_getinfo (lua_State *L) {
100 | lua_Debug ar;
101 | int arg;
102 | lua_State *L1 = getthread(L, &arg);
103 | const char *options = luaL_optstring(L, arg+2, "flnSu");
104 | if (lua_isnumber(L, arg+1)) {
105 | if (!lua_getstack(L1, (int)lua_tointeger(L, arg+1), &ar)) {
106 | lua_pushnil(L); /* level out of range */
107 | return 1;
108 | }
109 | }
110 | else if (lua_isfunction(L, arg+1)) {
111 | lua_pushfstring(L, ">%s", options);
112 | options = lua_tostring(L, -1);
113 | lua_pushvalue(L, arg+1);
114 | lua_xmove(L, L1, 1);
115 | }
116 | else
117 | return luaL_argerror(L, arg+1, "function or level expected");
118 | if (!lua_getinfo(L1, options, &ar))
119 | return luaL_argerror(L, arg+2, "invalid option");
120 | lua_createtable(L, 0, 2);
121 | if (strchr(options, 'S')) {
122 | settabss(L, "source", ar.source);
123 | settabss(L, "short_src", ar.short_src);
124 | settabsi(L, "linedefined", ar.linedefined);
125 | settabsi(L, "lastlinedefined", ar.lastlinedefined);
126 | settabss(L, "what", ar.what);
127 | }
128 | if (strchr(options, 'l'))
129 | settabsi(L, "currentline", ar.currentline);
130 | if (strchr(options, 'u'))
131 | settabsi(L, "nups", ar.nups);
132 | if (strchr(options, 'n')) {
133 | settabss(L, "name", ar.name);
134 | settabss(L, "namewhat", ar.namewhat);
135 | }
136 | if (strchr(options, 'L'))
137 | treatstackoption(L, L1, "activelines");
138 | if (strchr(options, 'f'))
139 | treatstackoption(L, L1, "func");
140 | return 1; /* return table */
141 | }
142 |
143 |
144 | static int db_getlocal (lua_State *L) {
145 | int arg;
146 | lua_State *L1 = getthread(L, &arg);
147 | lua_Debug ar;
148 | const char *name;
149 | if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */
150 | return luaL_argerror(L, arg+1, "level out of range");
151 | name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
152 | if (name) {
153 | lua_xmove(L1, L, 1);
154 | lua_pushstring(L, name);
155 | lua_pushvalue(L, -2);
156 | return 2;
157 | }
158 | else {
159 | lua_pushnil(L);
160 | return 1;
161 | }
162 | }
163 |
164 |
165 | static int db_setlocal (lua_State *L) {
166 | int arg;
167 | lua_State *L1 = getthread(L, &arg);
168 | lua_Debug ar;
169 | if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)) /* out of range? */
170 | return luaL_argerror(L, arg+1, "level out of range");
171 | luaL_checkany(L, arg+3);
172 | lua_settop(L, arg+3);
173 | lua_xmove(L, L1, 1);
174 | lua_pushstring(L, lua_setlocal(L1, &ar, luaL_checkint(L, arg+2)));
175 | return 1;
176 | }
177 |
178 |
179 | static int auxupvalue (lua_State *L, int get) {
180 | const char *name;
181 | int n = luaL_checkint(L, 2);
182 | luaL_checktype(L, 1, LUA_TFUNCTION);
183 | if (lua_iscfunction(L, 1)) return 0; /* cannot touch C upvalues from Lua */
184 | name = get ? lua_getupvalue(L, 1, n) : lua_setupvalue(L, 1, n);
185 | if (name == NULL) return 0;
186 | lua_pushstring(L, name);
187 | lua_insert(L, -(get+1));
188 | return get + 1;
189 | }
190 |
191 |
192 | static int db_getupvalue (lua_State *L) {
193 | return auxupvalue(L, 1);
194 | }
195 |
196 |
197 | static int db_setupvalue (lua_State *L) {
198 | luaL_checkany(L, 3);
199 | return auxupvalue(L, 0);
200 | }
201 |
202 |
203 |
204 | static const char KEY_HOOK = 'h';
205 |
206 |
207 | static void hookf (lua_State *L, lua_Debug *ar) {
208 | static const char *const hooknames[] =
209 | {"call", "return", "line", "count", "tail return"};
210 | lua_pushlightuserdata(L, (void *)&KEY_HOOK);
211 | lua_rawget(L, LUA_REGISTRYINDEX);
212 | lua_pushlightuserdata(L, L);
213 | lua_rawget(L, -2);
214 | if (lua_isfunction(L, -1)) {
215 | lua_pushstring(L, hooknames[(int)ar->event]);
216 | if (ar->currentline >= 0)
217 | lua_pushinteger(L, ar->currentline);
218 | else lua_pushnil(L);
219 | lua_assert(lua_getinfo(L, "lS", ar));
220 | lua_call(L, 2, 0);
221 | }
222 | }
223 |
224 |
225 | static int makemask (const char *smask, int count) {
226 | int mask = 0;
227 | if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
228 | if (strchr(smask, 'r')) mask |= LUA_MASKRET;
229 | if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
230 | if (count > 0) mask |= LUA_MASKCOUNT;
231 | return mask;
232 | }
233 |
234 |
235 | static char *unmakemask (int mask, char *smask) {
236 | int i = 0;
237 | if (mask & LUA_MASKCALL) smask[i++] = 'c';
238 | if (mask & LUA_MASKRET) smask[i++] = 'r';
239 | if (mask & LUA_MASKLINE) smask[i++] = 'l';
240 | smask[i] = '\0';
241 | return smask;
242 | }
243 |
244 |
245 | static void gethooktable (lua_State *L) {
246 | lua_pushlightuserdata(L, (void *)&KEY_HOOK);
247 | lua_rawget(L, LUA_REGISTRYINDEX);
248 | if (!lua_istable(L, -1)) {
249 | lua_pop(L, 1);
250 | lua_createtable(L, 0, 1);
251 | lua_pushlightuserdata(L, (void *)&KEY_HOOK);
252 | lua_pushvalue(L, -2);
253 | lua_rawset(L, LUA_REGISTRYINDEX);
254 | }
255 | }
256 |
257 |
258 | static int db_sethook (lua_State *L) {
259 | int arg, mask, count;
260 | lua_Hook func;
261 | lua_State *L1 = getthread(L, &arg);
262 | if (lua_isnoneornil(L, arg+1)) {
263 | lua_settop(L, arg+1);
264 | func = NULL; mask = 0; count = 0; /* turn off hooks */
265 | }
266 | else {
267 | const char *smask = luaL_checkstring(L, arg+2);
268 | luaL_checktype(L, arg+1, LUA_TFUNCTION);
269 | count = luaL_optint(L, arg+3, 0);
270 | func = hookf; mask = makemask(smask, count);
271 | }
272 | gethooktable(L);
273 | lua_pushlightuserdata(L, L1);
274 | lua_pushvalue(L, arg+1);
275 | lua_rawset(L, -3); /* set new hook */
276 | lua_pop(L, 1); /* remove hook table */
277 | lua_sethook(L1, func, mask, count); /* set hooks */
278 | return 0;
279 | }
280 |
281 |
282 | static int db_gethook (lua_State *L) {
283 | int arg;
284 | lua_State *L1 = getthread(L, &arg);
285 | char buff[5];
286 | int mask = lua_gethookmask(L1);
287 | lua_Hook hook = lua_gethook(L1);
288 | if (hook != NULL && hook != hookf) /* external hook? */
289 | lua_pushliteral(L, "external hook");
290 | else {
291 | gethooktable(L);
292 | lua_pushlightuserdata(L, L1);
293 | lua_rawget(L, -2); /* get hook */
294 | lua_remove(L, -2); /* remove hook table */
295 | }
296 | lua_pushstring(L, unmakemask(mask, buff));
297 | lua_pushinteger(L, lua_gethookcount(L1));
298 | return 3;
299 | }
300 |
301 |
302 | static int db_debug (lua_State *L) {
303 | for (;;) {
304 | char buffer[250];
305 | fputs("lua_debug> ", stderr);
306 | if (fgets(buffer, sizeof(buffer), stdin) == 0 ||
307 | strcmp(buffer, "cont\n") == 0)
308 | return 0;
309 | if (luaL_loadbuffer(L, buffer, strlen(buffer), "=(debug command)") ||
310 | lua_pcall(L, 0, 0, 0)) {
311 | fputs(lua_tostring(L, -1), stderr);
312 | fputs("\n", stderr);
313 | }
314 | lua_settop(L, 0); /* remove eventual returns */
315 | }
316 | }
317 |
318 |
319 | #define LEVELS1 12 /* size of the first part of the stack */
320 | #define LEVELS2 10 /* size of the second part of the stack */
321 |
322 | static int db_errorfb (lua_State *L) {
323 | int level;
324 | int firstpart = 1; /* still before eventual `...' */
325 | int arg;
326 | lua_State *L1 = getthread(L, &arg);
327 | lua_Debug ar;
328 | if (lua_isnumber(L, arg+2)) {
329 | level = (int)lua_tointeger(L, arg+2);
330 | lua_pop(L, 1);
331 | }
332 | else
333 | level = (L == L1) ? 1 : 0; /* level 0 may be this own function */
334 | if (lua_gettop(L) == arg)
335 | lua_pushliteral(L, "");
336 | else if (!lua_isstring(L, arg+1)) return 1; /* message is not a string */
337 | else lua_pushliteral(L, "\n");
338 | lua_pushliteral(L, "stack traceback:");
339 | while (lua_getstack(L1, level++, &ar)) {
340 | if (level > LEVELS1 && firstpart) {
341 | /* no more than `LEVELS2' more levels? */
342 | if (!lua_getstack(L1, level+LEVELS2, &ar))
343 | level--; /* keep going */
344 | else {
345 | lua_pushliteral(L, "\n\t..."); /* too many levels */
346 | while (lua_getstack(L1, level+LEVELS2, &ar)) /* find last levels */
347 | level++;
348 | }
349 | firstpart = 0;
350 | continue;
351 | }
352 | lua_pushliteral(L, "\n\t");
353 | lua_getinfo(L1, "Snl", &ar);
354 | lua_pushfstring(L, "%s:", ar.short_src);
355 | if (ar.currentline > 0)
356 | lua_pushfstring(L, "%d:", ar.currentline);
357 | if (*ar.namewhat != '\0') /* is there a name? */
358 | lua_pushfstring(L, " in function " LUA_QS, ar.name);
359 | else {
360 | if (*ar.what == 'm') /* main? */
361 | lua_pushfstring(L, " in main chunk");
362 | else if (*ar.what == 'C' || *ar.what == 't')
363 | lua_pushliteral(L, " ?"); /* C function or tail call */
364 | else
365 | lua_pushfstring(L, " in function <%s:%d>",
366 | ar.short_src, ar.linedefined);
367 | }
368 | lua_concat(L, lua_gettop(L) - arg);
369 | }
370 | lua_concat(L, lua_gettop(L) - arg);
371 | return 1;
372 | }
373 |
374 |
375 | static const luaL_Reg dblib[] = {
376 | {"debug", db_debug},
377 | {"getfenv", db_getfenv},
378 | {"gethook", db_gethook},
379 | {"getinfo", db_getinfo},
380 | {"getlocal", db_getlocal},
381 | {"getregistry", db_getregistry},
382 | {"getmetatable", db_getmetatable},
383 | {"getupvalue", db_getupvalue},
384 | {"setfenv", db_setfenv},
385 | {"sethook", db_sethook},
386 | {"setlocal", db_setlocal},
387 | {"setmetatable", db_setmetatable},
388 | {"setupvalue", db_setupvalue},
389 | {"traceback", db_errorfb},
390 | {NULL, NULL}
391 | };
392 |
393 |
394 | LUALIB_API int luaopen_debug (lua_State *L) {
395 | luaL_register(L, LUA_DBLIBNAME, dblib);
396 | return 1;
397 | }
398 |
399 |
--------------------------------------------------------------------------------
/mLua/jni/lua/lua.h:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: lua.h,v 1.218.1.7 2012/01/13 20:36:20 roberto Exp $
3 | ** Lua - An Extensible Extension Language
4 | ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
5 | ** See Copyright Notice at the end of this file
6 | */
7 |
8 |
9 | #ifndef lua_h
10 | #define lua_h
11 |
12 | #include
13 | #include
14 |
15 |
16 | #include "luaconf.h"
17 |
18 |
19 | #define LUA_VERSION "Lua 5.1"
20 | #define LUA_RELEASE "Lua 5.1.5"
21 | #define LUA_VERSION_NUM 501
22 | #define LUA_COPYRIGHT "Copyright (C) 1994-2012 Lua.org, PUC-Rio"
23 | #define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes"
24 |
25 |
26 | /* mark for precompiled code (`Lua') */
27 | #define LUA_SIGNATURE "\033Lua"
28 |
29 | /* option for multiple returns in `lua_pcall' and `lua_call' */
30 | #define LUA_MULTRET (-1)
31 |
32 |
33 | /*
34 | ** pseudo-indices
35 | */
36 | #define LUA_REGISTRYINDEX (-10000)
37 | #define LUA_ENVIRONINDEX (-10001)
38 | #define LUA_GLOBALSINDEX (-10002)
39 | #define lua_upvalueindex(i) (LUA_GLOBALSINDEX-(i))
40 |
41 |
42 | /* thread status; 0 is OK */
43 | #define LUA_YIELD 1
44 | #define LUA_ERRRUN 2
45 | #define LUA_ERRSYNTAX 3
46 | #define LUA_ERRMEM 4
47 | #define LUA_ERRERR 5
48 |
49 |
50 | typedef struct lua_State lua_State;
51 |
52 | typedef int (*lua_CFunction) (lua_State *L);
53 |
54 |
55 | /*
56 | ** functions that read/write blocks when loading/dumping Lua chunks
57 | */
58 | typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
59 |
60 | typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
61 |
62 |
63 | /*
64 | ** prototype for memory-allocation functions
65 | */
66 | typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
67 |
68 |
69 | /*
70 | ** basic types
71 | */
72 | #define LUA_TNONE (-1)
73 |
74 | #define LUA_TNIL 0
75 | #define LUA_TBOOLEAN 1
76 | #define LUA_TLIGHTUSERDATA 2
77 | #define LUA_TNUMBER 3
78 | #define LUA_TSTRING 4
79 | #define LUA_TTABLE 5
80 | #define LUA_TFUNCTION 6
81 | #define LUA_TUSERDATA 7
82 | #define LUA_TTHREAD 8
83 |
84 |
85 |
86 | /* minimum Lua stack available to a C function */
87 | #define LUA_MINSTACK 20
88 |
89 |
90 | /*
91 | ** generic extra include file
92 | */
93 | #if defined(LUA_USER_H)
94 | #include LUA_USER_H
95 | #endif
96 |
97 |
98 | /* type of numbers in Lua */
99 | typedef LUA_NUMBER lua_Number;
100 |
101 |
102 | /* type for integer functions */
103 | typedef LUA_INTEGER lua_Integer;
104 |
105 |
106 |
107 | /*
108 | ** state manipulation
109 | */
110 | LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
111 | LUA_API void (lua_close) (lua_State *L);
112 | LUA_API lua_State *(lua_newthread) (lua_State *L);
113 |
114 | LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
115 |
116 |
117 | /*
118 | ** basic stack manipulation
119 | */
120 | LUA_API int (lua_gettop) (lua_State *L);
121 | LUA_API void (lua_settop) (lua_State *L, int idx);
122 | LUA_API void (lua_pushvalue) (lua_State *L, int idx);
123 | LUA_API void (lua_remove) (lua_State *L, int idx);
124 | LUA_API void (lua_insert) (lua_State *L, int idx);
125 | LUA_API void (lua_replace) (lua_State *L, int idx);
126 | LUA_API int (lua_checkstack) (lua_State *L, int sz);
127 |
128 | LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);
129 |
130 |
131 | /*
132 | ** access functions (stack -> C)
133 | */
134 |
135 | LUA_API int (lua_isnumber) (lua_State *L, int idx);
136 | LUA_API int (lua_isstring) (lua_State *L, int idx);
137 | LUA_API int (lua_iscfunction) (lua_State *L, int idx);
138 | LUA_API int (lua_isuserdata) (lua_State *L, int idx);
139 | LUA_API int (lua_type) (lua_State *L, int idx);
140 | LUA_API const char *(lua_typename) (lua_State *L, int tp);
141 |
142 | LUA_API int (lua_equal) (lua_State *L, int idx1, int idx2);
143 | LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
144 | LUA_API int (lua_lessthan) (lua_State *L, int idx1, int idx2);
145 |
146 | LUA_API lua_Number (lua_tonumber) (lua_State *L, int idx);
147 | LUA_API lua_Integer (lua_tointeger) (lua_State *L, int idx);
148 | LUA_API int (lua_toboolean) (lua_State *L, int idx);
149 | LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
150 | LUA_API size_t (lua_objlen) (lua_State *L, int idx);
151 | LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
152 | LUA_API void *(lua_touserdata) (lua_State *L, int idx);
153 | LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
154 | LUA_API const void *(lua_topointer) (lua_State *L, int idx);
155 |
156 |
157 | /*
158 | ** push functions (C -> stack)
159 | */
160 | LUA_API void (lua_pushnil) (lua_State *L);
161 | LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);
162 | LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);
163 | LUA_API void (lua_pushlstring) (lua_State *L, const char *s, size_t l);
164 | LUA_API void (lua_pushstring) (lua_State *L, const char *s);
165 | LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
166 | va_list argp);
167 | LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
168 | LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
169 | LUA_API void (lua_pushboolean) (lua_State *L, int b);
170 | LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);
171 | LUA_API int (lua_pushthread) (lua_State *L);
172 |
173 |
174 | /*
175 | ** get functions (Lua -> stack)
176 | */
177 | LUA_API void (lua_gettable) (lua_State *L, int idx);
178 | LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k);
179 | LUA_API void (lua_rawget) (lua_State *L, int idx);
180 | LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n);
181 | LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
182 | LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
183 | LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
184 | LUA_API void (lua_getfenv) (lua_State *L, int idx);
185 |
186 |
187 | /*
188 | ** set functions (stack -> Lua)
189 | */
190 | LUA_API void (lua_settable) (lua_State *L, int idx);
191 | LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);
192 | LUA_API void (lua_rawset) (lua_State *L, int idx);
193 | LUA_API void (lua_rawseti) (lua_State *L, int idx, int n);
194 | LUA_API int (lua_setmetatable) (lua_State *L, int objindex);
195 | LUA_API int (lua_setfenv) (lua_State *L, int idx);
196 |
197 |
198 | /*
199 | ** `load' and `call' functions (load and run Lua code)
200 | */
201 | LUA_API void (lua_call) (lua_State *L, int nargs, int nresults);
202 | LUA_API int (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc);
203 | LUA_API int (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud);
204 | LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
205 | const char *chunkname);
206 |
207 | LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
208 |
209 |
210 | /*
211 | ** coroutine functions
212 | */
213 | LUA_API int (lua_yield) (lua_State *L, int nresults);
214 | LUA_API int (lua_resume) (lua_State *L, int narg);
215 | LUA_API int (lua_status) (lua_State *L);
216 |
217 | /*
218 | ** garbage-collection function and options
219 | */
220 |
221 | #define LUA_GCSTOP 0
222 | #define LUA_GCRESTART 1
223 | #define LUA_GCCOLLECT 2
224 | #define LUA_GCCOUNT 3
225 | #define LUA_GCCOUNTB 4
226 | #define LUA_GCSTEP 5
227 | #define LUA_GCSETPAUSE 6
228 | #define LUA_GCSETSTEPMUL 7
229 |
230 | LUA_API int (lua_gc) (lua_State *L, int what, int data);
231 |
232 |
233 | /*
234 | ** miscellaneous functions
235 | */
236 |
237 | LUA_API int (lua_error) (lua_State *L);
238 |
239 | LUA_API int (lua_next) (lua_State *L, int idx);
240 |
241 | LUA_API void (lua_concat) (lua_State *L, int n);
242 |
243 | LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
244 | LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);
245 |
246 |
247 |
248 | /*
249 | ** ===============================================================
250 | ** some useful macros
251 | ** ===============================================================
252 | */
253 |
254 | #define lua_pop(L,n) lua_settop(L, -(n)-1)
255 |
256 | #define lua_newtable(L) lua_createtable(L, 0, 0)
257 |
258 | #define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
259 |
260 | #define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
261 |
262 | #define lua_strlen(L,i) lua_objlen(L, (i))
263 |
264 | #define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
265 | #define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
266 | #define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
267 | #define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
268 | #define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
269 | #define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
270 | #define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
271 | #define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
272 |
273 | #define lua_pushliteral(L, s) \
274 | lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
275 |
276 | #define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, (s))
277 | #define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, (s))
278 |
279 | #define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
280 |
281 |
282 |
283 | /*
284 | ** compatibility macros and functions
285 | */
286 |
287 | #define lua_open() luaL_newstate()
288 |
289 | #define lua_getregistry(L) lua_pushvalue(L, LUA_REGISTRYINDEX)
290 |
291 | #define lua_getgccount(L) lua_gc(L, LUA_GCCOUNT, 0)
292 |
293 | #define lua_Chunkreader lua_Reader
294 | #define lua_Chunkwriter lua_Writer
295 |
296 |
297 | /* hack */
298 | LUA_API void lua_setlevel (lua_State *from, lua_State *to);
299 |
300 |
301 | /*
302 | ** {======================================================================
303 | ** Debug API
304 | ** =======================================================================
305 | */
306 |
307 |
308 | /*
309 | ** Event codes
310 | */
311 | #define LUA_HOOKCALL 0
312 | #define LUA_HOOKRET 1
313 | #define LUA_HOOKLINE 2
314 | #define LUA_HOOKCOUNT 3
315 | #define LUA_HOOKTAILRET 4
316 |
317 |
318 | /*
319 | ** Event masks
320 | */
321 | #define LUA_MASKCALL (1 << LUA_HOOKCALL)
322 | #define LUA_MASKRET (1 << LUA_HOOKRET)
323 | #define LUA_MASKLINE (1 << LUA_HOOKLINE)
324 | #define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
325 |
326 | typedef struct lua_Debug lua_Debug; /* activation record */
327 |
328 |
329 | /* Functions to be called by the debuger in specific events */
330 | typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
331 |
332 |
333 | LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
334 | LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
335 | LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
336 | LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
337 | LUA_API const char *lua_getupvalue (lua_State *L, int funcindex, int n);
338 | LUA_API const char *lua_setupvalue (lua_State *L, int funcindex, int n);
339 |
340 | LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count);
341 | LUA_API lua_Hook lua_gethook (lua_State *L);
342 | LUA_API int lua_gethookmask (lua_State *L);
343 | LUA_API int lua_gethookcount (lua_State *L);
344 |
345 |
346 | struct lua_Debug {
347 | int event;
348 | const char *name; /* (n) */
349 | const char *namewhat; /* (n) `global', `local', `field', `method' */
350 | const char *what; /* (S) `Lua', `C', `main', `tail' */
351 | const char *source; /* (S) */
352 | int currentline; /* (l) */
353 | int nups; /* (u) number of upvalues */
354 | int linedefined; /* (S) */
355 | int lastlinedefined; /* (S) */
356 | char short_src[LUA_IDSIZE]; /* (S) */
357 | /* private part */
358 | int i_ci; /* active function */
359 | };
360 |
361 | /* }====================================================================== */
362 |
363 |
364 | /******************************************************************************
365 | * Copyright (C) 1994-2012 Lua.org, PUC-Rio. All rights reserved.
366 | *
367 | * Permission is hereby granted, free of charge, to any person obtaining
368 | * a copy of this software and associated documentation files (the
369 | * "Software"), to deal in the Software without restriction, including
370 | * without limitation the rights to use, copy, modify, merge, publish,
371 | * distribute, sublicense, and/or sell copies of the Software, and to
372 | * permit persons to whom the Software is furnished to do so, subject to
373 | * the following conditions:
374 | *
375 | * The above copyright notice and this permission notice shall be
376 | * included in all copies or substantial portions of the Software.
377 | *
378 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
379 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
380 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
381 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
382 | * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
383 | * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
384 | * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
385 | ******************************************************************************/
386 |
387 |
388 | #endif
389 |
--------------------------------------------------------------------------------
/mLua/jni/lua/llex.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: llex.c,v 2.20.1.2 2009/11/23 14:58:22 roberto Exp $
3 | ** Lexical Analyzer
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 |
12 | #define llex_c
13 | #define LUA_CORE
14 |
15 | #include "lua.h"
16 |
17 | #include "ldo.h"
18 | #include "llex.h"
19 | #include "lobject.h"
20 | #include "lparser.h"
21 | #include "lstate.h"
22 | #include "lstring.h"
23 | #include "ltable.h"
24 | #include "lzio.h"
25 |
26 |
27 |
28 | #define next(ls) (ls->current = zgetc(ls->z))
29 |
30 |
31 |
32 |
33 | #define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r')
34 |
35 |
36 | /* ORDER RESERVED */
37 | const char *const luaX_tokens [] = {
38 | "and", "break", "do", "else", "elseif",
39 | "end", "false", "for", "function", "if",
40 | "in", "local", "nil", "not", "or", "repeat",
41 | "return", "then", "true", "until", "while",
42 | "..", "...", "==", ">=", "<=", "~=",
43 | "", "", "", "",
44 | NULL
45 | };
46 |
47 |
48 | #define save_and_next(ls) (save(ls, ls->current), next(ls))
49 |
50 |
51 | static void save (LexState *ls, int c) {
52 | Mbuffer *b = ls->buff;
53 | if (b->n + 1 > b->buffsize) {
54 | size_t newsize;
55 | if (b->buffsize >= MAX_SIZET/2)
56 | luaX_lexerror(ls, "lexical element too long", 0);
57 | newsize = b->buffsize * 2;
58 | luaZ_resizebuffer(ls->L, b, newsize);
59 | }
60 | b->buffer[b->n++] = cast(char, c);
61 | }
62 |
63 |
64 | void luaX_init (lua_State *L) {
65 | int i;
66 | for (i=0; itsv.reserved = cast_byte(i+1); /* reserved word */
71 | }
72 | }
73 |
74 |
75 | #define MAXSRC 80
76 |
77 |
78 | const char *luaX_token2str (LexState *ls, int token) {
79 | if (token < FIRST_RESERVED) {
80 | lua_assert(token == cast(unsigned char, token));
81 | return (iscntrl(token)) ? luaO_pushfstring(ls->L, "char(%d)", token) :
82 | luaO_pushfstring(ls->L, "%c", token);
83 | }
84 | else
85 | return luaX_tokens[token-FIRST_RESERVED];
86 | }
87 |
88 |
89 | static const char *txtToken (LexState *ls, int token) {
90 | switch (token) {
91 | case TK_NAME:
92 | case TK_STRING:
93 | case TK_NUMBER:
94 | save(ls, '\0');
95 | return luaZ_buffer(ls->buff);
96 | default:
97 | return luaX_token2str(ls, token);
98 | }
99 | }
100 |
101 |
102 | void luaX_lexerror (LexState *ls, const char *msg, int token) {
103 | char buff[MAXSRC];
104 | luaO_chunkid(buff, getstr(ls->source), MAXSRC);
105 | msg = luaO_pushfstring(ls->L, "%s:%d: %s", buff, ls->linenumber, msg);
106 | if (token)
107 | luaO_pushfstring(ls->L, "%s near " LUA_QS, msg, txtToken(ls, token));
108 | luaD_throw(ls->L, LUA_ERRSYNTAX);
109 | }
110 |
111 |
112 | void luaX_syntaxerror (LexState *ls, const char *msg) {
113 | luaX_lexerror(ls, msg, ls->t.token);
114 | }
115 |
116 |
117 | TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
118 | lua_State *L = ls->L;
119 | TString *ts = luaS_newlstr(L, str, l);
120 | TValue *o = luaH_setstr(L, ls->fs->h, ts); /* entry for `str' */
121 | if (ttisnil(o)) {
122 | setbvalue(o, 1); /* make sure `str' will not be collected */
123 | luaC_checkGC(L);
124 | }
125 | return ts;
126 | }
127 |
128 |
129 | static void inclinenumber (LexState *ls) {
130 | int old = ls->current;
131 | lua_assert(currIsNewline(ls));
132 | next(ls); /* skip `\n' or `\r' */
133 | if (currIsNewline(ls) && ls->current != old)
134 | next(ls); /* skip `\n\r' or `\r\n' */
135 | if (++ls->linenumber >= MAX_INT)
136 | luaX_syntaxerror(ls, "chunk has too many lines");
137 | }
138 |
139 |
140 | void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {
141 | ls->decpoint = '.';
142 | ls->L = L;
143 | ls->lookahead.token = TK_EOS; /* no look-ahead token */
144 | ls->z = z;
145 | ls->fs = NULL;
146 | ls->linenumber = 1;
147 | ls->lastline = 1;
148 | ls->source = source;
149 | luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */
150 | next(ls); /* read first char */
151 | }
152 |
153 |
154 |
155 | /*
156 | ** =======================================================
157 | ** LEXICAL ANALYZER
158 | ** =======================================================
159 | */
160 |
161 |
162 |
163 | static int check_next (LexState *ls, const char *set) {
164 | if (!strchr(set, ls->current))
165 | return 0;
166 | save_and_next(ls);
167 | return 1;
168 | }
169 |
170 |
171 | static void buffreplace (LexState *ls, char from, char to) {
172 | size_t n = luaZ_bufflen(ls->buff);
173 | char *p = luaZ_buffer(ls->buff);
174 | while (n--)
175 | if (p[n] == from) p[n] = to;
176 | }
177 |
178 |
179 | static void trydecpoint (LexState *ls, SemInfo *seminfo) {
180 | luaX_lexerror(ls, "malformed number", TK_NUMBER);
181 | }
182 |
183 |
184 | /* LUA_NUMBER */
185 | static void read_numeral (LexState *ls, SemInfo *seminfo) {
186 | lua_assert(isdigit(ls->current));
187 | do {
188 | save_and_next(ls);
189 | } while (isdigit(ls->current) || ls->current == '.');
190 | if (check_next(ls, "Ee")) /* `E'? */
191 | check_next(ls, "+-"); /* optional exponent sign */
192 | while (isalnum(ls->current) || ls->current == '_')
193 | save_and_next(ls);
194 | save(ls, '\0');
195 | buffreplace(ls, '.', ls->decpoint); /* follow locale for decimal point */
196 | if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) /* format error? */
197 | trydecpoint(ls, seminfo); /* try to update decimal point separator */
198 | }
199 |
200 |
201 | static int skip_sep (LexState *ls) {
202 | int count = 0;
203 | int s = ls->current;
204 | lua_assert(s == '[' || s == ']');
205 | save_and_next(ls);
206 | while (ls->current == '=') {
207 | save_and_next(ls);
208 | count++;
209 | }
210 | return (ls->current == s) ? count : (-count) - 1;
211 | }
212 |
213 |
214 | static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
215 | int cont = 0;
216 | (void)(cont); /* avoid warnings when `cont' is not used */
217 | save_and_next(ls); /* skip 2nd `[' */
218 | if (currIsNewline(ls)) /* string starts with a newline? */
219 | inclinenumber(ls); /* skip it */
220 | for (;;) {
221 | switch (ls->current) {
222 | case EOZ:
223 | luaX_lexerror(ls, (seminfo) ? "unfinished long string" :
224 | "unfinished long comment", TK_EOS);
225 | break; /* to avoid warnings */
226 | #if defined(LUA_COMPAT_LSTR)
227 | case '[': {
228 | if (skip_sep(ls) == sep) {
229 | save_and_next(ls); /* skip 2nd `[' */
230 | cont++;
231 | #if LUA_COMPAT_LSTR == 1
232 | if (sep == 0)
233 | luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');
234 | #endif
235 | }
236 | break;
237 | }
238 | #endif
239 | case ']': {
240 | if (skip_sep(ls) == sep) {
241 | save_and_next(ls); /* skip 2nd `]' */
242 | #if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2
243 | cont--;
244 | if (sep == 0 && cont >= 0) break;
245 | #endif
246 | goto endloop;
247 | }
248 | break;
249 | }
250 | case '\n':
251 | case '\r': {
252 | save(ls, '\n');
253 | inclinenumber(ls);
254 | if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */
255 | break;
256 | }
257 | default: {
258 | if (seminfo) save_and_next(ls);
259 | else next(ls);
260 | }
261 | }
262 | } endloop:
263 | if (seminfo)
264 | seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
265 | luaZ_bufflen(ls->buff) - 2*(2 + sep));
266 | }
267 |
268 |
269 | static void read_string (LexState *ls, int del, SemInfo *seminfo) {
270 | save_and_next(ls);
271 | while (ls->current != del) {
272 | switch (ls->current) {
273 | case EOZ:
274 | luaX_lexerror(ls, "unfinished string", TK_EOS);
275 | continue; /* to avoid warnings */
276 | case '\n':
277 | case '\r':
278 | luaX_lexerror(ls, "unfinished string", TK_STRING);
279 | continue; /* to avoid warnings */
280 | case '\\': {
281 | int c;
282 | next(ls); /* do not save the `\' */
283 | switch (ls->current) {
284 | case 'a': c = '\a'; break;
285 | case 'b': c = '\b'; break;
286 | case 'f': c = '\f'; break;
287 | case 'n': c = '\n'; break;
288 | case 'r': c = '\r'; break;
289 | case 't': c = '\t'; break;
290 | case 'v': c = '\v'; break;
291 | case '\n': /* go through */
292 | case '\r': save(ls, '\n'); inclinenumber(ls); continue;
293 | case EOZ: continue; /* will raise an error next loop */
294 | default: {
295 | if (!isdigit(ls->current))
296 | save_and_next(ls); /* handles \\, \", \', and \? */
297 | else { /* \xxx */
298 | int i = 0;
299 | c = 0;
300 | do {
301 | c = 10*c + (ls->current-'0');
302 | next(ls);
303 | } while (++i<3 && isdigit(ls->current));
304 | if (c > UCHAR_MAX)
305 | luaX_lexerror(ls, "escape sequence too large", TK_STRING);
306 | save(ls, c);
307 | }
308 | continue;
309 | }
310 | }
311 | save(ls, c);
312 | next(ls);
313 | continue;
314 | }
315 | default:
316 | save_and_next(ls);
317 | }
318 | }
319 | save_and_next(ls); /* skip delimiter */
320 | seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,
321 | luaZ_bufflen(ls->buff) - 2);
322 | }
323 |
324 |
325 | static int llex (LexState *ls, SemInfo *seminfo) {
326 | luaZ_resetbuffer(ls->buff);
327 | for (;;) {
328 | switch (ls->current) {
329 | case '\n':
330 | case '\r': {
331 | inclinenumber(ls);
332 | continue;
333 | }
334 | case '-': {
335 | next(ls);
336 | if (ls->current != '-') return '-';
337 | /* else is a comment */
338 | next(ls);
339 | if (ls->current == '[') {
340 | int sep = skip_sep(ls);
341 | luaZ_resetbuffer(ls->buff); /* `skip_sep' may dirty the buffer */
342 | if (sep >= 0) {
343 | read_long_string(ls, NULL, sep); /* long comment */
344 | luaZ_resetbuffer(ls->buff);
345 | continue;
346 | }
347 | }
348 | /* else short comment */
349 | while (!currIsNewline(ls) && ls->current != EOZ)
350 | next(ls);
351 | continue;
352 | }
353 | case '[': {
354 | int sep = skip_sep(ls);
355 | if (sep >= 0) {
356 | read_long_string(ls, seminfo, sep);
357 | return TK_STRING;
358 | }
359 | else if (sep == -1) return '[';
360 | else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);
361 | }
362 | case '=': {
363 | next(ls);
364 | if (ls->current != '=') return '=';
365 | else { next(ls); return TK_EQ; }
366 | }
367 | case '<': {
368 | next(ls);
369 | if (ls->current != '=') return '<';
370 | else { next(ls); return TK_LE; }
371 | }
372 | case '>': {
373 | next(ls);
374 | if (ls->current != '=') return '>';
375 | else { next(ls); return TK_GE; }
376 | }
377 | case '~': {
378 | next(ls);
379 | if (ls->current != '=') return '~';
380 | else { next(ls); return TK_NE; }
381 | }
382 | case '"':
383 | case '\'': {
384 | read_string(ls, ls->current, seminfo);
385 | return TK_STRING;
386 | }
387 | case '.': {
388 | save_and_next(ls);
389 | if (check_next(ls, ".")) {
390 | if (check_next(ls, "."))
391 | return TK_DOTS; /* ... */
392 | else return TK_CONCAT; /* .. */
393 | }
394 | else if (!isdigit(ls->current)) return '.';
395 | else {
396 | read_numeral(ls, seminfo);
397 | return TK_NUMBER;
398 | }
399 | }
400 | case EOZ: {
401 | return TK_EOS;
402 | }
403 | default: {
404 | if (isspace(ls->current)) {
405 | lua_assert(!currIsNewline(ls));
406 | next(ls);
407 | continue;
408 | }
409 | else if (isdigit(ls->current)) {
410 | read_numeral(ls, seminfo);
411 | return TK_NUMBER;
412 | }
413 | else if (isalpha(ls->current) || ls->current == '_') {
414 | /* identifier or reserved word */
415 | TString *ts;
416 | do {
417 | save_and_next(ls);
418 | } while (isalnum(ls->current) || ls->current == '_');
419 | ts = luaX_newstring(ls, luaZ_buffer(ls->buff),
420 | luaZ_bufflen(ls->buff));
421 | if (ts->tsv.reserved > 0) /* reserved word? */
422 | return ts->tsv.reserved - 1 + FIRST_RESERVED;
423 | else {
424 | seminfo->ts = ts;
425 | return TK_NAME;
426 | }
427 | }
428 | else {
429 | int c = ls->current;
430 | next(ls);
431 | return c; /* single-char tokens (+ - / ...) */
432 | }
433 | }
434 | }
435 | }
436 | }
437 |
438 |
439 | void luaX_next (LexState *ls) {
440 | ls->lastline = ls->linenumber;
441 | if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */
442 | ls->t = ls->lookahead; /* use this one */
443 | ls->lookahead.token = TK_EOS; /* and discharge it */
444 | }
445 | else
446 | ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */
447 | }
448 |
449 |
450 | void luaX_lookahead (LexState *ls) {
451 | lua_assert(ls->lookahead.token == TK_EOS);
452 | ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);
453 | }
454 |
455 |
--------------------------------------------------------------------------------
/mLua/jni/lua/liolib.c:
--------------------------------------------------------------------------------
1 | /*
2 | ** $Id: liolib.c,v 2.73.1.4 2010/05/14 15:33:51 roberto Exp $
3 | ** Standard I/O (and system) library
4 | ** See Copyright Notice in lua.h
5 | */
6 |
7 |
8 | #include
9 | #include
10 | #include
11 | #include
12 |
13 | #define liolib_c
14 | #define LUA_LIB
15 |
16 | #include "lua.h"
17 |
18 | #include "lauxlib.h"
19 | #include "lualib.h"
20 |
21 |
22 |
23 | #define IO_INPUT 1
24 | #define IO_OUTPUT 2
25 |
26 |
27 | static const char *const fnames[] = {"input", "output"};
28 |
29 |
30 | static int pushresult (lua_State *L, int i, const char *filename) {
31 | int en = errno; /* calls to Lua API may change this value */
32 | if (i) {
33 | lua_pushboolean(L, 1);
34 | return 1;
35 | }
36 | else {
37 | lua_pushnil(L);
38 | if (filename)
39 | lua_pushfstring(L, "%s: %s", filename, strerror(en));
40 | else
41 | lua_pushfstring(L, "%s", strerror(en));
42 | lua_pushinteger(L, en);
43 | return 3;
44 | }
45 | }
46 |
47 |
48 | static void fileerror (lua_State *L, int arg, const char *filename) {
49 | lua_pushfstring(L, "%s: %s", filename, strerror(errno));
50 | luaL_argerror(L, arg, lua_tostring(L, -1));
51 | }
52 |
53 |
54 | #define tofilep(L) ((FILE **)luaL_checkudata(L, 1, LUA_FILEHANDLE))
55 |
56 |
57 | static int io_type (lua_State *L) {
58 | void *ud;
59 | luaL_checkany(L, 1);
60 | ud = lua_touserdata(L, 1);
61 | lua_getfield(L, LUA_REGISTRYINDEX, LUA_FILEHANDLE);
62 | if (ud == NULL || !lua_getmetatable(L, 1) || !lua_rawequal(L, -2, -1))
63 | lua_pushnil(L); /* not a file */
64 | else if (*((FILE **)ud) == NULL)
65 | lua_pushliteral(L, "closed file");
66 | else
67 | lua_pushliteral(L, "file");
68 | return 1;
69 | }
70 |
71 |
72 | static FILE *tofile (lua_State *L) {
73 | FILE **f = tofilep(L);
74 | if (*f == NULL)
75 | luaL_error(L, "attempt to use a closed file");
76 | return *f;
77 | }
78 |
79 |
80 |
81 | /*
82 | ** When creating file handles, always creates a `closed' file handle
83 | ** before opening the actual file; so, if there is a memory error, the
84 | ** file is not left opened.
85 | */
86 | static FILE **newfile (lua_State *L) {
87 | FILE **pf = (FILE **)lua_newuserdata(L, sizeof(FILE *));
88 | *pf = NULL; /* file handle is currently `closed' */
89 | luaL_getmetatable(L, LUA_FILEHANDLE);
90 | lua_setmetatable(L, -2);
91 | return pf;
92 | }
93 |
94 |
95 | /*
96 | ** function to (not) close the standard files stdin, stdout, and stderr
97 | */
98 | static int io_noclose (lua_State *L) {
99 | lua_pushnil(L);
100 | lua_pushliteral(L, "cannot close standard file");
101 | return 2;
102 | }
103 |
104 |
105 | /*
106 | ** function to close 'popen' files
107 | */
108 | static int io_pclose (lua_State *L) {
109 | FILE **p = tofilep(L);
110 | int ok = lua_pclose(L, *p);
111 | *p = NULL;
112 | return pushresult(L, ok, NULL);
113 | }
114 |
115 |
116 | /*
117 | ** function to close regular files
118 | */
119 | static int io_fclose (lua_State *L) {
120 | FILE **p = tofilep(L);
121 | int ok = (fclose(*p) == 0);
122 | *p = NULL;
123 | return pushresult(L, ok, NULL);
124 | }
125 |
126 |
127 | static int aux_close (lua_State *L) {
128 | lua_getfenv(L, 1);
129 | lua_getfield(L, -1, "__close");
130 | return (lua_tocfunction(L, -1))(L);
131 | }
132 |
133 |
134 | static int io_close (lua_State *L) {
135 | if (lua_isnone(L, 1))
136 | lua_rawgeti(L, LUA_ENVIRONINDEX, IO_OUTPUT);
137 | tofile(L); /* make sure argument is a file */
138 | return aux_close(L);
139 | }
140 |
141 |
142 | static int io_gc (lua_State *L) {
143 | FILE *f = *tofilep(L);
144 | /* ignore closed files */
145 | if (f != NULL)
146 | aux_close(L);
147 | return 0;
148 | }
149 |
150 |
151 | static int io_tostring (lua_State *L) {
152 | FILE *f = *tofilep(L);
153 | if (f == NULL)
154 | lua_pushliteral(L, "file (closed)");
155 | else
156 | lua_pushfstring(L, "file (%p)", f);
157 | return 1;
158 | }
159 |
160 |
161 | static int io_open (lua_State *L) {
162 | const char *filename = luaL_checkstring(L, 1);
163 | const char *mode = luaL_optstring(L, 2, "r");
164 | FILE **pf = newfile(L);
165 | *pf = fopen(filename, mode);
166 | return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
167 | }
168 |
169 |
170 | /*
171 | ** this function has a separated environment, which defines the
172 | ** correct __close for 'popen' files
173 | */
174 | static int io_popen (lua_State *L) {
175 | const char *filename = luaL_checkstring(L, 1);
176 | const char *mode = luaL_optstring(L, 2, "r");
177 | FILE **pf = newfile(L);
178 | *pf = lua_popen(L, filename, mode);
179 | return (*pf == NULL) ? pushresult(L, 0, filename) : 1;
180 | }
181 |
182 |
183 | static int io_tmpfile (lua_State *L) {
184 | FILE **pf = newfile(L);
185 | *pf = tmpfile();
186 | return (*pf == NULL) ? pushresult(L, 0, NULL) : 1;
187 | }
188 |
189 |
190 | static FILE *getiofile (lua_State *L, int findex) {
191 | FILE *f;
192 | lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
193 | f = *(FILE **)lua_touserdata(L, -1);
194 | if (f == NULL)
195 | luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
196 | return f;
197 | }
198 |
199 |
200 | static int g_iofile (lua_State *L, int f, const char *mode) {
201 | if (!lua_isnoneornil(L, 1)) {
202 | const char *filename = lua_tostring(L, 1);
203 | if (filename) {
204 | FILE **pf = newfile(L);
205 | *pf = fopen(filename, mode);
206 | if (*pf == NULL)
207 | fileerror(L, 1, filename);
208 | }
209 | else {
210 | tofile(L); /* check that it's a valid file handle */
211 | lua_pushvalue(L, 1);
212 | }
213 | lua_rawseti(L, LUA_ENVIRONINDEX, f);
214 | }
215 | /* return current value */
216 | lua_rawgeti(L, LUA_ENVIRONINDEX, f);
217 | return 1;
218 | }
219 |
220 |
221 | static int io_input (lua_State *L) {
222 | return g_iofile(L, IO_INPUT, "r");
223 | }
224 |
225 |
226 | static int io_output (lua_State *L) {
227 | return g_iofile(L, IO_OUTPUT, "w");
228 | }
229 |
230 |
231 | static int io_readline (lua_State *L);
232 |
233 |
234 | static void aux_lines (lua_State *L, int idx, int toclose) {
235 | lua_pushvalue(L, idx);
236 | lua_pushboolean(L, toclose); /* close/not close file when finished */
237 | lua_pushcclosure(L, io_readline, 2);
238 | }
239 |
240 |
241 | static int f_lines (lua_State *L) {
242 | tofile(L); /* check that it's a valid file handle */
243 | aux_lines(L, 1, 0);
244 | return 1;
245 | }
246 |
247 |
248 | static int io_lines (lua_State *L) {
249 | if (lua_isnoneornil(L, 1)) { /* no arguments? */
250 | /* will iterate over default input */
251 | lua_rawgeti(L, LUA_ENVIRONINDEX, IO_INPUT);
252 | return f_lines(L);
253 | }
254 | else {
255 | const char *filename = luaL_checkstring(L, 1);
256 | FILE **pf = newfile(L);
257 | *pf = fopen(filename, "r");
258 | if (*pf == NULL)
259 | fileerror(L, 1, filename);
260 | aux_lines(L, lua_gettop(L), 1);
261 | return 1;
262 | }
263 | }
264 |
265 |
266 | /*
267 | ** {======================================================
268 | ** READ
269 | ** =======================================================
270 | */
271 |
272 |
273 | static int read_number (lua_State *L, FILE *f) {
274 | lua_Number d;
275 | if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
276 | lua_pushnumber(L, d);
277 | return 1;
278 | }
279 | else {
280 | lua_pushnil(L); /* "result" to be removed */
281 | return 0; /* read fails */
282 | }
283 | }
284 |
285 |
286 | static int test_eof (lua_State *L, FILE *f) {
287 | int c = getc(f);
288 | ungetc(c, f);
289 | lua_pushlstring(L, NULL, 0);
290 | return (c != EOF);
291 | }
292 |
293 |
294 | static int read_line (lua_State *L, FILE *f) {
295 | luaL_Buffer b;
296 | luaL_buffinit(L, &b);
297 | for (;;) {
298 | size_t l;
299 | char *p = luaL_prepbuffer(&b);
300 | if (fgets(p, LUAL_BUFFERSIZE, f) == NULL) { /* eof? */
301 | luaL_pushresult(&b); /* close buffer */
302 | return (lua_objlen(L, -1) > 0); /* check whether read something */
303 | }
304 | l = strlen(p);
305 | if (l == 0 || p[l-1] != '\n')
306 | luaL_addsize(&b, l);
307 | else {
308 | luaL_addsize(&b, l - 1); /* do not include `eol' */
309 | luaL_pushresult(&b); /* close buffer */
310 | return 1; /* read at least an `eol' */
311 | }
312 | }
313 | }
314 |
315 |
316 | static int read_chars (lua_State *L, FILE *f, size_t n) {
317 | size_t rlen; /* how much to read */
318 | size_t nr; /* number of chars actually read */
319 | luaL_Buffer b;
320 | luaL_buffinit(L, &b);
321 | rlen = LUAL_BUFFERSIZE; /* try to read that much each time */
322 | do {
323 | char *p = luaL_prepbuffer(&b);
324 | if (rlen > n) rlen = n; /* cannot read more than asked */
325 | nr = fread(p, sizeof(char), rlen, f);
326 | luaL_addsize(&b, nr);
327 | n -= nr; /* still have to read `n' chars */
328 | } while (n > 0 && nr == rlen); /* until end of count or eof */
329 | luaL_pushresult(&b); /* close buffer */
330 | return (n == 0 || lua_objlen(L, -1) > 0);
331 | }
332 |
333 |
334 | static int g_read (lua_State *L, FILE *f, int first) {
335 | int nargs = lua_gettop(L) - 1;
336 | int success;
337 | int n;
338 | clearerr(f);
339 | if (nargs == 0) { /* no arguments? */
340 | success = read_line(L, f);
341 | n = first+1; /* to return 1 result */
342 | }
343 | else { /* ensure stack space for all results and for auxlib's buffer */
344 | luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
345 | success = 1;
346 | for (n = first; nargs-- && success; n++) {
347 | if (lua_type(L, n) == LUA_TNUMBER) {
348 | size_t l = (size_t)lua_tointeger(L, n);
349 | success = (l == 0) ? test_eof(L, f) : read_chars(L, f, l);
350 | }
351 | else {
352 | const char *p = lua_tostring(L, n);
353 | luaL_argcheck(L, p && p[0] == '*', n, "invalid option");
354 | switch (p[1]) {
355 | case 'n': /* number */
356 | success = read_number(L, f);
357 | break;
358 | case 'l': /* line */
359 | success = read_line(L, f);
360 | break;
361 | case 'a': /* file */
362 | read_chars(L, f, ~((size_t)0)); /* read MAX_SIZE_T chars */
363 | success = 1; /* always success */
364 | break;
365 | default:
366 | return luaL_argerror(L, n, "invalid format");
367 | }
368 | }
369 | }
370 | }
371 | if (ferror(f))
372 | return pushresult(L, 0, NULL);
373 | if (!success) {
374 | lua_pop(L, 1); /* remove last result */
375 | lua_pushnil(L); /* push nil instead */
376 | }
377 | return n - first;
378 | }
379 |
380 |
381 | static int io_read (lua_State *L) {
382 | return g_read(L, getiofile(L, IO_INPUT), 1);
383 | }
384 |
385 |
386 | static int f_read (lua_State *L) {
387 | return g_read(L, tofile(L), 2);
388 | }
389 |
390 |
391 | static int io_readline (lua_State *L) {
392 | FILE *f = *(FILE **)lua_touserdata(L, lua_upvalueindex(1));
393 | int sucess;
394 | if (f == NULL) /* file is already closed? */
395 | luaL_error(L, "file is already closed");
396 | sucess = read_line(L, f);
397 | if (ferror(f))
398 | return luaL_error(L, "%s", strerror(errno));
399 | if (sucess) return 1;
400 | else { /* EOF */
401 | if (lua_toboolean(L, lua_upvalueindex(2))) { /* generator created file? */
402 | lua_settop(L, 0);
403 | lua_pushvalue(L, lua_upvalueindex(1));
404 | aux_close(L); /* close it */
405 | }
406 | return 0;
407 | }
408 | }
409 |
410 | /* }====================================================== */
411 |
412 |
413 | static int g_write (lua_State *L, FILE *f, int arg) {
414 | int nargs = lua_gettop(L) - 1;
415 | int status = 1;
416 | for (; nargs--; arg++) {
417 | if (lua_type(L, arg) == LUA_TNUMBER) {
418 | /* optimization: could be done exactly as for strings */
419 | status = status &&
420 | fprintf(f, LUA_NUMBER_FMT, lua_tonumber(L, arg)) > 0;
421 | }
422 | else {
423 | size_t l;
424 | const char *s = luaL_checklstring(L, arg, &l);
425 | status = status && (fwrite(s, sizeof(char), l, f) == l);
426 | }
427 | }
428 | return pushresult(L, status, NULL);
429 | }
430 |
431 |
432 | static int io_write (lua_State *L) {
433 | return g_write(L, getiofile(L, IO_OUTPUT), 1);
434 | }
435 |
436 |
437 | static int f_write (lua_State *L) {
438 | return g_write(L, tofile(L), 2);
439 | }
440 |
441 |
442 | static int f_seek (lua_State *L) {
443 | static const int mode[] = {SEEK_SET, SEEK_CUR, SEEK_END};
444 | static const char *const modenames[] = {"set", "cur", "end", NULL};
445 | FILE *f = tofile(L);
446 | int op = luaL_checkoption(L, 2, "cur", modenames);
447 | long offset = luaL_optlong(L, 3, 0);
448 | op = fseek(f, offset, mode[op]);
449 | if (op)
450 | return pushresult(L, 0, NULL); /* error */
451 | else {
452 | lua_pushinteger(L, ftell(f));
453 | return 1;
454 | }
455 | }
456 |
457 |
458 | static int f_setvbuf (lua_State *L) {
459 | static const int mode[] = {_IONBF, _IOFBF, _IOLBF};
460 | static const char *const modenames[] = {"no", "full", "line", NULL};
461 | FILE *f = tofile(L);
462 | int op = luaL_checkoption(L, 2, NULL, modenames);
463 | lua_Integer sz = luaL_optinteger(L, 3, LUAL_BUFFERSIZE);
464 | int res = setvbuf(f, NULL, mode[op], sz);
465 | return pushresult(L, res == 0, NULL);
466 | }
467 |
468 |
469 |
470 | static int io_flush (lua_State *L) {
471 | return pushresult(L, fflush(getiofile(L, IO_OUTPUT)) == 0, NULL);
472 | }
473 |
474 |
475 | static int f_flush (lua_State *L) {
476 | return pushresult(L, fflush(tofile(L)) == 0, NULL);
477 | }
478 |
479 |
480 | static const luaL_Reg iolib[] = {
481 | {"close", io_close},
482 | {"flush", io_flush},
483 | {"input", io_input},
484 | {"lines", io_lines},
485 | {"open", io_open},
486 | {"output", io_output},
487 | {"popen", io_popen},
488 | {"read", io_read},
489 | {"tmpfile", io_tmpfile},
490 | {"type", io_type},
491 | {"write", io_write},
492 | {NULL, NULL}
493 | };
494 |
495 |
496 | static const luaL_Reg flib[] = {
497 | {"close", io_close},
498 | {"flush", f_flush},
499 | {"lines", f_lines},
500 | {"read", f_read},
501 | {"seek", f_seek},
502 | {"setvbuf", f_setvbuf},
503 | {"write", f_write},
504 | {"__gc", io_gc},
505 | {"__tostring", io_tostring},
506 | {NULL, NULL}
507 | };
508 |
509 |
510 | static void createmeta (lua_State *L) {
511 | luaL_newmetatable(L, LUA_FILEHANDLE); /* create metatable for file handles */
512 | lua_pushvalue(L, -1); /* push metatable */
513 | lua_setfield(L, -2, "__index"); /* metatable.__index = metatable */
514 | luaL_register(L, NULL, flib); /* file methods */
515 | }
516 |
517 |
518 | static void createstdfile (lua_State *L, FILE *f, int k, const char *fname) {
519 | *newfile(L) = f;
520 | if (k > 0) {
521 | lua_pushvalue(L, -1);
522 | lua_rawseti(L, LUA_ENVIRONINDEX, k);
523 | }
524 | lua_pushvalue(L, -2); /* copy environment */
525 | lua_setfenv(L, -2); /* set it */
526 | lua_setfield(L, -3, fname);
527 | }
528 |
529 |
530 | static void newfenv (lua_State *L, lua_CFunction cls) {
531 | lua_createtable(L, 0, 1);
532 | lua_pushcfunction(L, cls);
533 | lua_setfield(L, -2, "__close");
534 | }
535 |
536 |
537 | LUALIB_API int luaopen_io (lua_State *L) {
538 | createmeta(L);
539 | /* create (private) environment (with fields IO_INPUT, IO_OUTPUT, __close) */
540 | newfenv(L, io_fclose);
541 | lua_replace(L, LUA_ENVIRONINDEX);
542 | /* open library */
543 | luaL_register(L, LUA_IOLIBNAME, iolib);
544 | /* create (and set) default files */
545 | newfenv(L, io_noclose); /* close function for default files */
546 | createstdfile(L, stdin, IO_INPUT, "stdin");
547 | createstdfile(L, stdout, IO_OUTPUT, "stdout");
548 | createstdfile(L, stderr, 0, "stderr");
549 | lua_pop(L, 1); /* pop environment for default files */
550 | lua_getfield(L, -1, "popen");
551 | newfenv(L, io_pclose); /* create environment for 'popen' */
552 | lua_setfenv(L, -2); /* set fenv for 'popen' */
553 | lua_pop(L, 1); /* pop 'popen' */
554 | return 1;
555 | }
556 |
557 |
--------------------------------------------------------------------------------