← Back to branch summary

~ilya-yanok/ubuntu/precise/grub2/fix-for-948716

« back to all changes in this revision

Viewing changes to script/lua/llex.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Millan
  • Date: 2009-07-25 19:00:53 UTC
  • mfrom: (1.6.3 upstream)
  • mto: (17.4.13 sid)
  • mto: This revision was merged to the branch mainline in revision 53.
  • Revision ID: james.westby@ubuntu.com-20090725190053-uv3lm6ya3zxs77ep
Import upstream version 1.96+20090725

Show diffs side-by-side

added added

removed removed

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