X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2Fjs%2FLexer.java;h=6e541c18af50cd0ecf94851069d68d3a268737ad;hb=32fa4185423afaf8700228f7864d062ded5ca8e8;hp=1fa432d8befeff4bcae14618852360951842c687;hpb=b32cea3f3e272ab00899d134d75a8bd7bcf6c8c0;p=org.ibex.core.git

diff --git a/src/org/xwt/js/Lexer.java b/src/org/xwt/js/Lexer.java
index 1fa432d..6e541c1 100644
--- a/src/org/xwt/js/Lexer.java
+++ b/src/org/xwt/js/Lexer.java
@@ -17,8 +17,6 @@
  * Contributor(s): Roger Lawrence, Mike McCabe
  */
 
-// FIXME: mark lots of these methods 'final' so they get inlined
-
 package org.xwt.js;
 import java.io.*;
 
@@ -79,98 +77,66 @@ class Lexer implements Tokens {
     
     // Token Subtype Handlers /////////////////////////////////////////////////////////
 
-    private int getKeyword(String s) throws IOException {
-        char c;
-        switch (s.length()) {
-            case 2: c=s.charAt(1);
-                if (c=='f') { if (s.charAt(0)=='i') return IF; }
-                else if (c=='n') { if (s.charAt(0)=='i') return IN; }
-                else if (c=='o') { if (s.charAt(0)=='d') return DO; }
-                break;
-            case 3: switch (s.charAt(0)) {
-                case 'a': if (s.charAt(2)=='d' && s.charAt(1)=='n') return AND; break;
-                case 'f': if (s.charAt(2)=='r' && s.charAt(1)=='o') return FOR; break;
-                case 'i': if (s.charAt(2)=='t' && s.charAt(1)=='n') return RESERVED;
-                case 'n': if (s.charAt(2)=='w' && s.charAt(1)=='e') return RESERVED;
-                case 't': if (s.charAt(2)=='y' && s.charAt(1)=='r') return TRY; break;
-                case 'v': if (s.charAt(2)=='r' && s.charAt(1)=='a') return VAR; break;
-                } break;
-            case 4: switch (s.charAt(0)) {
-                case 'b': return s.equals("byte") ? RESERVED : -1;
-                case 'c': c=s.charAt(3);
-                    if (c=='e') { if (s.charAt(2)=='s' && s.charAt(1)=='a') return CASE; }
-                    else if (c=='r') { if (s.charAt(2)=='a' && s.charAt(1)=='h') return RESERVED; }
-                    return -1;
-                case 'e': c=s.charAt(3);
-                    if (c=='e') { if (s.charAt(2)=='s' && s.charAt(1)=='l') return ELSE; }
-                    else if (c=='m') { if (s.charAt(2)=='u' && s.charAt(1)=='n') return RESERVED; }
-                    return -1;
-                case 'g': return s.equals("goto") ? RESERVED : -1;
-                case 'l': return s.equals("long") ? RESERVED : -1;
-                case 'n': return s.equals("null") ? NULL : -1;
-                case 't': c=s.charAt(3);
-                    if (c=='e') { if (s.charAt(2)=='u' && s.charAt(1)=='r') return TRUE; }
-                    else if (c=='s') { if (s.charAt(2)=='i' && s.charAt(1)=='h') return THIS; }
-                    return -1;
-                case 'w': if (s.equals("with")) return RESERVED; else return -1;
-                case 'v': if (s.equals("void")) return RESERVED; else return -1;
-                } break;
-            case 5: switch (s.charAt(2)) {
-                case 'a': return s.equals("class") ? RESERVED : -1;
-                case 'e': return s.equals("break") ? BREAK : -1;
-                case 'i': return s.equals("while") ? WHILE : -1;
-                case 'l': return s.equals("false") ? FALSE : -1;
-                case 'n': c=s.charAt(0);
-                    if (s.equals("const")) return RESERVED;
-                    else if (s.equals("final")) return RESERVED;
-                    return -1;
-                case 'o': c=s.charAt(0);
-                    if (c == 'c') return s.equals("float") ? RESERVED : -1;
-                    else if (c=='s') return s.equals("final") ? RESERVED : -1;
-                    break;
-                case 'p': return s.equals("super") ? RESERVED : -1;
-                case 'r': return s.equals("throw") ? THROW : -1;
-                case 't': return s.equals("catch") ? CATCH : -1;
-                } break;
-            case 6: switch (s.charAt(1)) {
-                case 'a': return s.equals("class") ? RESERVED : -1;
-                case 'e': c=s.charAt(0);
-                    if (s.equals("delete")) return RESERVED;
-                    else if (c=='r') return s.equals("return") ? RETURN : -1;
-                    break;
-                case 'h': return s.equals("throws") ? RESERVED : -1;
-                case 'o': return s.equals("double") ? RESERVED : -1;
-                case 's': return s.equals("assert") ? ASSERT : -1;
-                case 'u': return s.equals("public") ? RESERVED : -1;
-                case 'w': return s.equals("switch") ? SWITCH : -1;
-                case 'y': return s.equals("typeof") ? TYPEOF : -1;
-                } break;
-            case 7: switch (s.charAt(1)) {
-                case 'a': return s.equals("package") ? RESERVED : -1;
-                case 'e': return s.equals("default") ? DEFAULT : -1;
-                case 'i': return s.equals("finally") ? FINALLY : -1;
-                case 'o': return s.equals("boolean") ? RESERVED : -1;
-                case 'r': return s.equals("private") ? RESERVED : -1;
-                case 'x': return s.equals("extends") ? RESERVED : -1;
-                } break;
-            case 8: switch (s.charAt(0)) {
-                case 'a': return s.equals("abstract") ? RESERVED : -1;
-                case 'c': return s.equals("continue") ? CONTINUE : -1;
-                case 'd': return s.equals("debugger") ? RESERVED : -1;
-                case 'f': return s.equals("function") ? FUNCTION : -1;
-                case 'v': return s.equals("volatile") ? RESERVED : -1;
-                } break;
-            case 9: c=s.charAt(0);
-                if (c=='i') return s.equals("interface") ? RESERVED : -1;
-                else if (c=='p') return s.equals("protected") ? RESERVED : -1;
-                else if (c=='t') return s.equals("transient") ? RESERVED : -1;
-                break;
-            case 10: c=s.charAt(1);
-                if (c=='m') return s.equals("implements") ? RESERVED : -1;
-                else if (c=='n' && s.equals("instanceof")) return RESERVED;
-                break;
-            case 12: return s.equals("synchronized") ? RESERVED : -1;
-            }
+    private int getKeyword(String name) throws IOException {
+        //#switch(name)
+        case "if": return IF;
+        case "lt": return LT;
+        case "gt": return GT;
+        case "in": return IN;
+        case "do": return DO;
+        case "and": return AND;
+        case "for": return FOR;
+        case "int": return RESERVED;
+        case "new": return RESERVED;
+        case "try": return TRY;
+        case "var": return VAR;
+        case "byte": return RESERVED;
+        case "case": return CASE;
+        case "char": return RESERVED;
+        case "else": return ELSE;
+        case "enum": return RESERVED;
+        case "goto": return RESERVED;
+        case "long": return RESERVED;
+        case "null": return NULL;
+        case "true": return TRUE;
+        case "with": return RESERVED;
+        case "void": return RESERVED;
+        case "class": return RESERVED;
+        case "break": return BREAK;
+        case "while": return WHILE;
+        case "false": return FALSE;
+        case "const": return RESERVED;
+        case "final": return RESERVED;
+        case "super": return RESERVED;
+        case "throw": return THROW;
+        case "catch": return CATCH;
+        case "class": return RESERVED;
+        case "delete": return RESERVED;
+        case "return": return RETURN;
+        case "throws": return RESERVED;
+        case "double": return RESERVED;
+        case "assert": return ASSERT;
+        case "public": return RESERVED;
+        case "switch": return SWITCH;
+        case "typeof": return TYPEOF;
+        case "package": return RESERVED;
+        case "default": return DEFAULT;
+        case "finally": return FINALLY;
+        case "boolean": return RESERVED;
+        case "private": return RESERVED;
+        case "extends": return RESERVED;
+        case "abstract": return RESERVED;
+        case "continue": return CONTINUE;
+        case "debugger": return RESERVED;
+        case "function": return FUNCTION;
+        case "volatile": return RESERVED;
+        case "interface": return RESERVED;
+        case "protected": return RESERVED;
+        case "transient": return RESERVED;
+        case "implements": return RESERVED;
+        case "instanceof": return RESERVED;
+        case "synchronized": return RESERVED;
+        //#end
         return -1;
     }
 
@@ -227,11 +193,8 @@ class Lexer implements Tokens {
             }
         }
         
-        if (!isInteger) this.number = new Double(dval);
-        else if (Byte.MIN_VALUE <= longval && longval <= Byte.MAX_VALUE) this.number = new Byte((byte)longval);
-        else if (Short.MIN_VALUE <= longval && longval <= Short.MAX_VALUE) this.number = new Short((short)longval);
-        else if (Integer.MIN_VALUE <= longval && longval <= Integer.MAX_VALUE) this.number = new Integer((int)longval);
-        else this.number = new Double(longval);
+        if (!isInteger) this.number = JS.N(dval);
+        else this.number = JS.N(longval);
         return NUMBER;
     }
     
