From 89bda83e0570ab87c6e449f5955613d5385e90b3 Mon Sep 17 00:00:00 2001 From: "alexanders@b2ef00c0-3703-41da-baef-cfe82387ac0c" Date: Wed, 3 Feb 2010 00:50:41 +0000 Subject: removed obsolete svn folder from hg tree --HG-- extra : convert_revision : svn%3Ab2ef00c0-3703-41da-baef-cfe82387ac0c/trunk%408 --- .../src/org/mozilla/javascript/Token.java | 436 +++++++++++++++++++++ 1 file changed, 436 insertions(+) create mode 100644 infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java (limited to 'infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java') diff --git a/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java new file mode 100644 index 0000000..be96487 --- /dev/null +++ b/infrastructure/rhino1_7R1/src/org/mozilla/javascript/Token.java @@ -0,0 +1,436 @@ +/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is Rhino code, released + * May 6, 1999. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1997-1999 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Roger Lawrence + * Mike McCabe + * Igor Bukanov + * Bob Jervis + * Milen Nankov + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License Version 2 or later (the "GPL"), in which + * case the provisions of the GPL are applicable instead of those above. If + * you wish to allow use of your version of this file only under the terms of + * the GPL and not to allow others to use your version of this file under the + * MPL, indicate your decision by deleting the provisions above and replacing + * them with the notice and other provisions required by the GPL. If you do + * not delete the provisions above, a recipient may use your version of this + * file under either the MPL or the GPL. + * + * ***** END LICENSE BLOCK ***** */ + +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. + * + * @see org.mozilla.javascript.Parser + * + * @author Mike McCabe + * @author Brendan Eich + */ + +public class Token +{ + + // debug flags + public static final boolean printTrees = + /*APPJET: some info not generated with this off; we disable + actual printing in Interpreter and CodeGen */true; + static final boolean printICode = false; + static final boolean printNames = printTrees || printICode; + + /** + * 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 + + // For XML support: + DEFAULTNAMESPACE = 73, // default xml namespace = + ESCXMLATTR = 74, + ESCXMLTEXT = 75, + REF_MEMBER = 76, // Reference for x.@y, x..y etc. + REF_NS_MEMBER = 77, // Reference for x.ns::y, x..ns::y etc. + REF_NAME = 78, // Reference for @y, @[y] etc. + REF_NS_NAME = 79; // Reference for ns::y, @ns::y@[y] etc. + + // End of interpreter bytecodes + public final static int + LAST_BYTECODE_TOKEN = REF_NS_NAME, + + TRY = 80, + SEMI = 81, // semicolon + LB = 82, // left and right brackets + RB = 83, + LC = 84, // left and right curlies (braces) + RC = 85, + LP = 86, // left and right parentheses + RP = 87, + COMMA = 88, // comma operator + + ASSIGN = 89, // simple assignment (=) + ASSIGN_BITOR = 90, // |= + ASSIGN_BITXOR = 91, // ^= + ASSIGN_BITAND = 92, // |= + ASSIGN_LSH = 93, // <<= + ASSIGN_RSH = 94, // >>= + ASSIGN_URSH = 95, // >>>= + ASSIGN_ADD = 96, // += + ASSIGN_SUB = 97, // -= + ASSIGN_MUL = 98, // *= + ASSIGN_DIV = 99, // /= + ASSIGN_MOD = 100; // %= + + public final static int + FIRST_ASSIGN = ASSIGN, + LAST_ASSIGN = ASSIGN_MOD, + + HOOK = 101, // conditional (?:) + COLON = 102, + OR = 103, // logical or (||) + AND = 104, // logical and (&&) + INC = 105, // increment/decrement (++ --) + DEC = 106, + DOT = 107, // member operator (.) + FUNCTION = 108, // function keyword + EXPORT = 109, // export keyword + IMPORT = 110, // import keyword + IF = 111, // if keyword + ELSE = 112, // else keyword + SWITCH = 113, // switch keyword + CASE = 114, // case keyword + DEFAULT = 115, // default keyword + WHILE = 116, // while keyword + DO = 117, // do keyword + FOR = 118, // for keyword + BREAK = 119, // break keyword + CONTINUE = 120, // continue keyword + VAR = 121, // var keyword + WITH = 122, // with keyword + CATCH = 123, // catch keyword + FINALLY = 124, // finally keyword + VOID = 125, // void keyword + RESERVED = 126, // reserved keywords + + EMPTY = 127, + + /* types used for the parse tree - these never get returned + * by the scanner. + */ + + BLOCK = 128, // statement block + LABEL = 129, // label + TARGET = 130, + LOOP = 131, + EXPR_VOID = 132, // expression statement in functions + EXPR_RESULT = 133, // expression statement in scripts + JSR = 134, + SCRIPT = 135, // top-level node for entire script + TYPEOFNAME = 136, // for typeof(simple-name) + USE_STACK = 137, + SETPROP_OP = 138, // x.y op= something + SETELEM_OP = 139, // x[y] op= something + LOCAL_BLOCK = 140, + SET_REF_OP = 141, // *reference op= something + + // For XML support: + DOTDOT = 142, // member operator (..) + COLONCOLON = 143, // namespace::name + XML = 144, // XML type + DOTQUERY = 145, // .() -- e.g., x.emps.emp.(name == "terry") + XMLATTR = 146, // @ + XMLEND = 147, + + // Optimizer-only-tokens + TO_OBJECT = 148, + TO_DOUBLE = 149, + + GET = 150, // JS 1.5 get pseudo keyword + SET = 151, // JS 1.5 set pseudo keyword + LET = 152, // JS 1.7 let pseudo keyword + CONST = 153, + SETCONST = 154, + SETCONSTVAR = 155, + ARRAYCOMP = 156, // array comprehension + LETEXPR = 157, + WITHEXPR = 158, + DEBUGGER = 159, + LAST_TOKEN = 159; + + public static String name(int token) + { + if (!printNames) { + return String.valueOf(token); + } + switch (token) { + case ERROR: return "ERROR"; + case EOF: return "EOF"; + case EOL: return "EOL"; + case ENTERWITH: return "ENTERWITH"; + case LEAVEWITH: return "LEAVEWITH"; + case RETURN: return "RETURN"; + case GOTO: return "GOTO"; + case IFEQ: return "IFEQ"; + case IFNE: return "IFNE"; + case SETNAME: return "SETNAME"; + case BITOR: return "BITOR"; + case BITXOR: return "BITXOR"; + case BITAND: return "BITAND"; + case EQ: return "EQ"; + case NE: return "NE"; + case LT: return "LT"; + case LE: return "LE"; + case GT: return "GT"; + case GE: return "GE"; + case LSH: return "LSH"; + case RSH: return "RSH"; + case URSH: return "URSH"; + case ADD: return "ADD"; + case SUB: return "SUB"; + case MUL: return "MUL"; + case DIV: return "DIV"; + case MOD: return "MOD"; + case NOT: return "NOT"; + case BITNOT: return "BITNOT"; + case POS: return "POS"; + case NEG: return "NEG"; + case NEW: return "NEW"; + case DELPROP: return "DELPROP"; + case TYPEOF: return "TYPEOF"; + case GETPROP: return "GETPROP"; + case GETPROPNOWARN: return "GETPROPNOWARN"; + case SETPROP: return "SETPROP"; + case GETELEM: return "GETELEM"; + case SETELEM: return "SETELEM"; + case CALL: return "CALL"; + case NAME: return "NAME"; + case NUMBER: return "NUMBER"; + case STRING: return "STRING"; + case NULL: return "NULL"; + case THIS: return "THIS"; + case FALSE: return "FALSE"; + case TRUE: return "TRUE"; + case SHEQ: return "SHEQ"; + case SHNE: return "SHNE"; + case REGEXP: return "OBJECT"; + case BINDNAME: return "BINDNAME"; + case THROW: return "THROW"; + case RETHROW: return "RETHROW"; + case IN: return "IN"; + case INSTANCEOF: return "INSTANCEOF"; + case LOCAL_LOAD: return "LOCAL_LOAD"; + case GETVAR: return "GETVAR"; + case SETVAR: return "SETVAR"; + case CATCH_SCOPE: return "CATCH_SCOPE"; + case ENUM_INIT_KEYS: return "ENUM_INIT_KEYS"; + case ENUM_INIT_VALUES:return "ENUM_INIT_VALUES"; + case ENUM_INIT_ARRAY: return "ENUM_INIT_ARRAY"; + case ENUM_NEXT: return "ENUM_NEXT"; + case ENUM_ID: return "ENUM_ID"; + case THISFN: return "THISFN"; + case RETURN_RESULT: return "RETURN_RESULT"; + case ARRAYLIT: return "ARRAYLIT"; + case OBJECTLIT: return "OBJECTLIT"; + case GET_REF: return "GET_REF"; + case SET_REF: return "SET_REF"; + case DEL_REF: return "DEL_REF"; + case REF_CALL: return "REF_CALL"; + case REF_SPECIAL: return "REF_SPECIAL"; + case DEFAULTNAMESPACE:return "DEFAULTNAMESPACE"; + case ESCXMLTEXT: return "ESCXMLTEXT"; + case ESCXMLATTR: return "ESCXMLATTR"; + case REF_MEMBER: return "REF_MEMBER"; + case REF_NS_MEMBER: return "REF_NS_MEMBER"; + case REF_NAME: return "REF_NAME"; + case REF_NS_NAME: return "REF_NS_NAME"; + case TRY: return "TRY"; + case SEMI: return "SEMI"; + case LB: return "LB"; + case RB: return "RB"; + case LC: return "LC"; + case RC: return "RC"; + case LP: return "LP"; + case RP: return "RP"; + case COMMA: return "COMMA"; + case ASSIGN: return "ASSIGN"; + case ASSIGN_BITOR: return "ASSIGN_BITOR"; + case ASSIGN_BITXOR: return "ASSIGN_BITXOR"; + case ASSIGN_BITAND: return "ASSIGN_BITAND"; + case ASSIGN_LSH: return "ASSIGN_LSH"; + case ASSIGN_RSH: return "ASSIGN_RSH"; + case ASSIGN_URSH: return "ASSIGN_URSH"; + case ASSIGN_ADD: return "ASSIGN_ADD"; + case ASSIGN_SUB: return "ASSIGN_SUB"; + case ASSIGN_MUL: return "ASSIGN_MUL"; + case ASSIGN_DIV: return "ASSIGN_DIV"; + case ASSIGN_MOD: return "ASSIGN_MOD"; + case HOOK: return "HOOK"; + case COLON: return "COLON"; + case OR: return "OR"; + case AND: return "AND"; + case INC: return "INC"; + case DEC: return "DEC"; + case DOT: return "DOT"; + case FUNCTION: return "FUNCTION"; + case EXPORT: return "EXPORT"; + case IMPORT: return "IMPORT"; + case IF: return "IF"; + case ELSE: return "ELSE"; + case SWITCH: return "SWITCH"; + case CASE: return "CASE"; + case DEFAULT: return "DEFAULT"; + case WHILE: return "WHILE"; + case DO: return "DO"; + case FOR: return "FOR"; + case BREAK: return "BREAK"; + case CONTINUE: return "CONTINUE"; + case VAR: return "VAR"; + case WITH: return "WITH"; + case CATCH: return "CATCH"; + case FINALLY: return "FINALLY"; + case VOID: return "VOID"; + case RESERVED: return "RESERVED"; + case EMPTY: return "EMPTY"; + case BLOCK: return "BLOCK"; + case LABEL: return "LABEL"; + case TARGET: return "TARGET"; + case LOOP: return "LOOP"; + case EXPR_VOID: return "EXPR_VOID"; + case EXPR_RESULT: return "EXPR_RESULT"; + case JSR: return "JSR"; + case SCRIPT: return "SCRIPT"; + case TYPEOFNAME: return "TYPEOFNAME"; + case USE_STACK: return "USE_STACK"; + case SETPROP_OP: return "SETPROP_OP"; + case SETELEM_OP: return "SETELEM_OP"; + case LOCAL_BLOCK: return "LOCAL_BLOCK"; + case SET_REF_OP: return "SET_REF_OP"; + case DOTDOT: return "DOTDOT"; + case COLONCOLON: return "COLONCOLON"; + case XML: return "XML"; + case DOTQUERY: return "DOTQUERY"; + case XMLATTR: return "XMLATTR"; + case XMLEND: return "XMLEND"; + case TO_OBJECT: return "TO_OBJECT"; + case TO_DOUBLE: return "TO_DOUBLE"; + case GET: return "GET"; + case SET: return "SET"; + case LET: return "LET"; + case YIELD: return "YIELD"; + case CONST: return "CONST"; + case SETCONST: return "SETCONST"; + case ARRAYCOMP: return "ARRAYCOMP"; + case WITHEXPR: return "WITHEXPR"; + case LETEXPR: return "LETEXPR"; + case DEBUGGER: return "DEBUGGER"; + } + + // Token without name + throw new IllegalStateException(String.valueOf(token)); + } +} -- cgit v1.2.3