Constants.java

/*
 * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */


package sun.tools.java;

/**
 * This interface defines constant that are used
 * throughout the compiler. It inherits from RuntimeConstants,
 * which is an autogenerated class that contains contstants
 * defined in the interpreter.
 *
 * WARNING: The contents of this source file are not part of any
 * supported API.  Code that depends on them does so at its own risk:
 * they are subject to change or removal without notice.
 *
 * @author      Arthur van Hoff
 */

public
interface Constants extends RuntimeConstants {

    /*
     * Enable/disable inclusion of certain debug tracing code in the
     * compiler.  When included, the tracing code may be selectively
     * enabled at runtime, otherwise we save the space/time overhead.
     * Should normally be 'false' for a release version.
     */
    public static final boolean tracing = true;

    /*
     * Frequently used identifiers
     */
    Identifier idAppend = Identifier.lookup("append");
    Identifier idClassInit = Identifier.lookup("<clinit>");
    Identifier idCode = Identifier.lookup("Code");
    Identifier idInit = Identifier.lookup("<init>");
    Identifier idLength = Identifier.lookup("length");
    Identifier idNull = Identifier.lookup("");
    Identifier idStar = Identifier.lookup("*");
    Identifier idSuper = Identifier.lookup("super");
    Identifier idThis = Identifier.lookup("this");
    Identifier idClass = Identifier.lookup("class");
    Identifier idToString = Identifier.lookup("toString");
    Identifier idValueOf = Identifier.lookup("valueOf");
    Identifier idNew = Identifier.lookup("new");
    Identifier idGetClass = Identifier.lookup("getClass");
    Identifier idTYPE = Identifier.lookup("TYPE");
    Identifier idFinallyReturnValue = Identifier.lookup("<return>");

    Identifier idJavaLang = Identifier.lookup("java.lang");

    Identifier idJavaLangCloneable = Identifier.lookup("java.lang.Cloneable");

    Identifier idJavaLangError = Identifier.lookup("java.lang.Error");
    Identifier idJavaLangException = Identifier.lookup("java.lang.Exception");
    Identifier idJavaLangObject = Identifier.lookup("java.lang.Object");
    Identifier idJavaLangClass = Identifier.lookup("java.lang.Class");
    Identifier idJavaLangRuntimeException =
          Identifier.lookup("java.lang.RuntimeException");
    Identifier idJavaLangString = Identifier.lookup("java.lang.String");
    Identifier idJavaLangStringBuffer =
          Identifier.lookup("java.lang.StringBuffer");
    Identifier idJavaLangThrowable = Identifier.lookup("java.lang.Throwable");

    Identifier idJavaIoSerializable = Identifier.lookup("java.io.Serializable");


    Identifier idConstantValue = Identifier.lookup("ConstantValue");
    Identifier idLocalVariableTable = Identifier.lookup("LocalVariableTable");
    Identifier idLineNumberTable = Identifier.lookup("LineNumberTable");
// JCOV
    Identifier idCoverageTable = Identifier.lookup("CoverageTable");
// end JCOV
    Identifier idSourceFile = Identifier.lookup("SourceFile");
    Identifier idDocumentation = Identifier.lookup("Documentation");
    Identifier idDeprecated = Identifier.lookup("Deprecated");
    Identifier idSynthetic = Identifier.lookup("Synthetic");
    Identifier idExceptions = Identifier.lookup("Exceptions");
    Identifier idInnerClasses = Identifier.lookup("InnerClasses");

    /* methods we need to know about */
    Identifier idClone = Identifier.lookup("clone");


    /* This is not a real signature marker, since it is also
     * an identifier constituent character.
     */
    char   SIGC_INNERCLASS      = '$';
    String SIG_INNERCLASS       = "$";

    String prefixThis           = "this$";
    String prefixVal            = "val$";
    String prefixLoc            = "loc$";
    String prefixAccess         = "access$";
    String prefixClass          = "class$";
    String prefixArray          = "array$";

    /*
     * Flags
     */
    int F_VERBOSE               = 1 << 0;
    int F_DUMP                  = 1 << 1;
    int F_WARNINGS              = 1 << 2;

