Mercurial > vba-clojure

     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 

     8 #include <ctype.h>

     9 #include <locale.h>

    10 #include <string.h>

    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     "<number>", "<name>", "<string>", "<eof>",

    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; i<NUM_RESERVED; i++) {

    67     TString *ts = luaS_new(L, luaX_tokens[i]);

    68     luaS_fix(ts);  /* reserved words are never collected */

    69     lua_assert(strlen(luaX_tokens[i])+1 <= TOKEN_LEN);

    70     ts->tsv.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   return ts;

   124 }

   125 

   126 

   127 static void inclinenumber (LexState *ls) {

   128   int old = ls->current;

   129   lua_assert(currIsNewline(ls));

   130   next(ls);  /* skip `\n' or `\r' */

   131   if (currIsNewline(ls) && ls->current != old)

   132     next(ls);  /* skip `\n\r' or `\r\n' */

   133   if (++ls->linenumber >= MAX_INT)

   134     luaX_syntaxerror(ls, "chunk has too many lines");

   135 }

   136 

   137 

   138 void luaX_setinput (lua_State *L, LexState *ls, ZIO *z, TString *source) {

   139   ls->decpoint = '.';

   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   luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER);  /* initialize buffer */

   148   next(ls);  /* read first char */

   149 }

   150 

   151 

   152 

   153 /*

   154 ** =======================================================

   155 ** LEXICAL ANALYZER

   156 ** =======================================================

   157 */

   158 

   159 

   160 

   161 static int check_next (LexState *ls, const char *set) {

   162   if (!strchr(set, ls->current))

   163     return 0;

   164   save_and_next(ls);

   165   return 1;

   166 }

   167 

   168 

   169 static void buffreplace (LexState *ls, char from, char to) {

   170   size_t n = luaZ_bufflen(ls->buff);

   171   char *p = luaZ_buffer(ls->buff);

   172   while (n--)

   173     if (p[n] == from) p[n] = to;

   174 }

   175 

   176 

   177 static void trydecpoint (LexState *ls, SemInfo *seminfo) {

   178   /* format error: try to update decimal point separator */

   179   struct lconv *cv = localeconv();

   180   char old = ls->decpoint;

   181   ls->decpoint = (cv ? cv->decimal_point[0] : '.');

   182   buffreplace(ls, old, ls->decpoint);  /* try updated decimal separator */

   183   if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r)) {

   184     /* format error with correct decimal point: no more options */

   185     buffreplace(ls, ls->decpoint, '.');  /* undo change (for error message) */

   186     luaX_lexerror(ls, "malformed number", TK_NUMBER);

   187   }

   188 }

   189 

   190 

   191 /* LUA_NUMBER */

   192 static void read_numeral (LexState *ls, SemInfo *seminfo) {

   193   lua_assert(isdigit(ls->current));

   194   do {

   195     save_and_next(ls);

   196   } while (isdigit(ls->current) || ls->current == '.');

   197   if (check_next(ls, "Ee"))  /* `E'? */

   198     check_next(ls, "+-");  /* optional exponent sign */

   199   while (isalnum(ls->current) || ls->current == '_')

   200     save_and_next(ls);

   201   save(ls, '\0');

   202   buffreplace(ls, '.', ls->decpoint);  /* follow locale for decimal point */

   203   if (!luaO_str2d(luaZ_buffer(ls->buff), &seminfo->r))  /* format error? */

   204     trydecpoint(ls, seminfo); /* try to update decimal point separator */

   205 }

   206 

   207 

   208 static int skip_sep (LexState *ls) {

   209   int count = 0;

   210   int s = ls->current;

   211   lua_assert(s == '[' || s == ']');

   212   save_and_next(ls);

   213   while (ls->current == '=') {

   214     save_and_next(ls);

   215     count++;

   216   }

   217   return (ls->current == s) ? count : (-count) - 1;

   218 }

   219 

   220 

   221 static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {

   222   int cont = 0;

   223   (void)(cont);  /* avoid warnings when `cont' is not used */

   224   save_and_next(ls);  /* skip 2nd `[' */

   225   if (currIsNewline(ls))  /* string starts with a newline? */

   226     inclinenumber(ls);  /* skip it */

   227   for (;;) {

   228     switch (ls->current) {

   229       case EOZ:

   230         luaX_lexerror(ls, (seminfo) ? "unfinished long string" :

   231                                    "unfinished long comment", TK_EOS);

   232         break;  /* to avoid warnings */

   233 #if defined(LUA_COMPAT_LSTR)

   234       case '[': {

   235         if (skip_sep(ls) == sep) {

   236           save_and_next(ls);  /* skip 2nd `[' */

   237           cont++;

   238 #if LUA_COMPAT_LSTR == 1

   239           if (sep == 0)

   240             luaX_lexerror(ls, "nesting of [[...]] is deprecated", '[');

   241 #endif

   242         }

   243         break;

   244       }

   245 #endif

   246       case ']': {

   247         if (skip_sep(ls) == sep) {

   248           save_and_next(ls);  /* skip 2nd `]' */

   249 #if defined(LUA_COMPAT_LSTR) && LUA_COMPAT_LSTR == 2

   250           cont--;

   251           if (sep == 0 && cont >= 0) break;

   252 #endif

   253           goto endloop;

   254         }

   255         break;

   256       }

   257       case '\n':

   258       case '\r': {

   259         save(ls, '\n');

   260         inclinenumber(ls);

   261         if (!seminfo) luaZ_resetbuffer(ls->buff);  /* avoid wasting space */

   262         break;

   263       }

   264       default: {

   265         if (seminfo) save_and_next(ls);

   266         else next(ls);

   267       }

   268     }

   269   } endloop:

   270   if (seminfo)

   271     seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),

   272                                      luaZ_bufflen(ls->buff) - 2*(2 + sep));

   273 }

   274 

   275 

   276 static void read_string (LexState *ls, int del, SemInfo *seminfo) {

   277   save_and_next(ls);

   278   while (ls->current != del) {

   279     switch (ls->current) {

   280       case EOZ:

   281         luaX_lexerror(ls, "unfinished string", TK_EOS);

   282         continue;  /* to avoid warnings */

   283       case '\n':

   284       case '\r':

   285         luaX_lexerror(ls, "unfinished string", TK_STRING);

   286         continue;  /* to avoid warnings */

   287       case '\\': {

   288         int c;

   289         next(ls);  /* do not save the `\' */

   290         switch (ls->current) {

   291           case 'a': c = '\a'; break;

   292           case 'b': c = '\b'; break;

   293           case 'f': c = '\f'; break;

   294           case 'n': c = '\n'; break;

   295           case 'r': c = '\r'; break;

   296           case 't': c = '\t'; break;

   297           case 'v': c = '\v'; break;

   298           case '\n':  /* go through */

   299           case '\r': save(ls, '\n'); inclinenumber(ls); continue;

   300           case EOZ: continue;  /* will raise an error next loop */

   301           default: {

   302             if (!isdigit(ls->current))

   303               save_and_next(ls);  /* handles \\, \", \', and \? */

   304             else {  /* \xxx */

   305               int i = 0;

   306               c = 0;

   307               do {

   308                 c = 10*c + (ls->current-'0');

   309                 next(ls);

   310               } while (++i<3 && isdigit(ls->current));

   311               if (c > UCHAR_MAX)

   312                 luaX_lexerror(ls, "escape sequence too large", TK_STRING);

   313               save(ls, c);

   314             }

   315             continue;

   316           }

   317         }

   318         save(ls, c);

   319         next(ls);

   320         continue;

   321       }

   322       default:

   323         save_and_next(ls);

   324     }

   325   }

   326   save_and_next(ls);  /* skip delimiter */

   327   seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1,

   328                                    luaZ_bufflen(ls->buff) - 2);

   329 }

   330 

   331 

   332 static int llex (LexState *ls, SemInfo *seminfo) {

   333   luaZ_resetbuffer(ls->buff);

   334   for (;;) {

   335     switch (ls->current) {

   336       case '\n':

   337       case '\r': {

   338         inclinenumber(ls);

   339         continue;

   340       }

   341       case '-': {

   342         next(ls);

   343         if (ls->current != '-') return '-';

   344         /* else is a comment */

   345         next(ls);

   346         if (ls->current == '[') {

   347           int sep = skip_sep(ls);

   348           luaZ_resetbuffer(ls->buff);  /* `skip_sep' may dirty the buffer */

   349           if (sep >= 0) {

   350             read_long_string(ls, NULL, sep);  /* long comment */

   351             luaZ_resetbuffer(ls->buff);

   352             continue;

   353           }

   354         }

   355         /* else short comment */

   356         while (!currIsNewline(ls) && ls->current != EOZ)

   357           next(ls);

   358         continue;

   359       }

   360       case '[': {

   361         int sep = skip_sep(ls);

   362         if (sep >= 0) {

   363           read_long_string(ls, seminfo, sep);

   364           return TK_STRING;

   365         }

   366         else if (sep == -1) return '[';

   367         else luaX_lexerror(ls, "invalid long string delimiter", TK_STRING);

   368       }

   369       case '=': {

   370         next(ls);

   371         if (ls->current != '=') return '=';

   372         else { next(ls); return TK_EQ; }

   373       }

   374       case '<': {

   375         next(ls);

   376         if (ls->current != '=') return '<';

   377         else { next(ls); return TK_LE; }

   378       }

   379       case '>': {

   380         next(ls);

   381         if (ls->current != '=') return '>';

   382         else { next(ls); return TK_GE; }

   383       }

   384       case '~': {

   385         next(ls);

   386         if (ls->current != '=') return '~';

   387         else { next(ls); return TK_NE; }

   388       }

   389       case '"':

   390       case '\'': {

   391         read_string(ls, ls->current, seminfo);

   392         return TK_STRING;

   393       }

   394       case '.': {

   395         save_and_next(ls);

   396         if (check_next(ls, ".")) {

   397           if (check_next(ls, "."))

   398             return TK_DOTS;   /* ... */

   399           else return TK_CONCAT;   /* .. */

   400         }

   401         else if (!isdigit(ls->current)) return '.';

   402         else {

   403           read_numeral(ls, seminfo);

   404           return TK_NUMBER;

   405         }

   406       }

   407       case EOZ: {

   408         return TK_EOS;

   409       }

   410       default: {

   411         if (isspace(ls->current)) {

   412           lua_assert(!currIsNewline(ls));

   413           next(ls);

   414           continue;

   415         }

   416         else if (isdigit(ls->current)) {

   417           read_numeral(ls, seminfo);

   418           return TK_NUMBER;

   419         }

   420         else if (isalpha(ls->current) || ls->current == '_') {

   421           /* identifier or reserved word */

   422           TString *ts;

   423           do {

   424             save_and_next(ls);

   425           } while (isalnum(ls->current) || ls->current == '_');

   426           ts = luaX_newstring(ls, luaZ_buffer(ls->buff),

   427                                   luaZ_bufflen(ls->buff));

   428           if (ts->tsv.reserved > 0)  /* reserved word? */

   429             return ts->tsv.reserved - 1 + FIRST_RESERVED;

   430           else {

   431             seminfo->ts = ts;

   432             return TK_NAME;

   433           }

   434         }

   435         else {

   436           int c = ls->current;

   437           next(ls);

   438           return c;  /* single-char tokens (+ - / ...) */

   439         }

   440       }

   441     }

   442   }

   443 }

   444 

   445 

   446 void luaX_next (LexState *ls) {

   447   ls->lastline = ls->linenumber;

   448   if (ls->lookahead.token != TK_EOS) {  /* is there a look-ahead token? */

   449     ls->t = ls->lookahead;  /* use this one */

   450     ls->lookahead.token = TK_EOS;  /* and discharge it */

   451   }

   452   else

   453     ls->t.token = llex(ls, &ls->t.seminfo);  /* read next token */

   454 }

   455 

   456 

   457 void luaX_lookahead (LexState *ls) {

   458   lua_assert(ls->lookahead.token == TK_EOS);

   459   ls->lookahead.token = llex(ls, &ls->lookahead.seminfo);

   460 }

   461
author	Robert McIntyre <rlm@mit.edu>
date	Sat, 01 Sep 2012 03:42:16 -0500
parents	27763b933818
children