CHDK_DE Vorschauversion  Trunk Rev. 5163
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
lua.c-Dateireferenz
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"
+ Include-Abhängigkeitsdiagramm für lua.c:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  Smain
 

Makrodefinitionen

#define lua_c
 
#define notail(x)   {if ((x)[2] != '\0') return -1;}
 

Funktionen

static void lstop (lua_State *L, lua_Debug *ar)
 
static void laction (int i)
 
static void print_usage (void)
 
static void l_message (const char *pname, const char *msg)
 
static int report (lua_State *L, int status)
 
static int traceback (lua_State *L)
 
static int docall (lua_State *L, int narg, int clear)
 
static void print_version (void)
 
static int getargs (lua_State *L, char **argv, int n)
 
static int dofile (lua_State *L, const char *name)
 
static int dostring (lua_State *L, const char *s, const char *name)
 
static int dolibrary (lua_State *L, const char *name)
 
static const char * get_prompt (lua_State *L, int firstline)
 
static int incomplete (lua_State *L, int status)
 
static int pushline (lua_State *L, int firstline)
 
static int loadline (lua_State *L)
 
static void dotty (lua_State *L)
 
static int handle_script (lua_State *L, char **argv, int n)
 
static int collectargs (char **argv, int *pi, int *pv, int *pe)
 
static int runargs (lua_State *L, char **argv, int n)
 
static int handle_luainit (lua_State *L)
 
static int pmain (lua_State *L)
 
int main (int argc, char **argv)
 

Variablen

static lua_StateglobalL = NULL
 
static const char * progname = LUA_PROGNAME
 

Makro-Dokumentation

#define lua_c

Definiert in Zeile 13 der Datei lua.c.

#define notail (   x)    {if ((x)[2] != '\0') return -1;}

Definiert in Zeile 258 der Datei lua.c.

Dokumentation der Funktionen

static int collectargs ( char **  argv,
int *  pi,
int *  pv,
int *  pe 
)
static

Definiert in Zeile 261 der Datei lua.c.

261  {
262  int i;
263  for (i = 1; argv[i] != NULL; i++) {
264  if (argv[i][0] != '-') /* not an option? */
265  return i;
266  switch (argv[i][1]) { /* option */
267  case '-':
268  notail(argv[i]);
269  return (argv[i+1] != NULL ? i+1 : 0);
270  case '\0':
271  return i;
272  case 'i':
273  notail(argv[i]);
274  *pi = 1; /* go through */
275  case 'v':
276  notail(argv[i]);
277  *pv = 1;
278  break;
279  case 'e':
280  *pe = 1; /* go through */
281  case 'l':
282  if (argv[i][2] == '\0') {
283  i++;
284  if (argv[i] == NULL) return -1;
285  }
286  break;
287  default: return -1; /* invalid option */
288  }
289  }
290  return 0;
291 }
static int docall ( lua_State L,
int  narg,
int  clear 
)
static

Definiert in Zeile 96 der Datei lua.c.

96  {
97  int status;
98  int base = lua_gettop(L) - narg; /* function index */
99  lua_pushcfunction(L, traceback); /* push traceback function */
100  lua_insert(L, base); /* put it under chunk and args */
101  signal(SIGINT, laction);
102  status = lua_pcall(L, narg, (clear ? 0 : LUA_MULTRET), base);
103  signal(SIGINT, SIG_DFL);
104  lua_remove(L, base); /* remove traceback function */
105  /* force a complete garbage collection in case of errors */
106  if (status != 0) lua_gc(L, LUA_GCCOLLECT, 0);
107  return status;
108 }
static int dofile ( lua_State L,
const char *  name 
)
static

Definiert in Zeile 134 der Datei lua.c.

134  {
135  int status = luaL_loadfile(L, name) || docall(L, 0, 1);
136  return report(L, status);
137 }
static int dolibrary ( lua_State L,
const char *  name 
)
static