    // The meaning of -g has changed, so F_DEBUG flag is removed.
    // public static final int F_DEBUG          = 1 << 3;
    int F_DEBUG_LINES           = 1 << 12;
    int F_DEBUG_VARS            = 1 << 13;
    int F_DEBUG_SOURCE          = 1 << 18;

    // The meaning of -O has changed, so F_OPTIMIZE flag is removed.
    // public static final int F_OPTIMIZE       = 1 << 4;
    int F_OPT                   = 1 << 14;
    int F_OPT_INTERCLASS        = 1 << 15;

    int F_DEPENDENCIES          = 1 << 5;

// JCOV
    int F_COVERAGE              = 1 << 6;
    int F_COVDATA               = 1 << 7;
// end JCOV

    int F_DEPRECATION           = 1 << 9;
    int F_PRINT_DEPENDENCIES    = 1 << 10;
    int F_VERSION12             = 1 << 11;


    int F_ERRORSREPORTED        = 1 << 16;

    int F_STRICTDEFAULT         = 1 << 17;

    /*
     * Modifiers.
     *
     * There has been much confusion regarding modifiers.  There
     * are a number of distinct usages:
     *
     *    - in classfiles to annotate classes, as per JVM pg. 102.
     *    - in classfiles to annotate methods, as per JVM pg. 104.
     *    - in classfiles to annotate InnerClass attributes, as per
     *          http://java.sun.com/products/jdk/1.1/docs/guide/innerclasses
     *    - in the compiler to record java source level modifiers,
     *          as per JLS pg. 157 et al., plus misc. info such as whether
     *          a method is deprecated
     *    - in the JVM to record misc. info, such as whether a method has
     *          has been compiled
     *
     * To make matters worse, the terms "access flags" and "modifiers"
     * are often used interchangably, and some information that might
     * make sense as a flag is expressed using attributes (ie. Synthetic).
     *
     * The constants defined herein have been divided by whether they
     * make sense only within the compiler (M_* and MM_*) or whether
     * they only make sense to the JVM (ACC_* and ACCM_*).  At an earlier
     * time these were all lumped together.  Future maintenance should
     * strive to keep the distinction clear.
     *
     * Note that modifier M_STRICTFP is not in general recoverable from
     * the ACC_STRICT bit in classfiles.
     *
     * Note also that the modifiers M_LOCAL and M_ANONYMOUS do not appear
     * in the InnerClass attribute, as they are above the first 16 bits.
     */

    // Modifiers meaningful to both Java source and the JVM.  These
    // have been kept the same bit in the M_* and ACC_* forms
    // to avoid destabilizing the compiler.
    int M_PUBLIC                = ACC_PUBLIC;
    int M_PRIVATE               = ACC_PRIVATE;
    int M_PROTECTED             = ACC_PROTECTED;
    int M_STATIC                = ACC_STATIC;
    int M_TRANSIENT             = ACC_TRANSIENT;
    int M_SYNCHRONIZED          = ACC_SYNCHRONIZED; // collides with ACC_SUPER
    int M_ABSTRACT              = ACC_ABSTRACT;
    int M_NATIVE                = ACC_NATIVE;
    int M_FINAL                 = ACC_FINAL;
    int M_VOLATILE              = ACC_VOLATILE;
    int M_INTERFACE             = ACC_INTERFACE;

    // Modifiers not meaningful to the JVM.  The JVM only allows 16 bits
    // for modifiers, so keeping these in the unusable bits after the first
    // 16 is a good idea.
    int M_ANONYMOUS             = 0x00010000;
    int M_LOCAL                 = 0x00020000;
    int M_DEPRECATED            = 0x00040000;
    int M_SYNTHETIC             = 0x00080000;
    int M_INLINEABLE            = 0x00100000;

    int M_STRICTFP              = 0x00200000;

    String paraDeprecated       = "@deprecated";

    // Masks for modifiers that apply to Java source code
    int MM_CLASS  = M_PUBLIC
                        | M_INTERFACE
                        | M_FINAL
                        | M_ABSTRACT
                        | M_STRICTFP;
    int MM_MEMBER = M_PUBLIC
                        | M_PRIVATE
                        | M_PROTECTED
                        | M_FINAL
                        | M_STATIC;
    int MM_FIELD  = MM_MEMBER
                        | M_TRANSIENT
                        | M_VOLATILE;
    int MM_METHOD = MM_MEMBER
                        | M_SYNCHRONIZED
                        | M_ABSTRACT
                        | M_NATIVE
                        | M_STRICTFP;

