src/org/xwt/js/Lexer.java

   1 // Derived from org.mozilla.javascript.TokenStream [NPL]
   2
   3 /**
   4  * The contents of this file are subject to the Netscape Public
   5  * License Version 1.1 (the "License"); you may not use this file
   6  * except in compliance with the License. You may obtain a copy of
   7  * the License at http://www.mozilla.org/NPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS
  10  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11  * implied. See the License for the specific language governing
  12  * rights and limitations under the License.
  13  *
  14  * The Initial Developer of the Original Code is Netscape
  15  * Communications Corporation.
  16  *
  17  * Contributor(s): Roger Lawrence, Mike McCabe
  18  */
  19
  20 package org.xwt.js;
  21 import java.io.*;
  22
  23 /** Lexes a stream of characters into a stream of Tokens */
  24 class Lexer implements Tokens {
  25
  26     /** for debugging */
  27     public static void main(String[] s) throws Exception {
  28         Lexer l = new Lexer(new InputStreamReader(System.in), "stdin", 0);
  29         int tok = 0;
  30         while((tok = l.getToken()) != -1) System.out.println(codeToString[tok]);
  31     }
  32
  33     /** the token that was just parsed */
  34     protected int op;
  35
  36    /** the most recently parsed token, <i>regardless of pushbacks</i> */
  37     protected int mostRecentlyReadToken;
  38
  39     /** if the token just parsed was a NUMBER, this is the numeric value */
  40     protected Number number = null;
  41
  42     /** if the token just parsed was a NAME or STRING, this is the string value */
  43     protected String string = null;
  44
  45     /** the line number of the most recently <i>lexed</i> token */
  46     private int line = 0;
  47
  48     /** the line number of the most recently <i>parsed</i> token */
  49     protected int parserLine = 0;
  50
  51     /** the column number of the current token */
  52     protected int col = 0;
  53
  54     /** the name of the source code file being lexed */
  55     protected String sourceName;
  56
  57     private SmartReader in;
  58     public Lexer(Reader r, String sourceName, int line) throws IOException {
  59         this.sourceName = sourceName;
  60         this.line = line;
  61         this.parserLine = line;
  62         in = new SmartReader(r);
  63     }
  64
  65
  66     // Predicates ///////////////////////////////////////////////////////////////////////
  67
  68     private static boolean isAlpha(int c) { return ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); }
  69     private static boolean isDigit(int c) { return (c >= '0' && c <= '9'); }
  70     private static int xDigitToInt(int c) {
  71         if ('0' <= c && c <= '9') return c - '0';
  72         else if ('a' <= c && c <= 'f') return c - ('a' - 10);
  73         else if ('A' <= c && c <= 'F') return c - ('A' - 10);
  74         else return -1;
  75     }
  76
  77
  78     // Token Subtype Handlers /////////////////////////////////////////////////////////
  79
  80     private int getKeyword(String s) throws IOException {
  81         char c;
  82         switch (s.length()) {
  83             case 2: c=s.charAt(1);
  84                 if (c=='f') { if (s.charAt(0)=='i') return IF; }
  85                 else if (c=='n') { if (s.charAt(0)=='i') return IN; }
  86                 else if (c=='o') { if (s.charAt(0)=='d') return DO; }
  87                 break;
  88             case 3: switch (s.charAt(0)) {
  89                 case 'a': if (s.charAt(2)=='d' && s.charAt(1)=='n') return AND; break;
  90                 case 'f': if (s.charAt(2)=='r' && s.charAt(1)=='o') return FOR; break;
  91                 case 'i': if (s.charAt(2)=='t' && s.charAt(1)=='n') return RESERVED;
  92                 case 'n': if (s.charAt(2)=='w' && s.charAt(1)=='e') return RESERVED;
  93                 case 't': if (s.charAt(2)=='y' && s.charAt(1)=='r') return TRY; break;
  94                 case 'v': if (s.charAt(2)=='r' && s.charAt(1)=='a') return VAR; break;
  95                 } break;
  96             case 4: switch (s.charAt(0)) {
  97                 case 'b': return s.equals("byte") ? RESERVED : -1;
  98                 case 'c': c=s.charAt(3);
  99                     if (c=='e') { if (s.charAt(2)=='s' && s.charAt(1)=='a') return CASE; }
 100                     else if (c=='r') { if (s.charAt(2)=='a' && s.charAt(1)=='h') return RESERVED; }
 101                     return -1;
 102                 case 'e': c=s.charAt(3);
 103                     if (c=='e') { if (s.charAt(2)=='s' && s.charAt(1)=='l') return ELSE; }
 104                     else if (c=='m') { if (s.charAt(2)=='u' && s.charAt(1)=='n') return RESERVED; }
 105                     return -1;
 106                 case 'g': return s.equals("goto") ? RESERVED : -1;
 107                 case 'l': return s.equals("long") ? RESERVED : -1;
 108                 case 'n': return s.equals("null") ? NULL : -1;
 109                 case 't': c=s.charAt(3);
 110                     if (c=='e') { if (s.charAt(2)=='u' && s.charAt(1)=='r') return TRUE; }
 111                     else if (c=='s') { if (s.charAt(2)=='i' && s.charAt(1)=='h') return THIS; }
 112                     return -1;
 113                 case 'w': if (s.equals("with")) return RESERVED; else return -1;
 114                 case 'v': if (s.equals("void")) return RESERVED; else return -1;
 115                 } break;
 116             case 5: switch (s.charAt(2)) {
 117                 case 'a': return s.equals("class") ? RESERVED : -1;
 118                 case 'e': return s.equals("break") ? BREAK : -1;
 119                 case 'i': return s.equals("while") ? WHILE : -1;
 120                 case 'l': return s.equals("false") ? FALSE : -1;
 121                 case 'n': c=s.charAt(0);
 122                     if (s.equals("const")) return RESERVED;
 123                     else if (s.equals("final")) return RESERVED;
 124                     return -1;
 125                 case 'o': c=s.charAt(0);
 126                     if (c == 'c') return s.equals("float") ? RESERVED : -1;
 127                     else if (c=='s') return s.equals("final") ? RESERVED : -1;
 128                     break;
 129                 case 'p': return s.equals("super") ? RESERVED : -1;
 130                 case 'r': return s.equals("throw") ? THROW : -1;
 131                 case 't': return s.equals("catch") ? CATCH : -1;
 132                 } break;
 133             case 6: switch (s.charAt(1)) {
 134                 case 'a': return s.equals("class") ? RESERVED : -1;
 135                 case 'e': c=s.charAt(0);
 136                     if (s.equals("delete")) return RESERVED;
 137                     else if (c=='r') return s.equals("return") ? RETURN : -1;
 138                     break;
 139                 case 'h': return s.equals("throws") ? RESERVED : -1;
 140                 case 'o': return s.equals("double") ? RESERVED : -1;
 141                 case 's': return s.equals("assert") ? ASSERT : -1;
 142                 case 'u': return s.equals("public") ? RESERVED : -1;
 143                 case 'w': return s.equals("switch") ? SWITCH : -1;
 144                 case 'y': return s.equals("typeof") ? TYPEOF : -1;
 145                 } break;
 146             case 7: switch (s.charAt(1)) {
 147                 case 'a': return s.equals("package") ? RESERVED : -1;
 148                 case 'e': return s.equals("default") ? DEFAULT : -1;
 149                 case 'i': return s.equals("finally") ? FINALLY : -1;
 150                 case 'o': return s.equals("boolean") ? RESERVED : -1;
 151                 case 'r': return s.equals("private") ? RESERVED : -1;
 152                 case 'x': return s.equals("extends") ? RESERVED : -1;
 153                 } break;
 154             case 8: switch (s.charAt(0)) {
 155                 case 'a': return s.equals("abstract") ? RESERVED : -1;
 156                 case 'c': return s.equals("continue") ? CONTINUE : -1;
 157                 case 'd': return s.equals("debugger") ? RESERVED : -1;
 158                 case 'f': return s.equals("function") ? FUNCTION : -1;
 159                 case 'v': return s.equals("volatile") ? RESERVED : -1;
 160                 } break;
 161             case 9: c=s.charAt(0);
 162                 if (c=='i') return s.equals("interface") ? RESERVED : -1;
 163                 else if (c=='p') return s.equals("protected") ? RESERVED : -1;
 164                 else if (c=='t') return s.equals("transient") ? RESERVED : -1;
 165                 break;
 166             case 10: c=s.charAt(1);
 167                 if (c=='m') return s.equals("implements") ? RESERVED : -1;
 168                 else if (c=='n' && s.equals("instanceof")) return RESERVED;
 169                 break;
 170             case 12: return s.equals("synchronized") ? RESERVED : -1;
 171             }
 172         return -1;
 173     }
 174
 175     private int getIdentifier(int c) throws IOException {
 176         in.startString();
 177         while (Character.isJavaIdentifierPart((char)(c = in.read())));
 178         in.unread();
 179         String str = in.getString();
 180         int result = getKeyword(str);
 181         if (result == RESERVED) throw new LexerException("The reserved word \"" + str + "\" is not permitted in XWT scripts");
 182         if (result != -1) return result;
 183         this.string = str.intern();
 184         return NAME;
 185     }
 186
 187     private int getNumber(int c) throws IOException {
 188         int base = 10;
 189         in.startString();
 190         double dval = Double.NaN;
 191         long longval = 0;
 192         boolean isInteger = true;
 193
 194         // figure out what base we're using
 195         if (c == '0') {
 196             if (Character.toLowerCase((char)(c = in.read())) == 'x') { base = 16; in.startString(); }
 197             else if (isDigit(c)) base = 8;
 198         }
 199
 200         while (0 <= xDigitToInt(c) && !(base < 16 && isAlpha(c))) c = in.read();
 201         if (base == 10 && (c == '.' || c == 'e' || c == 'E')) {
 202             isInteger = false;
 203             if (c == '.') do { c = in.read(); } while (isDigit(c));
 204             if (c == 'e' || c == 'E') {
 205                 c = in.read();
 206                 if (c == '+' || c == '-') c = in.read();
 207                 if (!isDigit(c)) throw new LexerException("float listeral did not have an exponent value");
 208                 do { c = in.read(); } while (isDigit(c));
 209             }
 210         }
 211         in.unread();
 212
 213         String numString = in.getString();
 214         if (base == 10 && !isInteger) {
 215             try { dval = (Double.valueOf(numString)).doubleValue(); }
 216             catch (NumberFormatException ex) { throw new LexerException("invalid numeric literal: \"" + numString + "\""); }
 217         } else {
 218             if (isInteger) {
 219                 longval = Long.parseLong(numString, base);
 220                 dval = (double)longval;
 221             } else {
 222                 dval = Double.parseDouble(numString);
 223                 longval = (long) dval;
 224                 if (longval == dval) isInteger = true;
 225             }
 226         }
 227
 228         if (!isInteger) this.number = new Double(dval);
 229         else if (Byte.MIN_VALUE <= longval && longval <= Byte.MAX_VALUE) this.number = new Byte((byte)longval);
 230         else if (Short.MIN_VALUE <= longval && longval <= Short.MAX_VALUE) this.number = new Short((short)longval);
 231         else if (Integer.MIN_VALUE <= longval && longval <= Integer.MAX_VALUE) this.number = new Integer((int)longval);
 232         else this.number = new Double(longval);
 233         return NUMBER;
 234     }
 235
 236     private int getString(int c) throws IOException {
 237         StringBuffer stringBuf = null;
 238         int quoteChar = c;
 239         int val = 0;
 240         c = in.read();
 241         in.startString(); // start after the first "
 242         while(c != quoteChar) {
 243             if (c == '\n' || c == -1) throw new LexerException("unterminated string literal");
 244             if (c == '\\') {
 245                 if (stringBuf == null) {
 246                     in.unread();   // Don't include the backslash
 247                     stringBuf = new StringBuffer(in.getString());
 248                     in.read();
 249                 }
 250                 switch (c = in.read()) {
 251                 case 'b': c = '\b'; break;
 252                 case 'f': c = '\f'; break;
 253                 case 'n': c = '\n'; break;
 254                 case 'r': c = '\r'; break;
 255                 case 't': c = '\t'; break;
 256                 case 'v': c = '\u000B'; break;
 257                 case '\\': c = '\\'; break;
 258                 case 'u': {
 259                     int v = 0;
 260                     for(int i=0; i<4; i++) {
 261                         int ci = in.read();
 262                         if (!((ci >= '0' && ci <= '9') || (ci >= 'a' && ci <= 'f') || (ci >= 'A' && ci <= 'F')))
 263                             throw new LexerException("illegal character '" + ((char)c) + "' in \\u unicode escape sequence");
 264                         v = (v << 8) | Integer.parseInt(ci + "", 16);
 265                     }
 266                     c = (char)v;
 267                     break;
 268                 }
 269                 default:
 270                     // just use the character that was escaped
 271                     break;
 272                 }
 273             }
 274             if (stringBuf != null) stringBuf.append((char) c);
 275             c = in.read();
 276         }
 277         if (stringBuf != null) this.string = stringBuf.toString().intern();
 278         else {
 279             in.unread(); // miss the trailing "
 280             this.string = in.getString().intern();
 281             in.read();
 282         }
 283         return STRING;
 284     }
 285
 286     private int _getToken() throws IOException {
 287         int c;
 288         do { c = in.read(); } while (c == '\u0020' || c == '\u0009' || c == '\u000C' || c == '\u000B' || c == '\n' );
 289         if (c == -1) return -1;
 290         if (c == '\\' || Character.isJavaIdentifierStart((char)c)) return getIdentifier(c);
 291         if (isDigit(c) || (c == '.' && isDigit(in.peek()))) return getNumber(c);
 292         if (c == '"' || c == '\'') return getString(c);
 293         switch (c) {
 294         case ';': return SEMI;
 295         case '[': return LB;
 296         case ']': return RB;
 297         case '{': return LC;
 298         case '}': return RC;
 299         case '(': return LP;
 300         case ')': return RP;
 301         case ',': return COMMA;
 302         case '?': return HOOK;
 303         case ':': return COLON;
 304         case '.': return DOT;
 305         case '|': return in.match('|') ? OR : (in.match('=') ? ASSIGN_BITOR : BITOR);
 306         case '^': return in.match('=') ? ASSIGN_BITXOR : BITXOR;
 307         case '&': return in.match('&') ? AND : in.match('=') ? ASSIGN_BITAND : BITAND;
 308         case '=': return !in.match('=') ? ASSIGN : in.match('=') ? SHEQ : EQ;
 309         case '!': return !in.match('=') ? BANG : in.match('=') ? SHNE : NE;
 310         case '%': return in.match('=') ? ASSIGN_MOD : MOD;
 311         case '~': return BITNOT;
 312         case '+': return in.match('=') ? ASSIGN_ADD : in.match('+') ? INC : ADD;
 313         case '-': return in.match('=') ? ASSIGN_SUB: in.match('-') ? DEC : SUB;
 314         case '*': return in.match('=') ? ASSIGN_MUL : MUL;
 315         case '<': return !in.match('<') ? (in.match('=') ? LE : LT) : in.match('=') ? ASSIGN_LSH : LSH;
 316         case '>': return !in.match('>') ? (in.match('=') ? GE : GT) :
 317             in.match('>') ? (in.match('=') ? ASSIGN_URSH : URSH) : (in.match('=') ? ASSIGN_RSH : RSH);
 318         case '/':
 319             if (in.match('=')) return ASSIGN_DIV;
 320             if (in.match('/')) { while ((c = in.read()) != -1 && c != '\n'); in.unread(); return getToken(); }
 321             if (!in.match('*')) return DIV;
 322             while ((c = in.read()) != -1 && !(c == '*' && in.match('/'))) {
 323                 if (c == '\n' || c != '/' || !in.match('*')) continue;
 324                 if (in.match('/')) return getToken();
 325                 throw new LexerException("nested comments are not permitted");
 326             }
 327             if (c == -1) throw new LexerException("unterminated comment");
 328             return getToken();  // `goto retry'
 329         default: throw new LexerException("illegal character: \'" + ((char)c) + "\'");
 330         }
 331     }
 332
 333
 334     // SmartReader ////////////////////////////////////////////////////////////////
 335
 336     /** a Reader that tracks line numbers and can push back tokens */
 337     private class SmartReader {
 338         PushbackReader reader = null;
 339         int lastread = -1;
 340
 341         public SmartReader(Reader r) { reader = new PushbackReader(r); }
 342         public void unread() throws IOException { unread((char)lastread); }
 343         public void unread(char c) throws IOException {
 344             reader.unread(c);
 345             if(c == '\n') col = -1;
 346             else col--;
 347             if (accumulator != null) accumulator.setLength(accumulator.length() - 1);
 348         }
 349         public boolean match(char c) throws IOException { if (peek() == c) { reader.read(); return true; } else return false; }
 350         public int peek() throws IOException {
 351             int peeked = reader.read();
 352             if (peeked != -1) reader.unread((char)peeked);
 353             return peeked;
 354         }
 355         public int read() throws IOException {
 356             lastread = reader.read();
 357             if (accumulator != null) accumulator.append((char)lastread);
 358             if (lastread != '\n' && lastread != '\r') col++;
 359             if (lastread == '\n') {
 360                 // col is -1 if we just unread a newline, this is sort of ugly
 361                 if (col != -1) parserLine = ++line;
 362                 col = 0;
 363             }
 364             return lastread;
 365         }
 366
 367         // FEATURE: could be much more efficient
 368         StringBuffer accumulator = null;
 369         public void startString() {
 370             accumulator = new StringBuffer();
 371             accumulator.append((char)lastread);
 372         }
 373         public String getString() throws IOException {
 374             String ret = accumulator.toString();
 375             accumulator = null;
 376             return ret;
 377         }
 378     }
 379
 380
 381     // Token PushBack code ////////////////////////////////////////////////////////////
 382
 383     private int pushBackDepth = 0;
 384     private int[] pushBackInts = new int[10];
 385     private Object[] pushBackObjects = new Object[10];
 386
 387     /** push back a token */
 388     public final void pushBackToken(int op, Object obj) {
 389         if (pushBackDepth >= pushBackInts.length - 1) {
 390             int[] newInts = new int[pushBackInts.length * 2];
 391             System.arraycopy(pushBackInts, 0, newInts, 0, pushBackInts.length);
 392             pushBackInts = newInts;
 393             Object[] newObjects = new Object[pushBackObjects.length * 2];
 394             System.arraycopy(pushBackObjects, 0, newObjects, 0, pushBackObjects.length);
 395             pushBackObjects = newObjects;
 396         }
 397         pushBackInts[pushBackDepth] = op;
 398         pushBackObjects[pushBackDepth] = obj;
 399         pushBackDepth++;
 400     }
 401
 402     /** push back the most recently read token */
 403     public final void pushBackToken() { pushBackToken(op, number != null ? (Object)number : (Object)string); }
 404
 405     /** read a token but leave it in the stream */
 406     public final int peekToken() throws IOException {
 407         int ret = getToken();
 408         pushBackToken();
 409         return ret;
 410     }
 411
 412     /** read a token */
 413     public final int getToken() throws IOException {
 414         number = null;
 415         string = null;
 416         if (pushBackDepth == 0) {
 417             mostRecentlyReadToken = op;
 418             return op = _getToken();
 419         }
 420         pushBackDepth--;
 421         op = pushBackInts[pushBackDepth];
 422         if (pushBackObjects[pushBackDepth] != null) {
 423             number = pushBackObjects[pushBackDepth] instanceof Number ? (Number)pushBackObjects[pushBackDepth] : null;
 424             string = pushBackObjects[pushBackDepth] instanceof String ? (String)pushBackObjects[pushBackDepth] : null;
 425         }
 426         return op;
 427     }
 428
 429     class LexerException extends IOException {
 430         public LexerException(String s) { super(sourceName + ":" + line + "," + col + ": " + s); }
 431     }
 432 }