Definiert in Zeile 146 der Datei lua.c.

146  {
147  lua_getglobal(L, "require");
148  lua_pushstring(L, name);
149  return report(L, docall(L, 1, 1));
150 }
static int dostring ( lua_State L,
const char *  s,
const char *  name 
)
static

Definiert in Zeile 140 der Datei lua.c.

140  {
141  int status = luaL_loadbuffer(L, s, strlen(s), name) || docall(L, 0, 1);
142  return report(L, status);
143 }
static void dotty ( lua_State L)
static

Definiert in Zeile 216 der Datei lua.c.

216  {
217  int status;
218  const char *oldprogname = progname;
219  progname = NULL;
220  while ((status = loadline(L)) != -1) {
221  if (status == 0) status = docall(L, 0, 0);
222  report(L, status);
223  if (status == 0 && lua_gettop(L) > 0) { /* any result to print? */
224  lua_getglobal(L, "print");
225  lua_insert(L, 1);
226  if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
228  "error calling " LUA_QL("print") " (%s)",
229  lua_tostring(L, -1)));
230  }
231  }
232  lua_settop(L, 0); /* clear stack */
233  fputs("\n", stdout);
234  fflush(stdout);
235  progname = oldprogname;
236 }
static const char* get_prompt ( lua_State L,
int  firstline 
)
static

Definiert in Zeile 153 der Datei lua.c.

153  {
154  const char *p;
155  lua_getfield(L, LUA_GLOBALSINDEX, firstline ? "_PROMPT" : "_PROMPT2");
156  p = lua_tostring(L, -1);
157  if (p == NULL) p = (firstline ? LUA_PROMPT : LUA_PROMPT2);
158  lua_pop(L, 1); /* remove global */
159  return p;
160 }
static int getargs ( lua_State L,
char **  argv,
int  n 
)
static

Definiert in Zeile 116 der Datei lua.c.

116  {
117  int narg;
118  int i;
119  int argc = 0;
120  while (argv[argc]) argc++; /* count total number of arguments */
121  narg = argc - (n + 1); /* number of arguments to the script */
122  luaL_checkstack(L, narg + 3, "too many arguments to script");
123  for (i=n+1; i < argc; i++)
124  lua_pushstring(L, argv[i]);
125  lua_createtable(L, narg, n + 1);
126  for (i=0; i < argc; i++) {
127  lua_pushstring(L, argv[i]);
128  lua_rawseti(L, -2, i - n);
129  }
130  return narg;
131 }
static int handle_luainit ( lua_State L)
static

Definiert in Zeile 323 der Datei lua.c.

323  {
324  const char *init = getenv(LUA_INIT);
325  if (init == NULL) return 0; /* status OK */
326  else if (init[0] == '@')
327  return dofile(L, init+1);
328  else
329  return dostring(L, init, "=" LUA_INIT);
330 }
static int handle_script ( lua_State L,
char **  argv,
int  n 
)
static

Definiert in Zeile 239 der Datei lua.c.

239  {
240  int status;
241  const char *fname;
242  int narg = getargs(L, argv, n); /* collect arguments */
243  lua_setglobal(L, "arg");
244  fname = argv[n];
245  if (strcmp(fname, "-") == 0 && strcmp(argv[n-1], "--") != 0)
246  fname = NULL; /* stdin */
247  status = luaL_loadfile(L, fname);
248  lua_insert(L, -(narg+1));
249  if (status == 0)
250  status = docall(L, narg, 0);
251  else
252  lua_pop(L, narg);
253  return report(L, status);
254 }
static int incomplete ( lua_State L,
int  status 
)
static

Definiert in Zeile 163 der Datei lua.c.