    // Masks for modifiers that apply to class files.
    // Note that the M_SYNTHETIC modifier is never written out to a class file.
    // Synthetic members are indicated using the "Synthetic" attribute.
    int ACCM_CLASS  = ACC_PUBLIC
                        | ACC_INTERFACE
                        | ACC_FINAL
                        | ACC_ABSTRACT
                        | ACC_SUPER
                        | ACC_STRICT;
    int ACCM_MEMBER = ACC_PUBLIC
                        | ACC_PRIVATE
                        | ACC_PROTECTED
                        | ACC_FINAL
                        | ACC_STATIC;
    // The M_ANONYMOUS and M_LOCAL modifiers are not mentioned in the
    // inner classes specification and are never written to classfiles.
    // Also note that ACC_SUPER should never be set in an InnerClass
    // attribute.
    int ACCM_INNERCLASS = ACC_PUBLIC
                        | ACC_PRIVATE
                        | ACC_PROTECTED
                        | ACC_STATIC
                        | ACC_ABSTRACT
                        | ACC_FINAL
                        | ACC_INTERFACE
                        | ACC_STRICT;
    int ACCM_FIELD  = ACCM_MEMBER
                        | ACC_TRANSIENT
                        | ACC_VOLATILE;
    int ACCM_METHOD = ACCM_MEMBER
                        | ACC_SYNCHRONIZED
                        | ACC_ABSTRACT
                        | ACC_NATIVE
                        | ACC_STRICT;

    /*
     * Type codes
     */
    int TC_BOOLEAN   = 0;
    int TC_BYTE      = 1;
    int TC_CHAR      = 2;
    int TC_SHORT     = 3;
    int TC_INT       = 4;
    int TC_LONG      = 5;
    int TC_FLOAT     = 6;
    int TC_DOUBLE    = 7;
    int TC_NULL      = 8;
    int TC_ARRAY     = 9;
    int TC_CLASS     = 10;
    int TC_VOID      = 11;
    int TC_METHOD    = 12;
    int TC_ERROR     = 13;

// JCOV
    /*
     * Cover's types
     */
    int CT_FIRST_KIND   = 1;
    int CT_METHOD       = 1;
    int CT_FIKT_METHOD  = 2;
    int CT_BLOCK        = 3;
    int CT_FIKT_RET     = 4;
    int CT_CASE         = 5;
    int CT_SWITH_WO_DEF = 6;
    int CT_BRANCH_TRUE  = 7;
    int CT_BRANCH_FALSE = 8;
    int CT_LAST_KIND    = 8;
// end JCOV

    /*
     * Type Masks
     */
    int TM_NULL      = 1 << TC_NULL;
    int TM_VOID      = 1 << TC_VOID;
    int TM_BOOLEAN   = 1 << TC_BOOLEAN;
    int TM_BYTE      = 1 << TC_BYTE;
    int TM_CHAR      = 1 << TC_CHAR;
    int TM_SHORT     = 1 << TC_SHORT;
    int TM_INT       = 1 << TC_INT;
    int TM_LONG      = 1 << TC_LONG;
    int TM_FLOAT     = 1 << TC_FLOAT;
    int TM_DOUBLE    = 1 << TC_DOUBLE;
    int TM_ARRAY     = 1 << TC_ARRAY;
    int TM_CLASS     = 1 << TC_CLASS;
    int TM_METHOD    = 1 << TC_METHOD;
    int TM_ERROR     = 1 << TC_ERROR;

    int TM_INT32     = TM_BYTE | TM_SHORT | TM_CHAR | TM_INT;
    int TM_NUM32     = TM_INT32 | TM_FLOAT;
    int TM_NUM64     = TM_LONG | TM_DOUBLE;
    int TM_INTEGER   = TM_INT32 | TM_LONG;
    int TM_REAL      = TM_FLOAT | TM_DOUBLE;
    int TM_NUMBER    = TM_INTEGER | TM_REAL;
    int TM_REFERENCE = TM_ARRAY | TM_CLASS | TM_NULL;

