History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/tools/java/Constants.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/tools/java/Constants.java+591−0
@@ -0,0 +1,591 @@
1+/*
2+ * Copyright (c) 1994, 2004, Oracle and/or its affiliates. All rights reserved.
3+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+ *
5+ * This code is free software; you can redistribute it and/or modify it
6+ * under the terms of the GNU General Public License version 2 only, as
7+ * published by the Free Software Foundation. Oracle designates this
8+ * particular file as subject to the "Classpath" exception as provided
9+ * by Oracle in the LICENSE file that accompanied this code.
10+ *
11+ * This code is distributed in the hope that it will be useful, but WITHOUT
12+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14+ * version 2 for more details (a copy is included in the LICENSE file that
15+ * accompanied this code).
16+ *
17+ * You should have received a copy of the GNU General Public License version
18+ * 2 along with this work; if not, write to the Free Software Foundation,
19+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20+ *
21+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22+ * or visit www.oracle.com if you need additional information or have any
23+ * questions.
24+ */
25+
26+
27+package sun.tools.java;
28+
29+/**
30+ * This interface defines constant that are used
31+ * throughout the compiler. It inherits from RuntimeConstants,
32+ * which is an autogenerated class that contains contstants
33+ * defined in the interpreter.
34+ *
35+ * WARNING: The contents of this source file are not part of any
36+ * supported API. Code that depends on them does so at its own risk:
37+ * they are subject to change or removal without notice.
38+ *
39+ * @author Arthur van Hoff
40+ */
41+
42+public
43+interface Constants extends RuntimeConstants {
44+
45+ /*
46+ * Enable/disable inclusion of certain debug tracing code in the
47+ * compiler. When included, the tracing code may be selectively
48+ * enabled at runtime, otherwise we save the space/time overhead.
49+ * Should normally be 'false' for a release version.
50+ */
51+ public static final boolean tracing = true;
52+
53+ /*
54+ * Frequently used identifiers
55+ */
56+ Identifier idAppend = Identifier.lookup("append");
57+ Identifier idClassInit = Identifier.lookup("<clinit>");
58+ Identifier idCode = Identifier.lookup("Code");
59+ Identifier idInit = Identifier.lookup("<init>");
60+ Identifier idLength = Identifier.lookup("length");
61+ Identifier idNull = Identifier.lookup("");
62+ Identifier idStar = Identifier.lookup("*");
63+ Identifier idSuper = Identifier.lookup("super");
64+ Identifier idThis = Identifier.lookup("this");
65+ Identifier idClass = Identifier.lookup("class");
66+ Identifier idToString = Identifier.lookup("toString");
67+ Identifier idValueOf = Identifier.lookup("valueOf");
68+ Identifier idNew = Identifier.lookup("new");
69+ Identifier idGetClass = Identifier.lookup("getClass");
70+ Identifier idTYPE = Identifier.lookup("TYPE");
71+ Identifier idFinallyReturnValue = Identifier.lookup("<return>");
72+
73+ Identifier idJavaLang = Identifier.lookup("java.lang");
74+
75+ Identifier idJavaLangCloneable = Identifier.lookup("java.lang.Cloneable");
76+
77+ Identifier idJavaLangError = Identifier.lookup("java.lang.Error");
78+ Identifier idJavaLangException = Identifier.lookup("java.lang.Exception");
79+ Identifier idJavaLangObject = Identifier.lookup("java.lang.Object");
80+ Identifier idJavaLangClass = Identifier.lookup("java.lang.Class");
81+ Identifier idJavaLangRuntimeException =
82+ Identifier.lookup("java.lang.RuntimeException");
83+ Identifier idJavaLangString = Identifier.lookup("java.lang.String");
84+ Identifier idJavaLangStringBuffer =
85+ Identifier.lookup("java.lang.StringBuffer");
86+ Identifier idJavaLangThrowable = Identifier.lookup("java.lang.Throwable");
87+
88+ Identifier idJavaIoSerializable = Identifier.lookup("java.io.Serializable");
89+
90+
91+ Identifier idConstantValue = Identifier.lookup("ConstantValue");
92+ Identifier idLocalVariableTable = Identifier.lookup("LocalVariableTable");
93+ Identifier idLineNumberTable = Identifier.lookup("LineNumberTable");
94+// JCOV
95+ Identifier idCoverageTable = Identifier.lookup("CoverageTable");
96+// end JCOV
97+ Identifier idSourceFile = Identifier.lookup("SourceFile");
98+ Identifier idDocumentation = Identifier.lookup("Documentation");
99+ Identifier idDeprecated = Identifier.lookup("Deprecated");
100+ Identifier idSynthetic = Identifier.lookup("Synthetic");
101+ Identifier idExceptions = Identifier.lookup("Exceptions");
102+ Identifier idInnerClasses = Identifier.lookup("InnerClasses");
103+
104+ /* methods we need to know about */
105+ Identifier idClone = Identifier.lookup("clone");
106+
107+
108+ /* This is not a real signature marker, since it is also
109+ * an identifier constituent character.
110+ */
111+ char SIGC_INNERCLASS = '$';
112+ String SIG_INNERCLASS = "$";
113+
114+ String prefixThis = "this$";
115+ String prefixVal = "val$";
116+ String prefixLoc = "loc$";
117+ String prefixAccess = "access$";
118+ String prefixClass = "class$";
119+ String prefixArray = "array$";
120+
121+ /*
122+ * Flags
123+ */
124+ int F_VERBOSE = 1 << 0;
125+ int F_DUMP = 1 << 1;
126+ int F_WARNINGS = 1 << 2;
127+
128+ // The meaning of -g has changed, so F_DEBUG flag is removed.
129+ // public static final int F_DEBUG = 1 << 3;
130+ int F_DEBUG_LINES = 1 << 12;
131+ int F_DEBUG_VARS = 1 << 13;
132+ int F_DEBUG_SOURCE = 1 << 18;
133+
134+ // The meaning of -O has changed, so F_OPTIMIZE flag is removed.
135+ // public static final int F_OPTIMIZE = 1 << 4;
136+ int F_OPT = 1 << 14;
137+ int F_OPT_INTERCLASS = 1 << 15;
138+
139+ int F_DEPENDENCIES = 1 << 5;
140+
141+// JCOV
142+ int F_COVERAGE = 1 << 6;
143+ int F_COVDATA = 1 << 7;
144+// end JCOV
145+
146+ int F_DEPRECATION = 1 << 9;
147+ int F_PRINT_DEPENDENCIES = 1 << 10;
148+ int F_VERSION12 = 1 << 11;
149+
150+
151+ int F_ERRORSREPORTED = 1 << 16;
152+
153+ int F_STRICTDEFAULT = 1 << 17;
154+
155+ /*
156+ * Modifiers.
157+ *
158+ * There has been much confusion regarding modifiers. There
159+ * are a number of distinct usages:
160+ *
161+ * - in classfiles to annotate classes, as per JVM pg. 102.
162+ * - in classfiles to annotate methods, as per JVM pg. 104.
163+ * - in classfiles to annotate InnerClass attributes, as per
164+ * http://java.sun.com/products/jdk/1.1/docs/guide/innerclasses
165+ * - in the compiler to record java source level modifiers,
166+ * as per JLS pg. 157 et al., plus misc. info such as whether
167+ * a method is deprecated
168+ * - in the JVM to record misc. info, such as whether a method has
169+ * has been compiled
170+ *
171+ * To make matters worse, the terms "access flags" and "modifiers"
172+ * are often used interchangably, and some information that might
173+ * make sense as a flag is expressed using attributes (ie. Synthetic).
174+ *
175+ * The constants defined herein have been divided by whether they
176+ * make sense only within the compiler (M_* and MM_*) or whether
177+ * they only make sense to the JVM (ACC_* and ACCM_*). At an earlier
178+ * time these were all lumped together. Future maintenance should
179+ * strive to keep the distinction clear.
180+ *
181+ * Note that modifier M_STRICTFP is not in general recoverable from
182+ * the ACC_STRICT bit in classfiles.
183+ *
184+ * Note also that the modifiers M_LOCAL and M_ANONYMOUS do not appear
185+ * in the InnerClass attribute, as they are above the first 16 bits.
186+ */
187+
188+ // Modifiers meaningful to both Java source and the JVM. These
189+ // have been kept the same bit in the M_* and ACC_* forms
190+ // to avoid destabilizing the compiler.
191+ int M_PUBLIC = ACC_PUBLIC;
192+ int M_PRIVATE = ACC_PRIVATE;
193+ int M_PROTECTED = ACC_PROTECTED;
194+ int M_STATIC = ACC_STATIC;
195+ int M_TRANSIENT = ACC_TRANSIENT;
196+ int M_SYNCHRONIZED = ACC_SYNCHRONIZED; // collides with ACC_SUPER
197+ int M_ABSTRACT = ACC_ABSTRACT;
198+ int M_NATIVE = ACC_NATIVE;
199+ int M_FINAL = ACC_FINAL;
200+ int M_VOLATILE = ACC_VOLATILE;
201+ int M_INTERFACE = ACC_INTERFACE;
202+
203+ // Modifiers not meaningful to the JVM. The JVM only allows 16 bits
204+ // for modifiers, so keeping these in the unusable bits after the first
205+ // 16 is a good idea.
206+ int M_ANONYMOUS = 0x00010000;
207+ int M_LOCAL = 0x00020000;
208+ int M_DEPRECATED = 0x00040000;
209+ int M_SYNTHETIC = 0x00080000;
210+ int M_INLINEABLE = 0x00100000;
211+
212+ int M_STRICTFP = 0x00200000;
213+
214+ String paraDeprecated = "@deprecated";
215+
216+ // Masks for modifiers that apply to Java source code
217+ int MM_CLASS = M_PUBLIC
218+ | M_INTERFACE
219+ | M_FINAL
220+ | M_ABSTRACT
221+ | M_STRICTFP;
222+ int MM_MEMBER = M_PUBLIC
223+ | M_PRIVATE
224+ | M_PROTECTED
225+ | M_FINAL
226+ | M_STATIC;
227+ int MM_FIELD = MM_MEMBER
228+ | M_TRANSIENT
229+ | M_VOLATILE;
230+ int MM_METHOD = MM_MEMBER
231+ | M_SYNCHRONIZED
232+ | M_ABSTRACT
233+ | M_NATIVE
234+ | M_STRICTFP;
235+
236+ // Masks for modifiers that apply to class files.
237+ // Note that the M_SYNTHETIC modifier is never written out to a class file.
238+ // Synthetic members are indicated using the "Synthetic" attribute.
239+ int ACCM_CLASS = ACC_PUBLIC
240+ | ACC_INTERFACE
241+ | ACC_FINAL
242+ | ACC_ABSTRACT
243+ | ACC_SUPER
244+ | ACC_STRICT;
245+ int ACCM_MEMBER = ACC_PUBLIC
246+ | ACC_PRIVATE
247+ | ACC_PROTECTED
248+ | ACC_FINAL
249+ | ACC_STATIC;
250+ // The M_ANONYMOUS and M_LOCAL modifiers are not mentioned in the
251+ // inner classes specification and are never written to classfiles.
252+ // Also note that ACC_SUPER should never be set in an InnerClass
253+ // attribute.
254+ int ACCM_INNERCLASS = ACC_PUBLIC
255+ | ACC_PRIVATE
256+ | ACC_PROTECTED
257+ | ACC_STATIC
258+ | ACC_ABSTRACT
259+ | ACC_FINAL
260+ | ACC_INTERFACE
261+ | ACC_STRICT;
262+ int ACCM_FIELD = ACCM_MEMBER
263+ | ACC_TRANSIENT
264+ | ACC_VOLATILE;
265+ int ACCM_METHOD = ACCM_MEMBER
266+ | ACC_SYNCHRONIZED
267+ | ACC_ABSTRACT
268+ | ACC_NATIVE
269+ | ACC_STRICT;
270+
271+ /*
272+ * Type codes
273+ */
274+ int TC_BOOLEAN = 0;
275+ int TC_BYTE = 1;
276+ int TC_CHAR = 2;
277+ int TC_SHORT = 3;
278+ int TC_INT = 4;
279+ int TC_LONG = 5;
280+ int TC_FLOAT = 6;
281+ int TC_DOUBLE = 7;
282+ int TC_NULL = 8;
283+ int TC_ARRAY = 9;
284+ int TC_CLASS = 10;
285+ int TC_VOID = 11;
286+ int TC_METHOD = 12;
287+ int TC_ERROR = 13;
288+
289+// JCOV
290+ /*
291+ * Cover's types
292+ */
293+ int CT_FIRST_KIND = 1;
294+ int CT_METHOD = 1;
295+ int CT_FIKT_METHOD = 2;
296+ int CT_BLOCK = 3;
297+ int CT_FIKT_RET = 4;
298+ int CT_CASE = 5;
299+ int CT_SWITH_WO_DEF = 6;
300+ int CT_BRANCH_TRUE = 7;
301+ int CT_BRANCH_FALSE = 8;
302+ int CT_LAST_KIND = 8;
303+// end JCOV
304+
305+ /*
306+ * Type Masks
307+ */
308+ int TM_NULL = 1 << TC_NULL;
309+ int TM_VOID = 1 << TC_VOID;
310+ int TM_BOOLEAN = 1 << TC_BOOLEAN;
311+ int TM_BYTE = 1 << TC_BYTE;
312+ int TM_CHAR = 1 << TC_CHAR;
313+ int TM_SHORT = 1 << TC_SHORT;
314+ int TM_INT = 1 << TC_INT;
315+ int TM_LONG = 1 << TC_LONG;
316+ int TM_FLOAT = 1 << TC_FLOAT;
317+ int TM_DOUBLE = 1 << TC_DOUBLE;
318+ int TM_ARRAY = 1 << TC_ARRAY;
319+ int TM_CLASS = 1 << TC_CLASS;
320+ int TM_METHOD = 1 << TC_METHOD;
321+ int TM_ERROR = 1 << TC_ERROR;
322+
323+ int TM_INT32 = TM_BYTE | TM_SHORT | TM_CHAR | TM_INT;
324+ int TM_NUM32 = TM_INT32 | TM_FLOAT;
325+ int TM_NUM64 = TM_LONG | TM_DOUBLE;
326+ int TM_INTEGER = TM_INT32 | TM_LONG;
327+ int TM_REAL = TM_FLOAT | TM_DOUBLE;
328+ int TM_NUMBER = TM_INTEGER | TM_REAL;
329+ int TM_REFERENCE = TM_ARRAY | TM_CLASS | TM_NULL;
330+
331+ /*
332+ * Class status
333+ */
334+ int CS_UNDEFINED = 0;
335+ int CS_UNDECIDED = 1;
336+ int CS_BINARY = 2;
337+ int CS_SOURCE = 3;
338+ int CS_PARSED = 4;
339+ int CS_CHECKED = 5;
340+ int CS_COMPILED = 6;
341+ int CS_NOTFOUND = 7;
342+
343+
344+ /*
345+ * Attributes
346+ */
347+ int ATT_ALL = 0xFFFFFFFF;
348+ int ATT_CODE = 1 << 1;
349+ int ATT_ALLCLASSES = 1 << 2;
350+
351+ /*
352+ * Number of bits used in file offsets. The line number and
353+ * file offset are concatenated into a long, with enough room
354+ * for other information to be added later if desired (such as
355+ * token lengths). For the moment explicit bit manipulations
356+ * are used to modify the fields. This makes sense for efficiency
357+ * but at some point these ought to be better encapsulated.
358+ */
359+ int WHEREOFFSETBITS = 32;
360+ long MAXFILESIZE = (1L << WHEREOFFSETBITS) - 1;
361+ long MAXLINENUMBER = (1L << (64 - WHEREOFFSETBITS)) - 1;
362+
363+ /*
364+ * Operators
365+ */
366+ int COMMA = 0;
367+ int ASSIGN = 1;
368+
369+ int ASGMUL = 2;
370+ int ASGDIV = 3;
371+ int ASGREM = 4;
372+ int ASGADD = 5;
373+ int ASGSUB = 6;
374+ int ASGLSHIFT = 7;
375+ int ASGRSHIFT = 8;
376+ int ASGURSHIFT = 9;
377+ int ASGBITAND = 10;
378+ int ASGBITOR = 11;
379+ int ASGBITXOR = 12;
380+
381+ int COND = 13;
382+ int OR = 14;
383+ int AND = 15;
384+ int BITOR = 16;
385+ int BITXOR = 17;
386+ int BITAND = 18;
387+ int NE = 19;
388+ int EQ = 20;
389+ int GE = 21;
390+ int GT = 22;
391+ int LE = 23;
392+ int LT = 24;
393+ int INSTANCEOF = 25;
394+ int LSHIFT = 26;
395+ int RSHIFT = 27;
396+ int URSHIFT = 28;
397+ int ADD = 29;
398+ int SUB = 30;
399+ int DIV = 31;
400+ int REM = 32;
401+ int MUL = 33;
402+ int CAST = 34; // (x)y
403+ int POS = 35; // +x
404+ int NEG = 36; // -x
405+ int NOT = 37;
406+ int BITNOT = 38;
407+ int PREINC = 39; // ++x
408+ int PREDEC = 40; // --x
409+ int NEWARRAY = 41;
410+ int NEWINSTANCE = 42;
411+ int NEWFROMNAME = 43;
412+ int POSTINC = 44; // x++
413+ int POSTDEC = 45; // x--
414+ int FIELD = 46;
415+ int METHOD = 47; // x(y)
416+ int ARRAYACCESS = 48; // x[y]
417+ int NEW = 49;
418+ int INC = 50;
419+ int DEC = 51;
420+
421+ int CONVERT = 55; // implicit conversion
422+ int EXPR = 56; // (x)
423+ int ARRAY = 57; // {x, y, ...}
424+ int GOTO = 58;
425+
426+ /*
427+ * Value tokens
428+ */
429+ int IDENT = 60;
430+ int BOOLEANVAL = 61;
431+ int BYTEVAL = 62;
432+ int CHARVAL = 63;
433+ int SHORTVAL = 64;
434+ int INTVAL = 65;
435+ int LONGVAL = 66;
436+ int FLOATVAL = 67;
437+ int DOUBLEVAL = 68;
438+ int STRINGVAL = 69;
439+
440+ /*
441+ * Type keywords
442+ */
443+ int BYTE = 70;
444+ int CHAR = 71;
445+ int SHORT = 72;
446+ int INT = 73;
447+ int LONG = 74;
448+ int FLOAT = 75;
449+ int DOUBLE = 76;
450+ int VOID = 77;
451+ int BOOLEAN = 78;
452+
453+ /*
454+ * Expression keywords
455+ */
456+ int TRUE = 80;
457+ int FALSE = 81;
458+ int THIS = 82;
459+ int SUPER = 83;
460+ int NULL = 84;
461+
462+ /*
463+ * Statement keywords
464+ */
465+ int IF = 90;
466+ int ELSE = 91;
467+ int FOR = 92;
468+ int WHILE = 93;
469+ int DO = 94;
470+ int SWITCH = 95;
471+ int CASE = 96;
472+ int DEFAULT = 97;
473+ int BREAK = 98;
474+ int CONTINUE = 99;
475+ int RETURN = 100;
476+ int TRY = 101;
477+ int CATCH = 102;
478+ int FINALLY = 103;
479+ int THROW = 104;
480+ int STAT = 105;
481+ int EXPRESSION = 106;
482+ int DECLARATION = 107;
483+ int VARDECLARATION = 108;
484+
485+ /*
486+ * Declaration keywords
487+ */
488+ int IMPORT = 110;
489+ int CLASS = 111;
490+ int EXTENDS = 112;
491+ int IMPLEMENTS = 113;
492+ int INTERFACE = 114;
493+ int PACKAGE = 115;
494+
495+ /*
496+ * Modifier keywords
497+ */
498+ int PRIVATE = 120;
499+ int PUBLIC = 121;
500+ int PROTECTED = 122;
501+ int CONST = 123;
502+ int STATIC = 124;
503+ int TRANSIENT = 125;
504+ int SYNCHRONIZED = 126;
505+ int NATIVE = 127;
506+ int FINAL = 128;
507+ int VOLATILE = 129;
508+ int ABSTRACT = 130;
509+ int STRICTFP = 131;
510+
511+ /*
512+ * Punctuation
513+ */
514+ int SEMICOLON = 135;
515+ int COLON = 136;
516+ int QUESTIONMARK = 137;
517+ int LBRACE = 138;
518+ int RBRACE = 139;
519+ int LPAREN = 140;
520+ int RPAREN = 141;
521+ int LSQBRACKET = 142;
522+ int RSQBRACKET = 143;
523+ int THROWS = 144;
524+
525+ /*
526+ * Special tokens
527+ */
528+ int ERROR = 145; // an error
529+ int COMMENT = 146; // not used anymore.
530+ int TYPE = 147;
531+ int LENGTH = 148;
532+ int INLINERETURN = 149;
533+ int INLINEMETHOD = 150;
534+ int INLINENEWINSTANCE = 151;
535+
536+ /*
537+ * Operator precedence
538+ */
539+ int opPrecedence[] = {
540+ 10, 11, 11, 11, 11, 11, 11, 11, 11, 11,
541+ 11, 11, 11, 12, 13, 14, 15, 16, 17, 18,
542+ 18, 19, 19, 19, 19, 19, 20, 20, 20, 21,
543+ 21, 22, 22, 22, 23, 24, 24, 24, 24, 24,
544+ 24, 25, 25, 26, 26, 26, 26, 26, 26
545+ };
546+
547+ /*
548+ * Operator names
549+ */
550+ String opNames[] = {
551+ ",", "=", "*=", "/=", "%=",
552+ "+=", "-=", "<<=", ">>=", ">>>=",
553+ "&=", "|=", "^=", "?:", "||",
554+ "&&", "|", "^", "&", "!=",
555+ "==", ">=", ">", "<=", "<",
556+ "instanceof", "<<", ">>", ">>>", "+",
557+ "-", "/", "%", "*", "cast",
558+ "+", "-", "!", "~", "++",
559+ "--", "new", "new", "new", "++",
560+ "--", "field","method","[]", "new",
561+ "++", "--", null, null, null,
562+
563+ "convert", "expr", "array", "goto", null,
564+
565+ "Identifier", "boolean", "byte", "char", "short",
566+ "int", "long", "float", "double", "string",
567+
568+ "byte", "char", "short", "int", "long",
569+ "float", "double", "void", "boolean", null,
570+
571+ "true", "false", "this", "super", "null",
572+ null, null, null, null, null,
573+
574+ "if", "else", "for", "while","do",
575+ "switch", "case", "default", "break", "continue",
576+ "return", "try", "catch", "finally", "throw",
577+ "stat", "expression", "declaration", "declaration", null,
578+
579+ "import", "class", "extends", "implements", "interface",
580+ "package", null, null, null, null,
581+
582+ "private", "public", "protected", "const", "static",
583+ "transient", "synchronized", "native", "final", "volatile",
584+ "abstract", "strictfp", null, null, null,
585+
586+ ";", ":", "?", "{", "}",
587+ "(", ")", "[", "]", "throws",
588+ "error", "comment", "type", "length", "inline-return",
589+ "inline-method", "inline-new"
590+ };
591+}