163  {
164  if (status == LUA_ERRSYNTAX) {
165  size_t lmsg;
166  const char *msg = lua_tolstring(L, -1, &lmsg);
167  const char *tp = msg + lmsg - (sizeof(LUA_QL("<eof>")) - 1);
168  if (strstr(msg, LUA_QL("<eof>")) == tp) {
169  lua_pop(L, 1);
170  return 1;
171  }
172  }
173  return 0; /* else... */
174 }
static void l_message ( const char *  pname,
const char *  msg 
)
static

Definiert in Zeile 58 der Datei lua.c.

58  {
59  if (pname) fprintf(stderr, "%s: ", pname);
60  fprintf(stderr, "%s\n", msg);
61  fflush(stderr);
62 }
static void laction ( int  i)
static

Definiert in Zeile 35 der Datei lua.c.

35  {
36  signal(i, SIG_DFL); /* if another SIGINT happens before lstop,
37  terminate process (default action) */
39 }
static int loadline ( lua_State L)
static

Definiert in Zeile 196 der Datei lua.c.

196  {
197  int status;
198  lua_settop(L, 0);
199  if (!pushline(L, 1))
200  return -1; /* no input */
201  for (;;) { /* repeat until gets a complete line */
202  status = luaL_loadbuffer(L, lua_tostring(L, 1), lua_strlen(L, 1), "=stdin");
203  if (!incomplete(L, status)) break; /* cannot try to add lines? */
204  if (!pushline(L, 0)) /* no more input? */
205  return -1;
206  lua_pushliteral(L, "\n"); /* add a new line... */
207  lua_insert(L, -2); /* ...between the two lines */
208  lua_concat(L, 3); /* join them */
209  }
210  lua_saveline(L, 1);
211  lua_remove(L, 1); /* remove line */
212  return status;
213 }
static void lstop ( lua_State L,
lua_Debug ar 
)
static

Definiert in Zeile 28 der Datei lua.c.

28  {
29  (void)ar; /* unused arg. */
30  lua_sethook(L, NULL, 0, 0);
31  luaL_error(L, "interrupted!");
32 }
int main ( int  argc,
char **  argv 
)

Definiert in Zeile 377 der Datei lua.c.

377  {
378  int status;
379  struct Smain s;
380  lua_State *L = lua_open(); /* create state */
381  if (L == NULL) {
382  l_message(argv[0], "cannot create state: not enough memory");
383  return EXIT_FAILURE;
384  }
385  s.argc = argc;
386  s.argv = argv;
387  status = lua_cpcall(L, &pmain, &s);
388  report(L, status);
389  lua_close(L);
390  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
391 }
static int pmain ( lua_State L)
static

Definiert in Zeile 340 der Datei lua.c.

340  {
341  struct Smain *s = (struct Smain *)lua_touserdata(L, 1);
342  char **argv = s->argv;
343  int script;
344  int has_i = 0, has_v = 0, has_e = 0;
345  globalL = L;
346  if (argv[0] && argv[0][0]) progname = argv[0];
347  lua_gc(L, LUA_GCSTOP, 0); /* stop collector during initialization */
348  luaL_openlibs(L); /* open libraries */
349  lua_gc(L, LUA_GCRESTART, 0);
350  s->status = handle_luainit(L);
351  if (s->status != 0) return 0;
352  script = collectargs(argv, &has_i, &has_v, &has_e);
353  if (script < 0) { /* invalid args? */
354  print_usage();
355  s->status = 1;
356  return 0;
357  }
358  if (has_v) print_version();
359  s->status = runargs(L, argv, (script > 0) ? script : s->argc);
360  if (s->status != 0) return 0;
361  if (script)
362  s->status = handle_script(L, argv, script);
363  if (s->status != 0) return 0;
364  if (has_i)
365  dotty(L);
366  else if (script == 0 && !has_e && !has_v) {
367  if (lua_stdin_is_tty()) {
368  print_version();
369  dotty(L);
370  }
371  else dofile(L, NULL); /* executes stdin as a file */
372  }
373  return 0;
374 }
static void print_usage ( void  )
static