    /*
     * Class status
     */
    int CS_UNDEFINED    = 0;
    int CS_UNDECIDED    = 1;
    int CS_BINARY       = 2;
    int CS_SOURCE       = 3;
    int CS_PARSED       = 4;
    int CS_CHECKED      = 5;
    int CS_COMPILED     = 6;
    int CS_NOTFOUND     = 7;


    /*
     * Attributes
     */
    int ATT_ALL         = 0xFFFFFFFF;
    int ATT_CODE        = 1 << 1;
    int ATT_ALLCLASSES  = 1 << 2;

    /*
     * Number of bits used in file offsets.  The line number and
     * file offset are concatenated into a long, with enough room
     * for other information to be added later if desired (such as
     * token lengths).  For the moment explicit bit manipulations
     * are used to modify the fields.  This makes sense for efficiency
     * but at some point these ought to be better encapsulated.
     */
    int WHEREOFFSETBITS = 32;
    long MAXFILESIZE    = (1L << WHEREOFFSETBITS) - 1;
    long MAXLINENUMBER  = (1L << (64 - WHEREOFFSETBITS)) - 1;

    /*
     * Operators
     */
    int COMMA           = 0;
    int ASSIGN          = 1;

    int ASGMUL          = 2;
    int ASGDIV          = 3;
    int ASGREM          = 4;
    int ASGADD          = 5;
    int ASGSUB          = 6;
    int ASGLSHIFT       = 7;
    int ASGRSHIFT       = 8;
    int ASGURSHIFT      = 9;
    int ASGBITAND       = 10;
    int ASGBITOR        = 11;
    int ASGBITXOR       = 12;

    int COND            = 13;
    int OR              = 14;
    int AND             = 15;
    int BITOR           = 16;
    int BITXOR          = 17;
    int BITAND          = 18;
    int NE              = 19;
    int EQ              = 20;
    int GE              = 21;
    int GT              = 22;
    int LE              = 23;
    int LT              = 24;
    int INSTANCEOF      = 25;
    int LSHIFT          = 26;
    int RSHIFT          = 27;
    int URSHIFT         = 28;
    int ADD             = 29;
    int SUB             = 30;
    int DIV             = 31;
    int REM             = 32;
    int MUL             = 33;
    int CAST            = 34;           // (x)y
    int POS             = 35;           // +x
    int NEG             = 36;           // -x
    int NOT             = 37;
    int BITNOT          = 38;
    int PREINC          = 39;           // ++x
    int PREDEC          = 40;           // --x
    int NEWARRAY        = 41;
    int NEWINSTANCE     = 42;
    int NEWFROMNAME     = 43;
    int POSTINC         = 44;           // x++
    int POSTDEC         = 45;           // x--
    int FIELD           = 46;
    int METHOD          = 47;           // x(y)
    int ARRAYACCESS     = 48;           // x[y]
    int NEW             = 49;
    int INC             = 50;
    int DEC             = 51;

    int CONVERT         = 55;           // implicit conversion
    int EXPR            = 56;           // (x)
    int ARRAY           = 57;           // {x, y, ...}
    int GOTO            = 58;

    /*
     * Value tokens
     */
    int IDENT           = 60;
    int BOOLEANVAL      = 61;
    int BYTEVAL         = 62;
    int CHARVAL         = 63;
    int SHORTVAL        = 64;
    int INTVAL          = 65;
    int LONGVAL         = 66;
    int FLOATVAL        = 67;
    int DOUBLEVAL       = 68;
    int STRINGVAL       = 69;

    /*
     * Type keywords
     */
    int BYTE            = 70;
    int CHAR            = 71;
    int SHORT           = 72;
    int INT             = 73;
    int LONG            = 74;
    int FLOAT           = 75;
    int DOUBLE          = 76;
    int VOID            = 77;
    int BOOLEAN         = 78;

    /*
     * Expression keywords
     */
    int TRUE            = 80;
    int FALSE           = 81;
    int THIS            = 82;
    int SUPER           = 83;
    int NULL            = 84;

