Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   *
   * This Source Code Form is subject to the terms of the Mozilla Public
   * License, v. 2.0. If a copy of the MPL was not distributed with this
   * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
  
  package org.mozilla.javascript;

This class implements the JavaScript scanner. It is based on the C source files jsscan.c and jsscan.h in the jsref package.

Author(s):
Mike McCabe
Brendan Eich
See also:
Parser
 
 
 public class Token
 {
     public static enum CommentType {
         LINE, BLOCK_COMMENT, JSDOC, HTML
     }
 
     // debug flags
     public static final boolean printTrees = false;
     static final boolean printICode = false;
     static final boolean printNames =  || ;

    
Token types. These values correspond to JSTokenType values in jsscan.c.
 
 
     public final static int
     // start enum
         ERROR          = -1, // well-known as the only code < EOF
         EOF            = 0,  // end of file token - (not EOF_CHAR)
         EOL            = 1,  // end of line
 
         // Interpreter reuses the following as bytecodes
         FIRST_BYTECODE_TOKEN    = 2,
 
         ENTERWITH      = 2,
         LEAVEWITH      = 3,
         RETURN         = 4,
         GOTO           = 5,
         IFEQ           = 6,
         IFNE           = 7,
         SETNAME        = 8,
         BITOR          = 9,
         BITXOR         = 10,
         BITAND         = 11,
         EQ             = 12,
         NE             = 13,
         LT             = 14,
         LE             = 15,
         GT             = 16,
         GE             = 17,
         LSH            = 18,
         RSH            = 19,
         URSH           = 20,
         ADD            = 21,
         SUB            = 22,
         MUL            = 23,
         DIV            = 24,
         MOD            = 25,
         NOT            = 26,
         BITNOT         = 27,
         POS            = 28,
         NEG            = 29,
         NEW            = 30,
         DELPROP        = 31,
         TYPEOF         = 32,
         GETPROP        = 33,
         GETPROPNOWARN  = 34,
         SETPROP        = 35,
         GETELEM        = 36,
         SETELEM        = 37,
         CALL           = 38,
         NAME           = 39,
         NUMBER         = 40,
         STRING         = 41,
         NULL           = 42,
         THIS           = 43,
         FALSE          = 44,
         TRUE           = 45,
         SHEQ           = 46,   // shallow equality (===)
         SHNE           = 47,   // shallow inequality (!==)
         REGEXP         = 48,
         BINDNAME       = 49,
         THROW          = 50,
         RETHROW        = 51, // rethrow caught exception: catch (e if ) use it
         IN             = 52,
         INSTANCEOF     = 53,
         LOCAL_LOAD     = 54,
         GETVAR         = 55,
        SETVAR         = 56,
        CATCH_SCOPE    = 57,
        ENUM_INIT_KEYS = 58,
        ENUM_INIT_VALUES = 59,
        ENUM_INIT_ARRAY= 60,
        ENUM_NEXT      = 61,
        ENUM_ID        = 62,
        THISFN         = 63,
        RETURN_RESULT  = 64, // to return previously stored return result
        ARRAYLIT       = 65, // array literal
        OBJECTLIT      = 66, // object literal
        GET_REF        = 67, // *reference
        SET_REF        = 68, // *reference    = something
        DEL_REF        = 69, // delete reference
        REF_CALL       = 70, // f(args)    = something or f(args)++
        REF_SPECIAL    = 71, // reference for special properties like __proto
        YIELD          = 72,  // JS 1.7 yield pseudo keyword
        STRICT_SETNAME = 73,
        // For XML support:
        DEFAULTNAMESPACE = 74, // default xml namespace =
        ESCXMLATTR     = 75,
        ESCXMLTEXT     = 76,
        REF_MEMBER     = 77, // Reference for x.@y, x..y etc.
        REF_NS_MEMBER  = 78, // Reference for x.ns::y, x..ns::y etc.
        REF_NAME       = 79, // Reference for @y, @[y] etc.
        REF_NS_NAME    = 80; // Reference for ns::y, @ns::y@[y] etc.
        // End of interpreter bytecodes
    public final static int
        LAST_BYTECODE_TOKEN    = ,
        TRY            = 81,
        SEMI           = 82,  // semicolon
        LB             = 83,  // left and right brackets
        RB             = 84,
        LC             = 85,  // left and right curlies (braces)
        RC             = 86,
        LP             = 87,  // left and right parentheses
        RP             = 88,
        COMMA          = 89,  // comma operator
        ASSIGN         = 90,  // simple assignment  (=)
        ASSIGN_BITOR   = 91,  // |=
        ASSIGN_BITXOR  = 92,  // ^=
        ASSIGN_BITAND  = 93,  // |=
        ASSIGN_LSH     = 94,  // <<=
        ASSIGN_RSH     = 95,  // >>=
        ASSIGN_URSH    = 96,  // >>>=
        ASSIGN_ADD     = 97,  // +=
        ASSIGN_SUB     = 98,  // -=
        ASSIGN_MUL     = 99,  // *=
        ASSIGN_DIV     = 100,  // /=
        ASSIGN_MOD     = 101;  // %=
    public final static int
        FIRST_ASSIGN   = ,
        LAST_ASSIGN    = ,
        HOOK           = 102, // conditional (?:)
        COLON          = 103,
        OR             = 104, // logical or (||)
        AND            = 105, // logical and (&&)
        INC            = 106, // increment/decrement (++ --)
        DEC            = 107,
        DOT            = 108, // member operator (.)
        FUNCTION       = 109, // function keyword
        EXPORT         = 110, // export keyword
        IMPORT         = 111, // import keyword
        IF             = 112, // if keyword
        ELSE           = 113, // else keyword
        SWITCH         = 114, // switch keyword
        CASE           = 115, // case keyword
        DEFAULT        = 116, // default keyword
        WHILE          = 117, // while keyword
        DO             = 118, // do keyword
        FOR            = 119, // for keyword
        BREAK          = 120, // break keyword
        CONTINUE       = 121, // continue keyword
        VAR            = 122, // var keyword
        WITH           = 123, // with keyword
        CATCH          = 124, // catch keyword
        FINALLY        = 125, // finally keyword
        VOID           = 126, // void keyword
        RESERVED       = 127, // reserved keywords
        EMPTY          = 128,
        /* types used for the parse tree - these never get returned
         * by the scanner.
         */
        BLOCK          = 129, // statement block
        LABEL          = 130, // label
        TARGET         = 131,
        LOOP           = 132,
        EXPR_VOID      = 133, // expression statement in functions
        EXPR_RESULT    = 134, // expression statement in scripts
        JSR            = 135,
        SCRIPT         = 136, // top-level node for entire script
        TYPEOFNAME     = 137, // for typeof(simple-name)
        USE_STACK      = 138,
        SETPROP_OP     = 139, // x.y op= something
        SETELEM_OP     = 140, // x[y] op= something
        LOCAL_BLOCK    = 141,
        SET_REF_OP     = 142, // *reference op= something
        // For XML support:
        DOTDOT         = 143,  // member operator (..)
        COLONCOLON     = 144,  // namespace::name
        XML            = 145,  // XML type
        DOTQUERY       = 146,  // .() -- e.g., x.emps.emp.(name == "terry")
        XMLATTR        = 147,  // @
        XMLEND         = 148,
        // Optimizer-only-tokens
        TO_OBJECT      = 149,
        TO_DOUBLE      = 150,
        GET            = 151,  // JS 1.5 get pseudo keyword
        SET            = 152,  // JS 1.5 set pseudo keyword
        LET            = 153,  // JS 1.7 let pseudo keyword
        CONST          = 154,
        SETCONST       = 155,
        SETCONSTVAR    = 156,
        ARRAYCOMP      = 157,  // array comprehension
        LETEXPR        = 158,
        WITHEXPR       = 159,
        DEBUGGER       = 160,
        COMMENT        = 161,
        GENEXPR        = 162,
        LAST_TOKEN     = 163;

    
Returns a name for the token. If Rhino is compiled with certain hardcoded debugging flags in this file, it calls #typeToName; otherwise it returns a string whose value is the token number.
    public static String name(int token)
    {
        if (!) {
            return String.valueOf(token);
        }
        return typeToName(token);
    }

    
Always returns a human-readable string for the token name. For instance, FINALLY has the name "FINALLY".

Parameters:
token the token code
Returns:
the actual name for the token code
    public static String typeToName(int token) {
        switch (token) {
          case :           return "ERROR";
          case :             return "EOF";
          case :             return "EOL";
          case :       return "ENTERWITH";
          case :       return "LEAVEWITH";
          case :          return "RETURN";
          case :            return "GOTO";
          case :            return "IFEQ";
          case :            return "IFNE";
          case :         return "SETNAME";
          case :           return "BITOR";
          case :          return "BITXOR";
          case :          return "BITAND";
          case :              return "EQ";
          case :              return "NE";
          case :              return "LT";
          case :              return "LE";
          case :              return "GT";
          case :              return "GE";
          case :             return "LSH";
          case :             return "RSH";
          case :            return "URSH";
          case :             return "ADD";
          case :             return "SUB";
          case :             return "MUL";
          case :             return "DIV";
          case :             return "MOD";
          case :             return "NOT";
          case :          return "BITNOT";
          case :             return "POS";
          case :             return "NEG";
          case :             return "NEW";
          case :         return "DELPROP";
          case :          return "TYPEOF";
          case :         return "GETPROP";
          case :   return "GETPROPNOWARN";
          case :         return "SETPROP";
          case :         return "GETELEM";
          case :         return "SETELEM";
          case :            return "CALL";
          case :            return "NAME";
          case :          return "NUMBER";
          case :          return "STRING";
          case :            return "NULL";
          case :            return "THIS";
          case :           return "FALSE";
          case :            return "TRUE";
          case :            return "SHEQ";
          case :            return "SHNE";
          case :          return "REGEXP";
          case :        return "BINDNAME";
          case :           return "THROW";
          case :         return "RETHROW";
          case :              return "IN";
          case :      return "INSTANCEOF";
          case :      return "LOCAL_LOAD";
          case :          return "GETVAR";
          case :          return "SETVAR";
          case :     return "CATCH_SCOPE";
          case :  return "ENUM_INIT_KEYS";
          case :return "ENUM_INIT_VALUES";
          case return "ENUM_INIT_ARRAY";
          case :       return "ENUM_NEXT";
          case :         return "ENUM_ID";
          case :          return "THISFN";
          case :   return "RETURN_RESULT";
          case :        return "ARRAYLIT";
          case :       return "OBJECTLIT";
          case :         return "GET_REF";
          case :         return "SET_REF";
          case :         return "DEL_REF";
          case :        return "REF_CALL";
          case :     return "REF_SPECIAL";
          case :return "DEFAULTNAMESPACE";
          case :      return "ESCXMLTEXT";
          case :      return "ESCXMLATTR";
          case :      return "REF_MEMBER";
          case :   return "REF_NS_MEMBER";
          case :        return "REF_NAME";
          case :     return "REF_NS_NAME";
          case :             return "TRY";
          case :            return "SEMI";
          case :              return "LB";
          case :              return "RB";
          case :              return "LC";
          case :              return "RC";
          case :              return "LP";
          case :              return "RP";
          case :           return "COMMA";
          case :          return "ASSIGN";
          case :    return "ASSIGN_BITOR";
          case :   return "ASSIGN_BITXOR";
          case :   return "ASSIGN_BITAND";
          case :      return "ASSIGN_LSH";
          case :      return "ASSIGN_RSH";
          case :     return "ASSIGN_URSH";
          case :      return "ASSIGN_ADD";
          case :      return "ASSIGN_SUB";
          case :      return "ASSIGN_MUL";
          case :      return "ASSIGN_DIV";
          case :      return "ASSIGN_MOD";
          case :            return "HOOK";
          case :           return "COLON";
          case :              return "OR";
          case :             return "AND";
          case :             return "INC";
          case :             return "DEC";
          case :             return "DOT";
          case :        return "FUNCTION";
          case :          return "EXPORT";
          case :          return "IMPORT";
          case :              return "IF";
          case :            return "ELSE";
          case :          return "SWITCH";
          case :            return "CASE";
          case :         return "DEFAULT";
          case :           return "WHILE";
          case :              return "DO";
          case :             return "FOR";
          case :           return "BREAK";
          case :        return "CONTINUE";
          case :             return "VAR";
          case :            return "WITH";
          case :           return "CATCH";
          case :         return "FINALLY";
          case :            return "VOID";
          case :        return "RESERVED";
          case :           return "EMPTY";
          case :           return "BLOCK";
          case :           return "LABEL";
          case :          return "TARGET";
          case :            return "LOOP";
          case :       return "EXPR_VOID";
          case :     return "EXPR_RESULT";
          case :             return "JSR";
          case :          return "SCRIPT";
          case :      return "TYPEOFNAME";
          case :       return "USE_STACK";
          case :      return "SETPROP_OP";
          case :      return "SETELEM_OP";
          case :     return "LOCAL_BLOCK";
          case :      return "SET_REF_OP";
          case :          return "DOTDOT";
          case :      return "COLONCOLON";
          case :             return "XML";
          case :        return "DOTQUERY";
          case :         return "XMLATTR";
          case :          return "XMLEND";
          case :       return "TO_OBJECT";
          case :       return "TO_DOUBLE";
          case :             return "GET";
          case :             return "SET";
          case :             return "LET";
          case :           return "YIELD";
          case :           return "CONST";
          case :        return "SETCONST";
          case :       return "ARRAYCOMP";
          case :        return "WITHEXPR";
          case :         return "LETEXPR";
          case :        return "DEBUGGER";
          case :         return "COMMENT";
          case :         return "GENEXPR";
        }
        // Token without name
        throw new IllegalStateException(String.valueOf(token));
    }

    
Convert a keyword token to a name string for use with the Context.FEATURE_RESERVED_KEYWORD_AS_IDENTIFIER feature.

Parameters:
token A token
Returns:
the corresponding name string
    public static String keywordToName(int token) {
        switch (token) {
            case .:      return "break";
            case .:       return "case";
            case .:   return "continue";
            case .:    return "default";
            case .:    return "delete";
            case .:         return "do";
            case .:       return "else";
            case .:      return "false";
            case .:        return "for";
            case .:   return "function";
            case .:         return "if";
            case .:         return "in";
            case .:        return "let";
            case .:        return "new";
            case .:       return "null";
            case .:     return "return";
            case .:     return "switch";
            case .:       return "this";
            case .:       return "true";
            case .:     return "typeof";
            case .:        return "var";
            case .:       return "void";
            case .:      return "while";
            case .:       return "with";
            case .:      return "yield";
            case .:      return "catch";
            case .:      return "const";
            case .:   return "debugger";
            case .:    return "finally";
            case .return "instanceof";
            case .:      return "throw";
            case .:        return "try";
            default:               return null;
        }
    }

    
Return true if the passed code is a valid Token constant.

Parameters:
code a potential token code
Returns:
true if it's a known token
    public static boolean isValidToken(int code) {
        return code >= 
                && code <= ;
    }
New to GrepCode? Check out our FAQ X