Definiert in Zeile 42 der Datei lua.c.

42  {
43  fprintf(stderr,
44  "usage: %s [options] [script [args]].\n"
45  "Available options are:\n"
46  " -e stat execute string " LUA_QL("stat") "\n"
47  " -l name require library " LUA_QL("name") "\n"
48  " -i enter interactive mode after executing " LUA_QL("script") "\n"
49  " -v show version information\n"
50  " -- stop handling options\n"
51  " - execute stdin and stop handling options\n"
52  ,
53  progname);
54  fflush(stderr);
55 }
static void print_version ( void  )
static

Definiert in Zeile 111 der Datei lua.c.

111  {
113 }
static int pushline ( lua_State L,
int  firstline 
)
static

Definiert in Zeile 177 der Datei lua.c.

177  {
178  char buffer[LUA_MAXINPUT];
179  char *b = buffer;
180  size_t l;
181  const char *prmt = get_prompt(L, firstline);
182  if (lua_readline(L, b, prmt) == 0)
183  return 0; /* no input */
184  l = strlen(b);
185  if (l > 0 && b[l-1] == '\n') /* line ends with newline? */
186  b[l-1] = '\0'; /* remove it */
187  if (firstline && b[0] == '=') /* first line starts with `=' ? */
188  lua_pushfstring(L, "return %s", b+1); /* change it to `return' */
189  else
190  lua_pushstring(L, b);
191  lua_freeline(L, b);
192  return 1;
193 }
static int report ( lua_State L,
int  status 
)
static

Definiert in Zeile 65 der Datei lua.c.

65  {
66  if (status && !lua_isnil(L, -1)) {
67  const char *msg = lua_tostring(L, -1);
68  if (msg == NULL) msg = "(error object is not a string)";
69  l_message(progname, msg);
70  lua_pop(L, 1);
71  }
72  return status;
73 }
static int runargs ( lua_State L,
char **  argv,
int  n 
)
static

Definiert in Zeile 294 der Datei lua.c.

294  {
295  int i;
296  for (i = 1; i < n; i++) {
297  if (argv[i] == NULL) continue;
298  lua_assert(argv[i][0] == '-');
299  switch (argv[i][1]) { /* option */
300  case 'e': {
301  const char *chunk = argv[i] + 2;
302  if (*chunk == '\0') chunk = argv[++i];
303  lua_assert(chunk != NULL);
304  if (dostring(L, chunk, "=(command line)") != 0)
305  return 1;
306  break;
307  }
308  case 'l': {
309  const char *filename = argv[i] + 2;
310  if (*filename == '\0') filename = argv[++i];
311  lua_assert(filename != NULL);
312  if (dolibrary(L, filename))
313  return 1; /* stop if file fails */
314  break;
315  }
316  default: break;
317  }
318  }
319  return 0;
320 }
static int traceback ( lua_State L)
static

Definiert in Zeile 76 der Datei lua.c.

76  {
77  if (!lua_isstring(L, 1)) /* 'message' not a string? */
78  return 1; /* keep it intact */
79  lua_getfield(L, LUA_GLOBALSINDEX, "debug");
80  if (!lua_istable(L, -1)) {
81  lua_pop(L, 1);
82  return 1;
83  }
84  lua_getfield(L, -1, "traceback");
85  if (!lua_isfunction(L, -1)) {
86  lua_pop(L, 2);
87  return 1;
88  }
89  lua_pushvalue(L, 1); /* pass error message */
90  lua_pushinteger(L, 2); /* skip this function and traceback */
91  lua_call(L, 2, 1); /* call debug.traceback */
92  return 1;
93 }

Variablen-Dokumentation

lua_State* globalL = NULL
static

Definiert in Zeile 22 der Datei lua.c.

const char* progname = LUA_PROGNAME
static

Definiert in Zeile 24 der Datei lua.c.