    /*
     * Statement keywords
     */
    int IF              = 90;
    int ELSE            = 91;
    int FOR             = 92;
    int WHILE           = 93;
    int DO              = 94;
    int SWITCH          = 95;
    int CASE            = 96;
    int DEFAULT         = 97;
    int BREAK           = 98;
    int CONTINUE        = 99;
    int RETURN          = 100;
    int TRY             = 101;
    int CATCH           = 102;
    int FINALLY         = 103;
    int THROW           = 104;
    int STAT            = 105;
    int EXPRESSION      = 106;
    int DECLARATION     = 107;
    int VARDECLARATION  = 108;

    /*
     * Declaration keywords
     */
    int IMPORT          = 110;
    int CLASS           = 111;
    int EXTENDS         = 112;
    int IMPLEMENTS      = 113;
    int INTERFACE       = 114;
    int PACKAGE         = 115;

    /*
     * Modifier keywords
     */
    int PRIVATE         = 120;
    int PUBLIC          = 121;
    int PROTECTED       = 122;
    int CONST           = 123;
    int STATIC          = 124;
    int TRANSIENT       = 125;
    int SYNCHRONIZED    = 126;
    int NATIVE          = 127;
    int FINAL           = 128;
    int VOLATILE        = 129;
    int ABSTRACT        = 130;
    int STRICTFP        = 131;

    /*
     * Punctuation
     */
    int SEMICOLON       = 135;
    int COLON           = 136;
    int QUESTIONMARK    = 137;
    int LBRACE          = 138;
    int RBRACE          = 139;
    int LPAREN          = 140;
    int RPAREN          = 141;
    int LSQBRACKET      = 142;
    int RSQBRACKET      = 143;
    int THROWS          = 144;

    /*
     * Special tokens
     */
    int ERROR           = 145;          // an error
    int COMMENT         = 146;          // not used anymore.
    int TYPE            = 147;
    int LENGTH          = 148;
    int INLINERETURN    = 149;
    int INLINEMETHOD    = 150;
    int INLINENEWINSTANCE       = 151;

    /*
     * Operator precedence
     */
    int opPrecedence[] = {
        10, 11, 11, 11, 11, 11, 11, 11, 11, 11,
        11, 11, 11, 12, 13, 14, 15, 16, 17, 18,
        18, 19, 19, 19, 19, 19, 20, 20, 20, 21,
        21, 22, 22, 22, 23, 24, 24, 24, 24, 24,
        24, 25, 25, 26, 26, 26, 26, 26, 26
    };

    /*
     * Operator names
     */
    String opNames[] = {
        ",",    "=",    "*=",   "/=",   "%=",
        "+=",   "-=",   "<<=",  ">>=",  ">>>=",
        "&=",   "|=",   "^=",   "?:",   "||",
        "&&",   "|",    "^",    "&",    "!=",
        "==",   ">=",   ">",    "<=",   "<",
        "instanceof", "<<", ">>", ">>>", "+",
        "-",    "/",    "%",    "*",    "cast",
        "+",    "-",    "!",    "~",    "++",
        "--",   "new",  "new",  "new",  "++",
        "--",   "field","method","[]",  "new",
        "++",   "--",   null,   null,   null,

        "convert", "expr", "array", "goto", null,

        "Identifier", "boolean", "byte", "char", "short",
        "int", "long", "float", "double", "string",

        "byte", "char", "short", "int", "long",
        "float", "double", "void", "boolean", null,

        "true", "false", "this", "super", "null",
        null,   null,   null,   null,   null,

        "if",   "else", "for",  "while","do",
        "switch", "case", "default", "break", "continue",
        "return", "try", "catch", "finally", "throw",
        "stat", "expression", "declaration", "declaration", null,

        "import", "class", "extends", "implements", "interface",
        "package", null, null,  null,   null,

        "private", "public", "protected", "const", "static",
        "transient", "synchronized", "native", "final", "volatile",
        "abstract", "strictfp", null, null, null,

        ";",    ":",    "?",    "{",    "}",
        "(",    ")",    "[",    "]",    "throws",
        "error", "comment", "type", "length", "inline-return",
        "inline-method", "inline-new"
    };
}