/
lua_glue.c
532 lines (437 loc) · 15.4 KB
1
#include "universal.h"
2
#include "lua_glue.h"
3
#include "platform.h"
4
5
6
7
#include "fileio.h"
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
8
#include "gui.h"
9
10
11
12
13
#define MOJOSETUP_NAMESPACE "MojoSetup"
static lua_State *luaState = NULL;
14
15
16
17
18
19
20
21
22
23
24
25
// Allocator interface for internal Lua use.
static void *MojoLua_alloc(void *ud, void *ptr, size_t osize, size_t nsize)
{
if (nsize == 0)
{
free(ptr);
return NULL;
} // if
return xrealloc(ptr, nsize);
} // MojoLua_alloc
26
27
28
29
// Read data from a MojoInput when loading Lua code.
static const char *MojoLua_reader(lua_State *L, void *data, size_t *size)
{
MojoInput *in = (MojoInput *) data;
30
char *retval = (char *) scratchbuf_128k;
31
32
33
34
35
36
37
38
39
40
41
42
int64 br = in->read(in, scratchbuf_128k, sizeof (scratchbuf_128k));
if (br <= 0) // eof or error? (lua doesn't care which?!)
{
br = 0;
retval = NULL;
} // if
*size = (size_t) br;
return retval;
} // MojoLua_reader
43
44
45
46
47
48
49
50
51
52
53
54
55
static inline int snprintfcat(char **ptr, size_t *len, const char *fmt, ...)
{
int bw = 0;
va_list ap;
va_start(ap, fmt);
bw = vsnprintf(*ptr, *len, fmt, ap);
va_end(ap);
*ptr += bw;
*len -= bw;
return bw;
} // snprintfcat
56
57
58
59
60
61
62
static int luahook_stackwalk(lua_State *L)
{
const char *errstr = lua_tostring(L, 1);
lua_Debug ldbg;
int i = 0;
if (errstr != NULL)
63
logDebug("%s\n", errstr);
64
65
logDebug("Lua stack backtrace:");
66
67
68
69
// start at 1 to skip this function.
for (i = 1; lua_getstack(L, i, &ldbg); i++)
{
70
71
72
char *ptr = (char *) scratchbuf_128k;
size_t len = sizeof (scratchbuf_128k);
int bw = snprintfcat(&ptr, &len, "#%d", i-1);
73
74
75
const int maxspacing = 4;
int spacing = maxspacing - bw;
while (spacing-- > 0)
76
snprintfcat(&ptr, &len, " ");
77
78
79
if (!lua_getinfo(L, "nSl", &ldbg))
{
80
81
snprintfcat(&ptr, &len, "???\n");
logDebug((const char *) scratchbuf_128k);
82
83
84
85
continue;
} // if
if (ldbg.namewhat[0])
86
snprintfcat(&ptr, &len, "%s ", ldbg.namewhat);
87
88
if ((ldbg.name) && (ldbg.name[0]))
89
snprintfcat(&ptr, &len, "function %s ()", ldbg.name);
90
91
92
else
{
if (strcmp(ldbg.what, "main") == 0)
93
snprintfcat(&ptr, &len, "mainline of chunk");
94
else if (strcmp(ldbg.what, "tail") == 0)
95
snprintfcat(&ptr, &len, "tail call");
96
else
97
snprintfcat(&ptr, &len, "unidentifiable function");
98
99
} // if
100
101
102
103
logDebug((const char *) scratchbuf_128k);
ptr = (char *) scratchbuf_128k;
len = sizeof (scratchbuf_128k);
104
for (spacing = 0; spacing < maxspacing; spacing++)
105
snprintfcat(&ptr, &len, " ");
106
107
if (strcmp(ldbg.what, "C") == 0)
108
snprintfcat(&ptr, &len, "in native code");
109
else if (strcmp(ldbg.what, "tail") == 0)
110
snprintfcat(&ptr, &len, "in Lua code");
111
112
else if ( (strcmp(ldbg.source, "=?") == 0) && (ldbg.currentline == 0) )
snprintfcat(&ptr, &len, "in Lua code (debug info stripped)");
113
114
else
{
115
snprintfcat(&ptr, &len, "in Lua code at %s", ldbg.source);
116
if (ldbg.currentline != -1)
117
snprintfcat(&ptr, &len, ":%d", ldbg.currentline);
118
} // else
119
logDebug((const char *) scratchbuf_128k);
120
121
122
123
124
125
126
} // for
lua_pushstring(L, errstr ? errstr : "");
return 1;
} // luahook_stackwalk
127
128
boolean MojoLua_runFile(const char *basefname)
{
129
130
MojoArchive *ar = GBaseArchive; // in case we want to generalize later.
const MojoArchiveEntryInfo *entinfo;
131
boolean retval = false;
132
133
char clua[128]; // compiled filename.
char ulua[128]; // uncompiled filename.
134
135
136
int rc = 0;
MojoInput *io = NULL;
137
138
if (snprintf(clua, sizeof (clua), "%s.luac", basefname) >= sizeof (clua))
return false;
139
140
141
142
143
if (snprintf(ulua, sizeof (ulua), "%s.lua", basefname) >= sizeof (ulua))
return false;
if (ar->enumerate(ar, "lua"))
144
{
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
while ((entinfo = ar->enumNext(ar)) != NULL)
{
boolean match = (strcmp(entinfo->filename, clua) == 0);
#if !DISABLE_LUA_PARSER
if (!match)
match = (strcmp(entinfo->filename, ulua) == 0);
#endif
if (match)
{
if (entinfo->type == MOJOARCHIVE_ENTRY_FILE)
io = ar->openCurrentEntry(ar);
break;
} // if
} // while
160
161
162
163
} // if
if (io != NULL)
{
164
lua_pushcfunction(luaState, luahook_stackwalk);
165
rc = lua_load(luaState, MojoLua_reader, io, entinfo->filename);
166
167
168
169
170
171
172
io->close(io);
if (rc != 0)
lua_error(luaState);
else
{
// Call new chunk on top of the stack (lua_call will pop it off).
173
174
175
176
if (lua_pcall(luaState, 0, 0, -2) != 0) // retvals are dumped.
lua_error(luaState); // error on stack has debug info.
else
retval = true; // if this didn't panic, we succeeded.
177
} // if
178
lua_pop(luaState, 1); // dump stackwalker.
179
180
181
182
183
184
} // if
return retval;
} // MojoLua_runFile
185
186
187
void MojoLua_collectGarbage(void)
{
lua_State *L = luaState;
188
uint32 ticks = 0;
189
190
191
192
int pre = 0;
int post = 0;
pre = (lua_gc(L, LUA_GCCOUNT, 0) * 1024) + lua_gc(L, LUA_GCCOUNTB, 0);
193
logDebug("Collecting garbage (currently using %d bytes).", pre);
194
ticks = MojoPlatform_ticks();
195
lua_gc (L, LUA_GCCOLLECT, 0);
196
profile("Garbage collection", ticks);
197
post = (lua_gc(L, LUA_GCCOUNT, 0) * 1024) + lua_gc(L, LUA_GCCOUNTB, 0);
198
logDebug("Now using %d bytes (%d bytes savings).\n", post, pre - post);
199
200
201
} // MojoLua_collectGarbage
202
203
204
205
206
207
208
209
210
static inline void pushStringOrNil(lua_State *L, const char *str)
{
if (str != NULL)
lua_pushstring(L, str);
else
lua_pushnil(L);
} // pushStringOrNil
211
212
213
214
215
// Since localization is kept in Lua tables, I stuck this in the Lua glue.
const char *translate(const char *str)
{
const char *retval = str;
216
if (luaState != NULL) // No translations before Lua is initialized.
217
{
218
if (lua_checkstack(luaState, 3))
219
{
220
221
222
int popcount = 0;
lua_getglobal(luaState, MOJOSETUP_NAMESPACE); popcount++;
if (lua_istable(luaState, -1)) // namespace is sane?
223
{
224
225
lua_getfield(luaState, -1, "translations"); popcount++;
if (lua_istable(luaState, -1)) // translation table is sane?
226
{
227
228
229
230
231
const char *tr = NULL;
lua_getfield(luaState, -1, str); popcount++;
tr = lua_tostring(luaState, -1);
if (tr != NULL) // translated for this locale?
{
232
233
234
char *dst = (char *) scratchbuf_128k;
xstrncpy(dst, tr, sizeof(scratchbuf_128k));
retval = dst;
235
} // if
236
} // if
237
} // if
238
lua_pop(luaState, popcount); // remove our stack salsa.
239
240
241
242
243
244
245
246
} // if
} // if
return retval;
} // translate
// Hook into our error handling in case Lua throws a runtime error.
247
static int luahook_panic(lua_State *L)
248
{
249
250
const char *errstr = lua_tostring(L, 1);
if (errstr == NULL)
251
errstr = _("Unknown error");
252
return fatal(errstr); // doesn't actually return.
253
} // luahook_panic
254
255
256
257
258
259
260
261
262
263
264
// Use this instead of Lua's error() function if you don't have a
// programatic error, so you don't get stack callback stuff:
// MojoSetup.fatal("You need the base game to install this expansion pack.")
// Doesn't actually return.
static int luahook_fatal(lua_State *L)
{
const char *err = luaL_checkstring(L, 1);
fatal(err);
return 0;
265
} // luahook_fatal
266
267
268
269
270
271
272
273
274
275
276
277
// Lua interface to MojoLua_runFile(). This is needed instead of Lua's
// require(), since it can access scripts inside an archive.
static int luahook_runfile(lua_State *L)
{
const char *fname = luaL_checkstring(L, 1);
lua_pushboolean(L, MojoLua_runFile(fname));
return 1;
} // luahook_runfile
278
279
280
281
282
283
284
285
286
// Lua interface to translate().
static int luahook_translate(lua_State *L)
{
const char *str = luaL_checkstring(L, 1);
lua_pushstring(L, translate(str));
return 1;
} // luahook_translate
287
288
289
290
291
292
293
static int luahook_ticks(lua_State *L)
{
lua_pushnumber(L, MojoPlatform_ticks());
return 1;
} // luahook_ticks
294
295
296
297
298
299
static int luahook_msgbox(lua_State *L)
{
if (GGui != NULL)
{
const char *title = luaL_checkstring(L, 1);
const char *text = luaL_checkstring(L, 2);
300
GGui->msgbox(title, text);
301
302
303
304
305
306
307
308
309
310
311
312
} // if
return 0;
} // luahook_msgbox
static int luahook_promptyn(lua_State *L)
{
boolean rc = false;
if (GGui != NULL)
{
const char *title = luaL_checkstring(L, 1);
const char *text = luaL_checkstring(L, 2);
313
rc = GGui->promptyn(title, text);
314
315
316
317
318
319
320
} // if
lua_pushboolean(L, rc);
return 1;
} // luahook_msgbox
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
static int luahook_logwarning(lua_State *L)
{
logWarning(luaL_checkstring(L, 1));
return 0;
} // luahook_logwarning
static int luahook_logerror(lua_State *L)
{
logError(luaL_checkstring(L, 1));
return 0;
} // luahook_logerror
static int luahook_loginfo(lua_State *L)
{
logInfo(luaL_checkstring(L, 1));
return 0;
} // luahook_loginfo
static int luahook_logdebug(lua_State *L)
{
logDebug(luaL_checkstring(L, 1));
return 0;
} // luahook_logdebug
static int luahook_cmdline(lua_State *L)
{
const char *arg = luaL_checkstring(L, 1);
lua_pushboolean(L, cmdline(arg));
return 1;
} // luahook_cmdline
static int luahook_cmdlinestr(lua_State *L)
{
int argc = lua_gettop(L);
const char *arg = luaL_checkstring(L, 1);
const char *envr = (argc < 2) ? NULL : lua_tostring(L, 2);
const char *deflt = (argc < 3) ? NULL : lua_tostring(L, 3);
pushStringOrNil(L, cmdlinestr(arg, envr, deflt));
return 1;
} // luahook_cmdlinestr
368
369
370
371
372
373
374
375
// Sets t[sym]=f, where t is on the top of the Lua stack.
static inline void set_cfunc(lua_State *L, lua_CFunction f, const char *sym)
{
lua_pushcfunction(luaState, f);
lua_setfield(luaState, -2, sym);
} // set_cfunc
376
377
378
379
380
381
382
// Sets t[sym]=f, where t is on the top of the Lua stack.
static inline void set_string(lua_State *L, const char *str, const char *sym)
{
lua_pushstring(luaState, str);
lua_setfield(luaState, -2, sym);
} // set_string
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
static inline void set_string_array(lua_State *L, int argc, const char **argv,
const char *sym)
{
int i;
lua_newtable(luaState);
for (i = 0; i < argc; i++)
{
lua_pushinteger(luaState, i+1); // lua is option base 1!
lua_pushstring(luaState, argv[i]);
lua_settable(luaState, -3);
} // for
lua_setfield(luaState, -2, sym);
} // set_string_array
void MojoLua_setString(const char *str, const char *sym)
{
lua_getglobal(luaState, MOJOSETUP_NAMESPACE);
set_string(luaState, str, sym);
lua_pop(luaState, 1);
} // MojoLua_setString
void MojoLua_setStringArray(int argc, const char **argv, const char *sym)
{
lua_getglobal(luaState, MOJOSETUP_NAMESPACE);
set_string_array(luaState, argc, argv, sym);
lua_pop(luaState, 1);
} // MojoLua_setStringArray
413
414
415
boolean MojoLua_initLua(void)
{
416
char locale[16];
417
418
char ostype[64];
char osversion[64];
419
420
421
if (!MojoPlatform_locale(locale, sizeof (locale)))
xstrncpy(locale, "???", sizeof (locale));
422
423
424
425
426
427
if (!MojoPlatform_osType(ostype, sizeof (ostype)))
xstrncpy(ostype, "???", sizeof (ostype));
if (!MojoPlatform_osVersion(osversion, sizeof (osversion)))
xstrncpy(osversion, "???", sizeof (osversion));
assert(luaState == NULL);
428
429
luaState = lua_newstate(MojoLua_alloc, NULL);
430
431
432
if (luaState == NULL)
return false;
433
lua_atpanic(luaState, luahook_panic);
434
435
436
437
438
439
440
441
442
443
444
445
if (!lua_checkstack(luaState, 20)) // Just in case.
{
lua_close(luaState);
luaState = NULL;
return false;
} // if
luaL_openlibs(luaState);
// Build MojoSetup namespace for Lua to access and fill in C bridges...
lua_newtable(luaState);
446
// Set up initial C functions, etc we want to expose to Lua code...
447
set_cfunc(luaState, luahook_runfile, "runfile");
448
set_cfunc(luaState, luahook_translate, "translate");
449
set_cfunc(luaState, luahook_ticks, "ticks");
450
451
452
set_cfunc(luaState, luahook_fatal, "fatal");
set_cfunc(luaState, luahook_msgbox, "msgbox");
set_cfunc(luaState, luahook_promptyn, "promptyn");
453
set_cfunc(luaState, luahook_stackwalk, "stackwalk");
454
455
456
457
458
459
set_cfunc(luaState, luahook_logwarning, "logwarning");
set_cfunc(luaState, luahook_logerror, "logerror");
set_cfunc(luaState, luahook_loginfo, "loginfo");
set_cfunc(luaState, luahook_logdebug, "logdebug");
set_cfunc(luaState, luahook_cmdline, "cmdline");
set_cfunc(luaState, luahook_cmdlinestr, "cmdlinestr");
460
set_string(luaState, locale, "locale");
461
462
463
464
set_string(luaState, PLATFORM_NAME, "platform");
set_string(luaState, PLATFORM_ARCH, "arch");
set_string(luaState, ostype, "ostype");
set_string(luaState, osversion, "osversion");
465
set_string(luaState, GBuildVer, "buildver");
466
set_string(luaState, GLuaLicense, "lualicense");
467
set_string_array(luaState, GArgc, GArgv, "argv");
468
lua_setglobal(luaState, MOJOSETUP_NAMESPACE);
469
470
// Set up localization table, if possible.
471
MojoLua_runFile("localization");
472
473
474
475
// Transfer control to Lua to setup some APIs and state...
if (!MojoLua_runFile("mojosetup_init"))
return false;
476
477
// ...and run the installer-specific config file.
478
479
480
if (!MojoLua_runFile("config"))
return false;
481
482
483
484
485
486
487
488
489
490
491
492
// We don't need the MojoSetup.schema namespace anymore. Make it
// eligible for garbage collection.
lua_getglobal(luaState, MOJOSETUP_NAMESPACE);
if (lua_istable(luaState, -1))
{
lua_pushnil(luaState);
lua_setfield(luaState, -2, "schema");
} // if
lua_pop(luaState, 1);
MojoLua_collectGarbage(); // get rid of old init crap we don't need.
493
494
495
496
497
498
499
500
501
502
503
504
505
return true;
} // MojoLua_initLua
void MojoLua_deinitLua(void)
{
if (luaState != NULL)
{
lua_close(luaState);
luaState = NULL;
} // if
} // MojoLua_deinitLua
506
507
const char *GLuaLicense =
508
509
"Lua:\n"
"\n"
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
"Copyright (C) 1994-2006 Lua.org, PUC-Rio.\n"
"\n"
"Permission is hereby granted, free of charge, to any person obtaining a copy\n"
"of this software and associated documentation files (the \"Software\"), to deal\n"
"in the Software without restriction, including without limitation the rights\n"
"to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n"
"copies of the Software, and to permit persons to whom the Software is\n"
"furnished to do so, subject to the following conditions:\n"
"\n"
"The above copyright notice and this permission notice shall be included in\n"
"all copies or substantial portions of the Software.\n"
"\n"
"THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n"
"IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n"
"FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n"
"AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n"
"LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n"
"OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n"
"THE SOFTWARE.\n"
"\n";
531
// end of lua_glue.c ...