@@ -285,7 +248,7 @@ class Lexer implements Tokens {
         return STRING;
     }
 
-    public int _getToken() throws IOException {
+    private int _getToken() throws IOException {
         int c;
         do { c = in.read(); } while (c == '\u0020' || c == '\u0009' || c == '\u000C' || c == '\u000B' || c == '\n' );
         if (c == -1) return -1;
@@ -344,6 +307,8 @@ class Lexer implements Tokens {
         public void unread() throws IOException { unread((char)lastread); }
         public void unread(char c) throws IOException {
             reader.unread(c);
+            if(c == '\n') col = -1;
+            else col--;
             if (accumulator != null) accumulator.setLength(accumulator.length() - 1);
         }
         public boolean match(char c) throws IOException { if (peek() == c) { reader.read(); return true; } else return false; }
@@ -356,7 +321,11 @@ class Lexer implements Tokens {
             lastread = reader.read();
             if (accumulator != null) accumulator.append((char)lastread);
             if (lastread != '\n' && lastread != '\r') col++;
-            if (lastread == '\n') { parserLine = ++line; col = 0; }
+            if (lastread == '\n') {
+                // col is -1 if we just unread a newline, this is sort of ugly
+                if (col != -1) parserLine = ++line;
+                col = 0;
+            }
             return lastread;
         }
 
@@ -367,7 +336,7 @@ class Lexer implements Tokens {
             accumulator.append((char)lastread);
         }
         public String getString() throws IOException {
-            String ret = accumulator.toString();
+            String ret = accumulator.toString().intern();
             accumulator = null;
             return ret;
         }
@@ -381,7 +350,7 @@ class Lexer implements Tokens {
     private Object[] pushBackObjects = new Object[10];
 
     /** push back a token */
-    public void pushBackToken(int op, Object obj) {
+    public final void pushBackToken(int op, Object obj) {
         if (pushBackDepth >= pushBackInts.length - 1) {
             int[] newInts = new int[pushBackInts.length * 2];
             System.arraycopy(pushBackInts, 0, newInts, 0, pushBackInts.length);
@@ -396,17 +365,17 @@ class Lexer implements Tokens {
     }
 
     /** push back the most recently read token */
-    public void pushBackToken() { pushBackToken(op, number != null ? (Object)number : (Object)string); }
+    public final void pushBackToken() { pushBackToken(op, number != null ? (Object)number : (Object)string); }
 
     /** read a token but leave it in the stream */
-    public int peekToken() throws IOException {
+    public final int peekToken() throws IOException {
         int ret = getToken();
         pushBackToken();
         return ret;
     }
 
     /** read a token */
-    public int getToken() throws IOException {
+    public final int getToken() throws IOException {
         number = null;
         string = null;
         if (pushBackDepth == 0) {