768ea981d871306d4c7fa2528e4ab3bf4ae29b41
[olsrd.git] / lib / tas / src / lua / llex.c
1
2 /*
3 ** $Id: llex.c,v 1.119 2003/03/24 12:39:34 roberto Exp $
4 ** Lexical Analyzer
5 ** See Copyright Notice in lua.h
6 */
7
8
9 #include <ctype.h>
10 #include <string.h>
11
12 #define llex_c
13
14 #include "lua.h"
15
16 #include "ldo.h"
17 #include "llex.h"
18 #include "lobject.h"
19 #include "lparser.h"
20 #include "lstate.h"
21 #include "lstring.h"
22 #include "lzio.h"
23
24
25
26 #define next(LS) (LS->current = zgetc(LS->z))
27
28 static void luaX_error(LexState * ls, const char *s, const char *token) __attribute__ ((noreturn));
29 static void luaX_lexerror(LexState * ls, const char *s, int token) __attribute__ ((noreturn));
30
31
32 /* ORDER RESERVED */
33 static const char *const token2string[] = {
34   "and", "break", "do", "else", "elseif",
35   "end", "false", "for", "function", "if",
36   "in", "local", "nil", "not", "or", "repeat",
37   "return", "then", "true", "until", "while", "*name",
38   "..", "...", "==", ">=", "<=", "~=",
39   "*number", "*string", "<eof>"
40 };
41
42
43 void
44 luaX_init(lua_State * L)
45 {
46   int i;
47   for (i = 0; i < NUM_RESERVED; i++) {
48     TString *ts = luaS_new(L, token2string[i]);
49     luaS_fix(ts);               /* reserved words are never collected */
50     lua_assert(strlen(token2string[i]) + 1 <= TOKEN_LEN);
51     ts->tsv.reserved = cast(lu_byte, i + 1);    /* reserved word */
52   }
53 }
54
55
56 #define MAXSRC          80
57
58
59 void
60 luaX_checklimit(LexState * ls, int val, int limit, const char *msg)
61 {
62   if (val > limit) {
63     msg = luaO_pushfstring(ls->L, "too many %s (limit=%d)", msg, limit);
64     luaX_syntaxerror(ls, msg);
65   }
66 }
67
68
69 void
70 luaX_errorline(LexState * ls, const char *s, const char *token, int line)
71 {
72   lua_State *L = ls->L;
73   char buff[MAXSRC];
74   luaO_chunkid(buff, getstr(ls->source), MAXSRC);
75   luaO_pushfstring(L, "%s:%d: %s near `%s'", buff, line, s, token);
76   luaD_throw(L, LUA_ERRSYNTAX);
77 }
78
79
80 static void
81 luaX_error(LexState * ls, const char *s, const char *token)
82 {
83   luaX_errorline(ls, s, token, ls->linenumber);
84 }
85
86
87 void
88 luaX_syntaxerror(LexState * ls, const char *msg)
89 {
90   const char *lasttoken;
91   switch (ls->t.token) {
92   case TK_NAME:
93     lasttoken = getstr(ls->t.seminfo.ts);
94     break;
95   case TK_STRING:
96   case TK_NUMBER:
97     lasttoken = luaZ_buffer(ls->buff);
98     break;
99   default:
100     lasttoken = luaX_token2str(ls, ls->t.token);
101     break;
102   }
103   luaX_error(ls, msg, lasttoken);
104 }
105
106
107 const char *
108 luaX_token2str(LexState * ls, int token)
109 {
110   if (token < FIRST_RESERVED) {
111     lua_assert(token == (unsigned char)token);
112     return luaO_pushfstring(ls->L, "%c", token);
113   } else
114     return token2string[token - FIRST_RESERVED];
115 }
116
117
118 static void
119 luaX_lexerror(LexState * ls, const char *s, int token)
120 {
121   if (token == TK_EOS)
122     luaX_error(ls, s, luaX_token2str(ls, token));
123   else
124     luaX_error(ls, s, luaZ_buffer(ls->buff));
125 }
126
127
128 static void
129 inclinenumber(LexState * LS)
130 {
131   next(LS);                     /* skip `\n' */
132   ++LS->linenumber;
133   luaX_checklimit(LS, LS->linenumber, MAX_INT, "lines in a chunk");
134 }
135
136
137 void
138 luaX_setinput(lua_State * L, LexState * LS, ZIO * z, TString * source)
139 {
140   LS->L = L;
141   LS->lookahead.token = TK_EOS; /* no look-ahead token */
142   LS->z = z;
143   LS->fs = NULL;
144   LS->linenumber = 1;
145   LS->lastline = 1;
146   LS->source = source;
147   next(LS);                     /* read first char */
148   if (LS->current == '#') {
149     do {                        /* skip first line */
150       next(LS);
151     } while (LS->current != '\n' && LS->current != EOZ);
152   }
153 }
154
155
156
157 /*
158 ** =======================================================
159 ** LEXICAL ANALYZER
160 ** =======================================================
161 */
162
163
164 /* use buffer to store names, literal strings and numbers */
165
166 /* extra space to allocate when growing buffer */
167 #define EXTRABUFF       32
168
169 /* maximum number of chars that can be read without checking buffer size */
170 #define MAXNOCHECK      5
171
172 #define checkbuffer(LS, len)    \
173     if (((len)+MAXNOCHECK)*sizeof(char) > luaZ_sizebuffer((LS)->buff)) \
174       luaZ_openspace((LS)->L, (LS)->buff, (len)+EXTRABUFF)
175
176 #define save(LS, c, l) \
177         (luaZ_buffer((LS)->buff)[l++] = cast(char, c))
178 #define save_and_next(LS, l)  (save(LS, LS->current, l), next(LS))
179
180
181 static size_t
182 readname(LexState * LS)
183 {
184   size_t l = 0;
185   checkbuffer(LS, l);
186   do {
187     checkbuffer(LS, l);
188     save_and_next(LS, l);
189   } while (isalnum(LS->current) || LS->current == '_');
190   save(LS, '\0', l);
191   return l - 1;
192 }
193
194
195 /* LUA_NUMBER */
196 static void
197 read_numeral(LexState * LS, int comma, SemInfo * seminfo)
198 {
199   size_t l = 0;
200   checkbuffer(LS, l);
201   if (comma)
202     save(LS, '.', l);
203   while (isdigit(LS->current)) {
204     checkbuffer(LS, l);
205     save_and_next(LS, l);
206   }
207   if (LS->current == '.') {
208     save_and_next(LS, l);
209     if (LS->current == '.') {
210       save_and_next(LS, l);
211       save(LS, '\0', l);
212       luaX_lexerror(LS, "ambiguous syntax (decimal point x string concatenation)", TK_NUMBER);
213     }
214   }
215   while (isdigit(LS->current)) {
216     checkbuffer(LS, l);
217     save_and_next(LS, l);
218   }
219   if (LS->current == 'e' || LS->current == 'E') {
220     save_and_next(LS, l);       /* read `E' */
221     if (LS->current == '+' || LS->current == '-')
222       save_and_next(LS, l);     /* optional exponent sign */
223     while (isdigit(LS->current)) {
224       checkbuffer(LS, l);
225       save_and_next(LS, l);
226     }
227   }
228   save(LS, '\0', l);
229   if (!luaO_str2d(luaZ_buffer(LS->buff), &seminfo->r))
230     luaX_lexerror(LS, "malformed number", TK_NUMBER);
231 }
232
233
234 static void
235 read_long_string(LexState * LS, SemInfo * seminfo)
236 {
237   int cont = 0;
238   size_t l = 0;
239   checkbuffer(LS, l);
240   save(LS, '[', l);             /* save first `[' */
241   save_and_next(LS, l);         /* pass the second `[' */
242   if (LS->current == '\n')      /* string starts with a newline? */
243     inclinenumber(LS);          /* skip it */
244   for (;;) {
245     checkbuffer(LS, l);
246     switch (LS->current) {
247     case EOZ:
248       save(LS, '\0', l);
249       luaX_lexerror(LS, (seminfo) ? "unfinished long string" : "unfinished long comment", TK_EOS);
250       break;                    /* to avoid warnings */
251     case '[':
252       save_and_next(LS, l);
253       if (LS->current == '[') {
254         cont++;
255         save_and_next(LS, l);
256       }
257       continue;
258     case ']':
259       save_and_next(LS, l);
260       if (LS->current == ']') {
261         if (cont == 0)
262           goto endloop;
263         cont--;
264         save_and_next(LS, l);
265       }
266       continue;
267     case '\n':
268       save(LS, '\n', l);
269       inclinenumber(LS);
270       if (!seminfo)
271         l = 0;                  /* reset buffer to avoid wasting space */
272       continue;
273     default:
274       save_and_next(LS, l);
275     }
276   }
277 endloop:
278   save_and_next(LS, l);         /* skip the second `]' */
279   save(LS, '\0', l);
280   if (seminfo)
281     seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 2, l - 5);
282 }
283
284
285 static void
286 read_string(LexState * LS, int del, SemInfo * seminfo)
287 {
288   size_t l = 0;
289   checkbuffer(LS, l);
290   save_and_next(LS, l);
291   while (LS->current != del) {
292     checkbuffer(LS, l);
293     switch (LS->current) {
294     case EOZ:
295       save(LS, '\0', l);
296       luaX_lexerror(LS, "unfinished string", TK_EOS);
297       break;                    /* to avoid warnings */
298     case '\n':
299       save(LS, '\0', l);
300       luaX_lexerror(LS, "unfinished string", TK_STRING);
301       break;                    /* to avoid warnings */
302     case '\\':
303       next(LS);                 /* do not save the `\' */
304       switch (LS->current) {
305       case 'a':
306         save(LS, '\a', l);
307         next(LS);
308         break;
309       case 'b':
310         save(LS, '\b', l);
311         next(LS);
312         break;
313       case 'f':
314         save(LS, '\f', l);
315         next(LS);
316         break;
317       case 'n':
318         save(LS, '\n', l);
319         next(LS);
320         break;
321       case 'r':
322         save(LS, '\r', l);
323         next(LS);
324         break;
325       case 't':
326         save(LS, '\t', l);
327         next(LS);
328         break;
329       case 'v':
330         save(LS, '\v', l);
331         next(LS);
332         break;
333       case '\n':
334         save(LS, '\n', l);
335         inclinenumber(LS);
336         break;
337       case EOZ:
338         break;                  /* will raise an error next loop */
339       default:{
340           if (!isdigit(LS->current))
341             save_and_next(LS, l);       /* handles \\, \", \', and \? */
342           else {                /* \xxx */
343             int c = 0;
344             int i = 0;
345             do {
346               c = 10 * c + (LS->current - '0');
347               next(LS);
348             } while (++i < 3 && isdigit(LS->current));
349             if (c > UCHAR_MAX) {
350               save(LS, '\0', l);
351               luaX_lexerror(LS, "escape sequence too large", TK_STRING);
352             }
353             save(LS, c, l);
354           }
355         }
356       }
357       break;
358     default:
359       save_and_next(LS, l);
360     }
361   }
362   save_and_next(LS, l);         /* skip delimiter */
363   save(LS, '\0', l);
364   seminfo->ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff) + 1, l - 3);
365 }
366
367
368 int
369 luaX_lex(LexState * LS, SemInfo * seminfo)
370 {
371   for (;;) {
372     switch (LS->current) {
373
374     case '\n':{
375         inclinenumber(LS);
376         continue;
377       }
378     case '-':{
379         next(LS);
380         if (LS->current != '-')
381           return '-';
382         /* else is a comment */
383         next(LS);
384         if (LS->current == '[' && (next(LS), LS->current == '['))
385           read_long_string(LS, NULL);   /* long comment */
386         else                    /* short comment */
387           while (LS->current != '\n' && LS->current != EOZ)
388             next(LS);
389         continue;
390       }
391     case '[':{
392         next(LS);
393         if (LS->current != '[')
394           return '[';
395         else {
396           read_long_string(LS, seminfo);
397           return TK_STRING;
398         }
399       }
400     case '=':{
401         next(LS);
402         if (LS->current != '=')
403           return '=';
404         else {
405           next(LS);
406           return TK_EQ;
407         }
408       }
409     case '<':{
410         next(LS);
411         if (LS->current != '=')
412           return '<';
413         else {
414           next(LS);
415           return TK_LE;
416         }
417       }
418     case '>':{
419         next(LS);
420         if (LS->current != '=')
421           return '>';
422         else {
423           next(LS);
424           return TK_GE;
425         }
426       }
427     case '~':{
428         next(LS);
429         if (LS->current != '=')
430           return '~';
431         else {
432           next(LS);
433           return TK_NE;
434         }
435       }
436     case '"':
437     case '\'':{
438         read_string(LS, LS->current, seminfo);
439         return TK_STRING;
440       }
441     case '.':{
442         next(LS);
443         if (LS->current == '.') {
444           next(LS);
445           if (LS->current == '.') {
446             next(LS);
447             return TK_DOTS;     /* ... */
448           } else
449             return TK_CONCAT;   /* .. */
450         } else if (!isdigit(LS->current))
451           return '.';
452         else {
453           read_numeral(LS, 1, seminfo);
454           return TK_NUMBER;
455         }
456       }
457     case EOZ:{
458         return TK_EOS;
459       }
460     default:{
461         if (isspace(LS->current)) {
462           next(LS);
463           continue;
464         } else if (isdigit(LS->current)) {
465           read_numeral(LS, 0, seminfo);
466           return TK_NUMBER;
467         } else if (isalpha(LS->current) || LS->current == '_') {
468           /* identifier or reserved word */
469           size_t l = readname(LS);
470           TString *ts = luaS_newlstr(LS->L, luaZ_buffer(LS->buff), l);
471           if (ts->tsv.reserved > 0)     /* reserved word? */
472             return ts->tsv.reserved - 1 + FIRST_RESERVED;
473           seminfo->ts = ts;
474           return TK_NAME;
475         } else {
476           int c = LS->current;
477           if (iscntrl(c))
478             luaX_error(LS, "invalid control char", luaO_pushfstring(LS->L, "char(%d)", c));
479           next(LS);
480           return c;             /* single-char tokens (+ - / ...) */
481         }
482       }
483     }
484   }
485 }
486
487 #undef next