001 /*
002 $Id: Types.java,v 1.11 2005/04/12 15:04:59 jstrachan Exp $
003
004 Copyright 2003 (C) James Strachan and Bob Mcwhirter. All Rights Reserved.
005
006 Redistribution and use of this software and associated documentation
007 ("Software"), with or without modification, are permitted provided
008 that the following conditions are met:
009
010 1. Redistributions of source code must retain copyright
011 statements and notices. Redistributions must also contain a
012 copy of this document.
013
014 2. Redistributions in binary form must reproduce the
015 above copyright notice, this list of conditions and the
016 following disclaimer in the documentation and/or other
017 materials provided with the distribution.
018
019 3. The name "groovy" must not be used to endorse or promote
020 products derived from this Software without prior written
021 permission of The Codehaus. For written permission,
022 please contact info@codehaus.org.
023
024 4. Products derived from this Software may not be called "groovy"
025 nor may "groovy" appear in their names without prior written
026 permission of The Codehaus. "groovy" is a registered
027 trademark of The Codehaus.
028
029 5. Due credit should be given to The Codehaus -
030 http://groovy.codehaus.org/
031
032 THIS SOFTWARE IS PROVIDED BY THE CODEHAUS AND CONTRIBUTORS
033 ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT
034 NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
035 FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
036 THE CODEHAUS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
037 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
038 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
039 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
040 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
041 STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
042 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
043 OF THE POSSIBILITY OF SUCH DAMAGE.
044
045 */
046
047 package org.codehaus.groovy.syntax;
048
049 import java.util.HashMap;
050 import java.util.Iterator;
051 import java.util.Map;
052
053 import org.codehaus.groovy.GroovyBugError;
054
055
056 /**
057 * Typing information for the CST system. The types here are those
058 * used by CSTNode, Token, and Reduction.
059 *
060 * @author <a href="mailto:bob@werken.com">bob mcwhirter</a>
061 * @author <a href="mailto:cpoirier@dreaming.org">Chris Poirier</a>
062 *
063 * @version $Id: Types.java,v 1.11 2005/04/12 15:04:59 jstrachan Exp $
064 */
065
066 public class Types
067 {
068
069
070 //---------------------------------------------------------------------------
071 // TYPES: NOTE THAT ORDERING AND VALUES ARE IMPORTANT TO LOCAL ROUTINES!
072
073
074 //
075 // SPECIAL TOKENS
076
077 public static final int EOF = -1; // end of file
078 public static final int UNKNOWN = 0; // the unknown token
079
080
081 //
082 // RELEVANT WHITESPACE
083
084 public static final int NEWLINE = 5; // \n
085
086
087 //
088 // OPERATORS AND OTHER MARKERS
089
090 public static final int LEFT_CURLY_BRACE = 10; // {
091 public static final int RIGHT_CURLY_BRACE = 20; // }
092 public static final int LEFT_SQUARE_BRACKET = 30; // [
093 public static final int RIGHT_SQUARE_BRACKET = 40; // ]
094 public static final int LEFT_PARENTHESIS = 50; // (
095 public static final int RIGHT_PARENTHESIS = 60; // )
096
097 public static final int DOT = 70; // .
098 public static final int DOT_DOT = 75; // ..
099 public static final int DOT_DOT_DOT = 77; // ...
100
101 public static final int NAVIGATE = 80; // ->
102
103 public static final int FIND_REGEX = 90; // =~
104 public static final int MATCH_REGEX = 94; // ==~
105 public static final int REGEX_PATTERN = 97; // ~
106
107 public static final int EQUAL = 100; // =
108 public static final int EQUALS = EQUAL;
109 public static final int ASSIGN = EQUAL;
110
111 public static final int COMPARE_NOT_EQUAL = 120; // !=
112 public static final int COMPARE_IDENTICAL = 121; // ===
113 public static final int COMPARE_NOT_IDENTICAL = 122; // !==
114 public static final int COMPARE_EQUAL = 123; // ==
115 public static final int COMPARE_LESS_THAN = 124; // <
116 public static final int COMPARE_LESS_THAN_EQUAL = 125; // <=
117 public static final int COMPARE_GREATER_THAN = 126; // >
118 public static final int COMPARE_GREATER_THAN_EQUAL = 127; // >=
119 public static final int COMPARE_TO = 128; // <=>
120
121 public static final int NOT = 160; // !
122 public static final int LOGICAL_OR = 162; // ||
123 public static final int LOGICAL_AND = 164; // &&
124
125 public static final int LOGICAL_OR_EQUAL = 166; // ||=
126 public static final int LOGICAL_AND_EQUAL = 168; // &&=
127
128 public static final int PLUS = 200; // +
129 public static final int MINUS = 201; // -
130 public static final int MULTIPLY = 202; // *
131 public static final int DIVIDE = 203; // /
132 public static final int INTDIV = 204; // \
133 public static final int MOD = 205; // %
134 public static final int STAR_STAR = 206; // **
135 public static final int POWER = STAR_STAR; // **
136
137 public static final int PLUS_EQUAL = 210; // +=
138 public static final int MINUS_EQUAL = 211; // -=
139 public static final int MULTIPLY_EQUAL = 212; // *=
140 public static final int DIVIDE_EQUAL = 213; // /=
141 public static final int INTDIV_EQUAL = 214; // \=
142 public static final int MOD_EQUAL = 215; // %=
143 public static final int POWER_EQUAL = 216; // **=
144
145 public static final int PLUS_PLUS = 250; // ++
146 public static final int PREFIX_PLUS_PLUS = 251; // ++
147 public static final int POSTFIX_PLUS_PLUS = 252; // ++
148 public static final int PREFIX_PLUS = 253; // +
149
150 public static final int MINUS_MINUS = 260; // --
151 public static final int PREFIX_MINUS_MINUS = 261; // --
152 public static final int POSTFIX_MINUS_MINUS = 262; // --
153 public static final int PREFIX_MINUS = 263; // - (negation)
154
155 public static final int LEFT_SHIFT = 280; // <<
156 public static final int RIGHT_SHIFT = 281; // >>
157 public static final int RIGHT_SHIFT_UNSIGNED = 282; // >>>
158
159 public static final int LEFT_SHIFT_EQUAL = 285; // <<=
160 public static final int RIGHT_SHIFT_EQUAL = 286; // >>=
161 public static final int RIGHT_SHIFT_UNSIGNED_EQUAL = 287; // >>>=
162
163 public static final int STAR = MULTIPLY;
164
165 public static final int COMMA = 300; // -
166 public static final int COLON = 310; // :
167 public static final int SEMICOLON = 320; // ;
168 public static final int QUESTION = 330; // ?
169
170 // TODO refactor PIPE to be BITWISE_OR
171 public static final int PIPE = 340; // |
172 public static final int DOUBLE_PIPE = LOGICAL_OR; // ||
173 public static final int BITWISE_OR = PIPE; // |
174 public static final int BITWISE_AND = 341; // &
175 public static final int BITWISE_XOR = 342; // ^
176
177 public static final int BITWISE_OR_EQUAL = 350; // |=
178 public static final int BITWISE_AND_EQUAL = 351; // &=
179 public static final int BITWISE_XOR_EQUAL = 352; // ^=
180 public static final int BITWISE_NEGATION = REGEX_PATTERN; // ~
181
182
183 //
184 // LITERALS
185
186 public static final int STRING = 400; // any bare string data
187
188 public static final int IDENTIFIER = 440; // anything text and not a keyword
189
190 public static final int INTEGER_NUMBER = 450; // integer
191 public static final int DECIMAL_NUMBER = 451; // decimal
192
193
194 //
195 // KEYWORDS: (PRIMARILY) CLASS/METHOD DECLARATION MODIFIERS
196
197 public static final int KEYWORD_PRIVATE = 500; // declaration visibility
198 public static final int KEYWORD_PROTECTED = 501; // declaration visibility
199 public static final int KEYWORD_PUBLIC = 502; // declaration visibility
200
201 public static final int KEYWORD_ABSTRACT = 510; // method body missing
202 public static final int KEYWORD_FINAL = 511; // declaration cannot be overridden
203 public static final int KEYWORD_NATIVE = 512; // a native code entry point
204 public static final int KEYWORD_TRANSIENT = 513; // property should not be persisted
205 public static final int KEYWORD_VOLATILE = 514; // compiler should never cache property
206
207 public static final int KEYWORD_SYNCHRONIZED = 520; // modifier and block type
208 public static final int KEYWORD_STATIC = 521; // modifier and block type
209
210
211 //
212 // KEYWORDS: TYPE SYSTEM
213
214 public static final int KEYWORD_DEF = 530; // identifies a function declaration
215 public static final int KEYWORD_DEFMACRO = 539; // XXX br identifies a macro declaration
216 public static final int KEYWORD_CLASS = 531; // identifies a class declaration
217 public static final int KEYWORD_INTERFACE = 532; // identifies an interface declaration
218 public static final int KEYWORD_MIXIN = 533; // identifies a mixin declaration
219
220 public static final int KEYWORD_IMPLEMENTS = 540; // specifies the interfaces implemented by a class
221 public static final int KEYWORD_EXTENDS = 541; // specifies the base class/interface for a new one
222 public static final int KEYWORD_THIS = 542; // method variable points to the current instance
223 public static final int KEYWORD_SUPER = 543; // method variable points to the base instance
224 public static final int KEYWORD_INSTANCEOF = 544; // type comparator
225 public static final int KEYWORD_PROPERTY = 545; // deprecated; identifies a property
226 public static final int KEYWORD_NEW = 546; // used to create a new instance of a class
227
228 public static final int KEYWORD_PACKAGE = 550; // declares the package scope
229 public static final int KEYWORD_IMPORT = 551; // declares an external class
230 public static final int KEYWORD_AS = 552; // used in import statements to create an alias
231
232
233 //
234 // KEYWORDS: CONTROL STRUCTURES
235
236 public static final int KEYWORD_RETURN = 560; // returns from a closure or method
237 public static final int KEYWORD_IF = 561; // if
238 public static final int KEYWORD_ELSE = 562; // else
239 public static final int KEYWORD_DO = 570; // do loop
240 public static final int KEYWORD_WHILE = 571; // while loop
241 public static final int KEYWORD_FOR = 572; // for loop
242 public static final int KEYWORD_IN = 573; // for (each) loop separator
243 public static final int KEYWORD_BREAK = 574; // exits a loop or block
244 public static final int KEYWORD_CONTINUE = 575; // restarts a loop on the next iteration
245 public static final int KEYWORD_SWITCH = 576; // switch block
246 public static final int KEYWORD_CASE = 577; // item in a switch block
247 public static final int KEYWORD_DEFAULT = 578; // catch-all item in a switch block
248
249 public static final int KEYWORD_TRY = 580; // block to monitor for exceptions
250 public static final int KEYWORD_CATCH = 581; // catch block for a particular exception
251 public static final int KEYWORD_FINALLY = 582; // block to always execute on exit of the try
252 public static final int KEYWORD_THROW = 583; // statement to throw an exception
253 public static final int KEYWORD_THROWS = 584; // method modifier to declare thrown transactions
254 public static final int KEYWORD_ASSERT = 585; // alternate throw for code invariants
255
256
257 //
258 // KEYWORDS: PRIMITIVE TYPES
259
260 public static final int KEYWORD_VOID = 600; // void
261 public static final int KEYWORD_BOOLEAN = 601; // boolean
262 public static final int KEYWORD_BYTE = 602; // 1 byte integer
263 public static final int KEYWORD_SHORT = 603; // 2 byte integer
264 public static final int KEYWORD_INT = 604; // 4 byte integer
265 public static final int KEYWORD_LONG = 605; // 8 byte integer
266 public static final int KEYWORD_FLOAT = 606; // 32 bit floating point number
267 public static final int KEYWORD_DOUBLE = 607; // 64 bit floating point number
268 public static final int KEYWORD_CHAR = 608; // unicode character code
269
270
271 //
272 // KEYWORDS: SPECIAL VALUES
273
274 public static final int KEYWORD_TRUE = 610; // boolean truth
275 public static final int KEYWORD_FALSE = 611; // boolean false
276 public static final int KEYWORD_NULL = 612; // missing instance
277
278
279 //
280 // KEYWORDS: RESERVED
281
282 public static final int KEYWORD_CONST = 700; // reserved in java and groovy
283 public static final int KEYWORD_GOTO = 701; // reserved in java and groovy
284
285
286 //
287 // SPECIAL (CALCULATED) MEANINGS
288
289 public static final int SYNTH_COMPILATION_UNIT = 800; // reserved: a synthetic root for a CST
290
291 public static final int SYNTH_CLASS = 801; // applied to class names
292 public static final int SYNTH_INTERFACE = 802; // applied to interface names
293 public static final int SYNTH_MIXIN = 803; // applied to mixin names
294 public static final int SYNTH_METHOD = 804; // applied to method names
295 public static final int SYNTH_PROPERTY = 805; // applied to property names
296 public static final int SYNTH_PARAMETER_DECLARATION = 806; // applied to method/closure parameter names
297
298 public static final int SYNTH_LIST = 810; // applied to "[" that marks a list
299 public static final int SYNTH_MAP = 811; // applied to "[" that marks a map
300 public static final int SYNTH_GSTRING = 812; // a complete GString
301
302 public static final int SYNTH_METHOD_CALL = 814; // applied to the optional "(" that marks a call to a method
303 public static final int SYNTH_CAST = 815; // applied to "(" that marks a type cast
304 public static final int SYNTH_BLOCK = 816; // applied to "{" that marks a block
305 public static final int SYNTH_CLOSURE = 817; // applied to "{" that marks a closure
306 public static final int SYNTH_LABEL = 818; // applied to a statement label
307 public static final int SYNTH_TERNARY = 819; // applied to "?" that marks a ternary expression
308 public static final int SYNTH_TUPLE = 820; // applied to "{" that marks an array initializer
309
310 public static final int SYNTH_VARIABLE_DECLARATION = 830; // applied to an identifier that specifies
311 // the type of a variable declaration
312
313 //
314 // GSTRING TOKENS
315
316 public static final int GSTRING_START = 901; // any marker tha begins a GString
317 public static final int GSTRING_END = 902; // any matching marker that ends a GString
318 public static final int GSTRING_EXPRESSION_START = 903; // the ${ marker that starts a GString expression
319 public static final int GSTRING_EXPRESSION_END = 904; // the } marker that ends a GString expresssion
320
321
322 //
323 // TYPE CLASSES
324
325 public static final int ANY = 1000; // anything
326 public static final int NOT_EOF = 1001; // anything but EOF
327 public static final int GENERAL_END_OF_STATEMENT = 1002; // ";", "\n", EOF
328 public static final int ANY_END_OF_STATEMENT = 1003; // ";", "\n", EOF, "}"
329
330 public static final int ASSIGNMENT_OPERATOR = 1100; // =, +=, etc.
331 public static final int COMPARISON_OPERATOR = 1101; // ==, ===, >, <, etc.
332 public static final int MATH_OPERATOR = 1102; // +, -, / *, %, plus the LOGICAL_OPERATORS
333 public static final int LOGICAL_OPERATOR = 1103; // ||, &&, !
334 public static final int RANGE_OPERATOR = 1104; // .., ...
335 public static final int REGEX_COMPARISON_OPERATOR = 1105; // =~, etc.
336 public static final int DEREFERENCE_OPERATOR = 1106; // ., ->
337 public static final int BITWISE_OPERATOR = 1107; // |, &, <<, >>, >>>, ^, ~
338
339 public static final int PREFIX_OPERATOR = 1200; // ++, !, etc.
340 public static final int POSTFIX_OPERATOR = 1210; // ++, etc.
341 public static final int INFIX_OPERATOR = 1220; // +, -, =, etc.
342 public static final int PREFIX_OR_INFIX_OPERATOR = 1230; // +, -
343 public static final int PURE_PREFIX_OPERATOR = 1235; // prefix +, prefix -
344
345 public static final int KEYWORD = 1300; // any keyword
346 public static final int SYMBOL = 1301; // any symbol
347 public static final int LITERAL = 1310; // strings, numbers, identifiers
348 public static final int NUMBER = 1320; // integers and decimals
349 public static final int SIGN = 1325; // "+", "-"
350 public static final int NAMED_VALUE = 1330; // true, false, null
351 public static final int TRUTH_VALUE = 1331; // true, false
352 public static final int PRIMITIVE_TYPE = 1340; // void, byte, short, int, etc.
353 public static final int CREATABLE_PRIMITIVE_TYPE = 1341; // any PRIMITIVE_TYPE except void
354 public static final int LOOP = 1350; // do, while, etc.
355 public static final int RESERVED_KEYWORD = 1360; // const, goto, etc.
356 public static final int KEYWORD_IDENTIFIER = 1361; // keywords that can appear as identifiers
357 public static final int SYNTHETIC = 1370; // any of the SYNTH types
358
359 public static final int TYPE_DECLARATION = 1400; // class, interface, mixin
360 public static final int DECLARATION_MODIFIER = 1410; // public, private, abstract, etc.
361
362 public static final int TYPE_NAME = 1420; // identifiers, primitive types
363 public static final int CREATABLE_TYPE_NAME = 1430; // identifiers, primitive types except void
364
365 public static final int MATCHED_CONTAINER = 1500; // (, ), [, ], {, }
366 public static final int LEFT_OF_MATCHED_CONTAINER = 1501; // (, [, {
367 public static final int RIGHT_OF_MATCHED_CONTAINER = 1502; // ), ], }
368
369 public static final int EXPRESSION = 1900; // all of the below 1900 series
370
371 public static final int OPERATOR_EXPRESSION = 1901; // "."-"<<"
372 public static final int SYNTH_EXPRESSION = 1902; // cast, ternary, and closure expression
373 public static final int KEYWORD_EXPRESSION = 1903; // new, this, super, instanceof, true, false, null
374 public static final int LITERAL_EXPRESSION = 1904; // LITERAL
375 public static final int ARRAY_EXPRESSION = 1905; // "["
376
377 public static final int SIMPLE_EXPRESSION = 1910; // LITERAL, this, true, false, null
378 public static final int COMPLEX_EXPRESSION = 1911; // SIMPLE_EXPRESSION, and various molecules
379
380
381
382 //
383 // TYPE GROUPS (OPERATIONS SUPPORT)
384
385 public static final int PARAMETER_TERMINATORS = 2000; // ")", ","
386 public static final int ARRAY_ITEM_TERMINATORS = 2001; // "]", ","
387 public static final int TYPE_LIST_TERMINATORS = 2002; // "implements", "throws", "{", ","
388 public static final int OPTIONAL_DATATYPE_FOLLOWERS = 2003; // identifier, "[", "."
389
390 public static final int SWITCH_BLOCK_TERMINATORS = 2004; // "case", "default", "}"
391 public static final int SWITCH_ENTRIES = 2005; // "case", "default"
392
393 public static final int METHOD_CALL_STARTERS = 2006; // LITERAL, "(", "{"
394 public static final int UNSAFE_OVER_NEWLINES = 2007; // things the expression parser should cross lines for in it doesn't have to
395
396 public static final int PRECLUDES_CAST_OPERATOR = 2008; // anything that prevents (X) from being a cast
397
398
399
400
401
402 //---------------------------------------------------------------------------
403 // TYPE HIERARCHIES
404
405
406 /**
407 * Given two types, returns true if the second describes the first.
408 */
409
410 public static boolean ofType( int specific, int general )
411 {
412
413 if( general == specific )
414 {
415 return true;
416 }
417
418 switch( general )
419 {
420 case ANY:
421 return true;
422
423 case NOT_EOF:
424 return specific >= UNKNOWN && specific <= SYNTH_VARIABLE_DECLARATION;
425
426 case GENERAL_END_OF_STATEMENT:
427 switch( specific )
428 {
429 case EOF:
430 case NEWLINE:
431 case SEMICOLON:
432 return true;
433 }
434 break;
435
436 case ANY_END_OF_STATEMENT:
437 switch( specific )
438 {
439 case EOF:
440 case NEWLINE:
441 case SEMICOLON:
442 case RIGHT_CURLY_BRACE:
443 return true;
444 }
445 break;
446
447 case ASSIGNMENT_OPERATOR:
448 return specific == EQUAL || (specific >= PLUS_EQUAL && specific <= POWER_EQUAL) || (specific >= LOGICAL_OR_EQUAL && specific <= LOGICAL_AND_EQUAL)
449 || (specific >= LEFT_SHIFT_EQUAL && specific <= RIGHT_SHIFT_UNSIGNED_EQUAL)
450 || (specific >= BITWISE_OR_EQUAL && specific <= BITWISE_XOR_EQUAL);
451
452 case COMPARISON_OPERATOR:
453 return specific >= COMPARE_NOT_EQUAL && specific <= COMPARE_TO;
454
455 case MATH_OPERATOR:
456 return (specific >= PLUS && specific <= RIGHT_SHIFT_UNSIGNED) || (specific >= NOT && specific <= LOGICAL_AND)
457 || (specific >= BITWISE_OR && specific <= BITWISE_XOR);
458
459 case LOGICAL_OPERATOR:
460 return specific >= NOT && specific <= LOGICAL_AND;
461
462 case BITWISE_OPERATOR:
463 return (specific >= BITWISE_OR && specific <= BITWISE_XOR) || specific == BITWISE_NEGATION;
464
465 case RANGE_OPERATOR:
466 return specific == DOT_DOT || specific == DOT_DOT_DOT;
467
468 case REGEX_COMPARISON_OPERATOR:
469 return specific == FIND_REGEX || specific == MATCH_REGEX;
470
471 case DEREFERENCE_OPERATOR:
472 return specific == DOT || specific == NAVIGATE;
473
474 case PREFIX_OPERATOR:
475 switch( specific )
476 {
477 case MINUS:
478 case PLUS_PLUS:
479 case MINUS_MINUS:
480 return true;
481 }
482
483 /* FALL THROUGH */
484
485 case PURE_PREFIX_OPERATOR:
486 switch( specific )
487 {
488 case REGEX_PATTERN:
489 case NOT:
490 case PREFIX_PLUS:
491 case PREFIX_PLUS_PLUS:
492 case PREFIX_MINUS:
493 case PREFIX_MINUS_MINUS:
494 case SYNTH_CAST:
495 return true;
496 }
497 break;
498
499 case POSTFIX_OPERATOR:
500 switch( specific )
501 {
502 case PLUS_PLUS:
503 case POSTFIX_PLUS_PLUS:
504 case MINUS_MINUS:
505 case POSTFIX_MINUS_MINUS:
506 return true;
507 }
508 break;
509
510 case INFIX_OPERATOR:
511 switch( specific )
512 {
513 case DOT:
514 case NAVIGATE:
515 case LOGICAL_OR:
516 case LOGICAL_AND:
517 case BITWISE_OR:
518 case BITWISE_AND:
519 case BITWISE_XOR:
520 case LEFT_SHIFT:
521 case RIGHT_SHIFT:
522 case RIGHT_SHIFT_UNSIGNED:
523 case FIND_REGEX:
524 case MATCH_REGEX:
525 case DOT_DOT:
526 case DOT_DOT_DOT:
527 case KEYWORD_INSTANCEOF:
528 return true;
529 }
530
531 return (specific >= COMPARE_NOT_EQUAL && specific <= COMPARE_TO) || (specific >= PLUS && specific <= MOD_EQUAL) || specific == EQUAL || (specific >= PLUS_EQUAL && specific <= POWER_EQUAL) || (specific >= LOGICAL_OR_EQUAL && specific <= LOGICAL_AND_EQUAL)
532 || (specific >= LEFT_SHIFT_EQUAL && specific <= RIGHT_SHIFT_UNSIGNED_EQUAL) || (specific >= BITWISE_OR_EQUAL && specific <= BITWISE_XOR_EQUAL);
533
534 case PREFIX_OR_INFIX_OPERATOR:
535 switch( specific )
536 {
537 case POWER:
538 case PLUS:
539 case MINUS:
540 case PREFIX_PLUS:
541 case PREFIX_MINUS:
542 return true;
543 }
544 break;
545
546
547 case KEYWORD:
548 return specific >= KEYWORD_PRIVATE && specific <= KEYWORD_GOTO;
549
550 case SYMBOL:
551 return specific >= NEWLINE && specific <= PIPE;
552
553 case LITERAL:
554 return specific >= STRING && specific <= DECIMAL_NUMBER;
555
556 case NUMBER:
557 return specific == INTEGER_NUMBER || specific == DECIMAL_NUMBER;
558
559 case SIGN:
560 switch( specific )
561 {
562 case PLUS:
563 case MINUS:
564 return true;
565 }
566 break;
567
568 case NAMED_VALUE:
569 return specific >= KEYWORD_TRUE && specific <= KEYWORD_NULL;
570
571 case TRUTH_VALUE:
572 return specific == KEYWORD_TRUE || specific == KEYWORD_FALSE;
573
574 case TYPE_NAME:
575 if( specific == IDENTIFIER )
576 {
577 return true;
578 }
579
580 /* FALL THROUGH */
581
582 case PRIMITIVE_TYPE:
583 return specific >= KEYWORD_VOID && specific <= KEYWORD_CHAR;
584
585 case CREATABLE_TYPE_NAME:
586 if( specific == IDENTIFIER )
587 {
588 return true;
589 }
590
591 /* FALL THROUGH */
592
593 case CREATABLE_PRIMITIVE_TYPE:
594 return specific >= KEYWORD_BOOLEAN && specific <= KEYWORD_CHAR;
595
596 case LOOP:
597 switch( specific )
598 {
599 case KEYWORD_DO:
600 case KEYWORD_WHILE:
601 case KEYWORD_FOR:
602 return true;
603 }
604 break;
605
606 case RESERVED_KEYWORD:
607 return specific >= KEYWORD_CONST && specific <= KEYWORD_GOTO;
608
609 case KEYWORD_IDENTIFIER:
610 switch( specific )
611 {
612 case KEYWORD_CLASS:
613 case KEYWORD_INTERFACE:
614 case KEYWORD_MIXIN:
615 case KEYWORD_DEF:
616 case KEYWORD_DEFMACRO:
617 case KEYWORD_IN:
618 case KEYWORD_PROPERTY:
619 return true;
620 }
621 break;
622
623 case SYNTHETIC:
624 return specific >= SYNTH_COMPILATION_UNIT && specific <= SYNTH_VARIABLE_DECLARATION;
625
626 case TYPE_DECLARATION:
627 return specific >= KEYWORD_CLASS && specific <= KEYWORD_MIXIN;
628
629 case DECLARATION_MODIFIER:
630 return specific >= KEYWORD_PRIVATE && specific <= KEYWORD_STATIC;
631
632 case MATCHED_CONTAINER:
633 switch( specific )
634 {
635 case LEFT_CURLY_BRACE:
636 case RIGHT_CURLY_BRACE:
637 case LEFT_SQUARE_BRACKET:
638 case RIGHT_SQUARE_BRACKET:
639 case LEFT_PARENTHESIS:
640 case RIGHT_PARENTHESIS:
641 return true;
642 }
643 break;
644
645 case LEFT_OF_MATCHED_CONTAINER:
646 switch( specific )
647 {
648 case LEFT_CURLY_BRACE:
649 case LEFT_SQUARE_BRACKET:
650 case LEFT_PARENTHESIS:
651 return true;
652 }
653 break;
654
655 case RIGHT_OF_MATCHED_CONTAINER:
656 switch( specific )
657 {
658 case RIGHT_CURLY_BRACE:
659 case RIGHT_SQUARE_BRACKET:
660 case RIGHT_PARENTHESIS:
661 return true;
662 }
663 break;
664
665
666 case PARAMETER_TERMINATORS:
667 return specific == RIGHT_PARENTHESIS || specific == COMMA;
668
669 case ARRAY_ITEM_TERMINATORS:
670 return specific == RIGHT_SQUARE_BRACKET || specific == COMMA;
671
672 case TYPE_LIST_TERMINATORS:
673 switch( specific )
674 {
675 case KEYWORD_IMPLEMENTS:
676 case KEYWORD_THROWS:
677 case LEFT_CURLY_BRACE:
678 case COMMA:
679 return true;
680 }
681 break;
682
683 case OPTIONAL_DATATYPE_FOLLOWERS:
684 switch( specific )
685 {
686 case IDENTIFIER:
687 case LEFT_SQUARE_BRACKET:
688 case DOT:
689 return true;
690 }
691 break;
692
693 case SWITCH_BLOCK_TERMINATORS:
694 if( specific == RIGHT_CURLY_BRACE )
695 {
696 return true;
697 }
698
699 /* FALL THROUGH */
700
701 case SWITCH_ENTRIES:
702 return specific == KEYWORD_CASE || specific == KEYWORD_DEFAULT;
703
704 case METHOD_CALL_STARTERS:
705 if( specific >= STRING && specific <= DECIMAL_NUMBER )
706 {
707 return true;
708 }
709 switch( specific )
710 {
711 case LEFT_PARENTHESIS:
712 case GSTRING_START:
713 case SYNTH_GSTRING:
714 case KEYWORD_NEW:
715 return true;
716 }
717 break;
718
719 case UNSAFE_OVER_NEWLINES:
720 if( ofType(specific, SYMBOL) )
721 {
722 switch( specific )
723 {
724 case LEFT_CURLY_BRACE:
725 case LEFT_PARENTHESIS:
726 case LEFT_SQUARE_BRACKET:
727 case PLUS:
728 case PLUS_PLUS:
729 case MINUS:
730 case MINUS_MINUS:
731 case REGEX_PATTERN:
732 case NOT:
733 return true;
734 }
735
736 return false;
737 }
738
739 switch( specific )
740 {
741 case KEYWORD_INSTANCEOF:
742 case GSTRING_EXPRESSION_START:
743 case GSTRING_EXPRESSION_END:
744 case GSTRING_END:
745 return false;
746 }
747
748 return true;
749
750 case PRECLUDES_CAST_OPERATOR:
751 switch( specific )
752 {
753 case PLUS:
754 case MINUS:
755 case PREFIX_MINUS:
756 case PREFIX_MINUS_MINUS:
757 case PREFIX_PLUS:
758 case PREFIX_PLUS_PLUS:
759 case LEFT_PARENTHESIS:
760 return false;
761 }
762
763 return !ofType( specific, COMPLEX_EXPRESSION );
764
765
766
767
768 case OPERATOR_EXPRESSION:
769 return specific >= DOT && specific <= RIGHT_SHIFT_UNSIGNED;
770
771 case SYNTH_EXPRESSION:
772 switch( specific )
773 {
774 case SYNTH_CAST:
775 case SYNTH_CLOSURE:
776 case SYNTH_TERNARY:
777 return true;
778 }
779 break;
780
781 case KEYWORD_EXPRESSION:
782 switch( specific )
783 {
784 case KEYWORD_NEW:
785 case KEYWORD_THIS:
786 case KEYWORD_SUPER:
787 case KEYWORD_INSTANCEOF:
788 case KEYWORD_TRUE:
789 case KEYWORD_FALSE:
790 case KEYWORD_NULL:
791 return true;
792 }
793 break;
794
795 case LITERAL_EXPRESSION:
796 return specific >= STRING && specific <= DECIMAL_NUMBER;
797
798 case ARRAY_EXPRESSION:
799 return specific == LEFT_SQUARE_BRACKET;
800
801 case EXPRESSION:
802 if( specific >= DOT && specific <= RIGHT_SHIFT_UNSIGNED )
803 {
804 return true;
805 }
806
807 if( specific >= STRING && specific <= DECIMAL_NUMBER )
808 {
809 return true;
810 }
811
812 switch( specific )
813 {
814 case SYNTH_CAST:
815 case SYNTH_CLOSURE:
816 case SYNTH_TERNARY:
817 case SYNTH_GSTRING:
818 case KEYWORD_NEW:
819 case KEYWORD_THIS:
820 case KEYWORD_SUPER:
821 case KEYWORD_INSTANCEOF:
822 case KEYWORD_TRUE:
823 case KEYWORD_FALSE:
824 case KEYWORD_NULL:
825 case LEFT_SQUARE_BRACKET:
826 return true;
827 }
828 break;
829
830 case COMPLEX_EXPRESSION:
831 switch( specific )
832 {
833 case KEYWORD_NEW:
834 case SYNTH_METHOD_CALL:
835 case SYNTH_GSTRING:
836 case SYNTH_LIST:
837 case SYNTH_MAP:
838 case SYNTH_CLOSURE:
839 case SYNTH_TERNARY:
840 case SYNTH_VARIABLE_DECLARATION:
841 return true;
842 }
843
844 /* FALL THROUGH */
845
846 case SIMPLE_EXPRESSION:
847 if( specific >= STRING && specific <= DECIMAL_NUMBER ) {
848 return true;
849 }
850
851 switch( specific ) {
852 case KEYWORD_SUPER:
853 case KEYWORD_THIS:
854 case KEYWORD_TRUE:
855 case KEYWORD_FALSE:
856 case KEYWORD_NULL:
857 return true;
858 }
859
860 break;
861 }
862
863 return false;
864 }
865
866
867
868
869 //---------------------------------------------------------------------------
870 // TYPE COERSIONS
871
872
873 /**
874 * Given two types, returns true if the first can be viewed as the second.
875 * NOTE that <code>canMean()</code> is orthogonal to <code>ofType()</code>.
876 */
877
878 public static boolean canMean( int actual, int preferred ) {
879
880 if( actual == preferred ) {
881 return true;
882 }
883
884 switch( preferred ) {
885
886 case SYNTH_PARAMETER_DECLARATION:
887 case IDENTIFIER:
888 switch( actual ) {
889 case IDENTIFIER:
890 case KEYWORD_DEF:
891 case KEYWORD_DEFMACRO:
892 case KEYWORD_CLASS:
893 case KEYWORD_INTERFACE:
894 case KEYWORD_MIXIN:
895 return true;
896 }
897 break;
898
899 case SYNTH_CLASS:
900 case SYNTH_INTERFACE:
901 case SYNTH_MIXIN:
902 case SYNTH_METHOD:
903 case SYNTH_PROPERTY:
904 return actual == IDENTIFIER;
905
906 case SYNTH_LIST:
907 case SYNTH_MAP:
908 return actual == LEFT_SQUARE_BRACKET;
909
910 case SYNTH_CAST:
911 return actual == LEFT_PARENTHESIS;
912
913 case SYNTH_BLOCK:
914 case SYNTH_CLOSURE:
915 return actual == LEFT_CURLY_BRACE;
916
917 case SYNTH_LABEL:
918 return actual == COLON;
919
920 case SYNTH_VARIABLE_DECLARATION:
921 return actual == IDENTIFIER;
922 }
923
924 return false;
925 }
926
927
928
929 /**
930 * Converts a node from a generic type to a specific prefix type.
931 * Throws a <code>GroovyBugError</code> if the type can't be converted
932 * and requested.
933 */
934
935 public static void makePrefix( CSTNode node, boolean throwIfInvalid ) {
936
937 switch( node.getMeaning() ) {
938 case PLUS:
939 node.setMeaning( PREFIX_PLUS );
940 break;
941
942 case MINUS:
943 node.setMeaning( PREFIX_MINUS );
944 break;
945
946 case PLUS_PLUS:
947 node.setMeaning( PREFIX_PLUS_PLUS );
948 break;
949
950 case MINUS_MINUS:
951 node.setMeaning( PREFIX_MINUS_MINUS );
952 break;
953
954 default:
955 if( throwIfInvalid ) {
956 throw new GroovyBugError( "cannot convert to prefix for type [" + node.getMeaning() + "]" );
957 }
958 }
959
960 }
961
962
963
964 /**
965 * Converts a node from a generic type to a specific postfix type.
966 * Throws a <code>GroovyBugError</code> if the type can't be converted.
967 */
968
969 public static void makePostfix( CSTNode node, boolean throwIfInvalid ) {
970
971 switch( node.getMeaning() ) {
972 case PLUS_PLUS:
973 node.setMeaning( POSTFIX_PLUS_PLUS );
974 break;
975
976 case MINUS_MINUS:
977 node.setMeaning( POSTFIX_MINUS_MINUS );
978 break;
979
980 default:
981 if( throwIfInvalid ) {
982 throw new GroovyBugError( "cannot convert to postfix for type [" + node.getMeaning() + "]" );
983 }
984 }
985
986 }
987
988
989
990
991 //---------------------------------------------------------------------------
992 // OPERATOR PRECEDENCE
993
994
995 /**
996 * Returns the precendence of the specified operator. Non-operator's will
997 * receive -1 or a GroovyBugError, depending on your preference.
998 */
999
1000 public static int getPrecedence( int type, boolean throwIfInvalid ) {
1001
1002 switch( type ) {
1003
1004 case LEFT_PARENTHESIS:
1005 return 0;
1006
1007 case EQUAL:
1008 case PLUS_EQUAL:
1009 case MINUS_EQUAL:
1010 case MULTIPLY_EQUAL:
1011 case DIVIDE_EQUAL:
1012 case INTDIV_EQUAL:
1013 case MOD_EQUAL:
1014 case POWER_EQUAL:
1015 case LOGICAL_OR_EQUAL:
1016 case LOGICAL_AND_EQUAL:
1017 case LEFT_SHIFT_EQUAL:
1018 case RIGHT_SHIFT_EQUAL:
1019 case RIGHT_SHIFT_UNSIGNED_EQUAL:
1020 case BITWISE_OR_EQUAL:
1021 case BITWISE_AND_EQUAL:
1022 case BITWISE_XOR_EQUAL:
1023 return 5;
1024
1025 case QUESTION:
1026 return 10;
1027
1028 case LOGICAL_OR:
1029 return 15;
1030
1031 case LOGICAL_AND:
1032 return 20;
1033
1034 case BITWISE_OR:
1035 case BITWISE_AND:
1036 case BITWISE_XOR:
1037 return 22;
1038
1039 case COMPARE_IDENTICAL:
1040 case COMPARE_NOT_IDENTICAL:
1041 return 24;
1042
1043 case COMPARE_NOT_EQUAL:
1044 case COMPARE_EQUAL:
1045 case COMPARE_LESS_THAN:
1046 case COMPARE_LESS_THAN_EQUAL:
1047 case COMPARE_GREATER_THAN:
1048 case COMPARE_GREATER_THAN_EQUAL:
1049 case COMPARE_TO:
1050 case FIND_REGEX:
1051 case MATCH_REGEX:
1052 case KEYWORD_INSTANCEOF:
1053 return 25;
1054
1055 case DOT_DOT:
1056 case DOT_DOT_DOT:
1057 return 30;
1058
1059 case LEFT_SHIFT:
1060 case RIGHT_SHIFT:
1061 case RIGHT_SHIFT_UNSIGNED:
1062 return 35;
1063
1064 case PLUS:
1065 case MINUS:
1066 return 40;
1067
1068 case MULTIPLY:
1069 case DIVIDE:
1070 case INTDIV:
1071 case MOD:
1072 return 45;
1073
1074 case NOT:
1075 case REGEX_PATTERN:
1076 return 50;
1077
1078 case SYNTH_CAST:
1079 return 55;
1080
1081 case PLUS_PLUS:
1082 case MINUS_MINUS:
1083 case PREFIX_PLUS_PLUS:
1084 case PREFIX_MINUS_MINUS:
1085 case POSTFIX_PLUS_PLUS:
1086 case POSTFIX_MINUS_MINUS:
1087 return 65;
1088
1089 case PREFIX_PLUS:
1090 case PREFIX_MINUS:
1091 return 70;
1092
1093 case POWER:
1094 return 72;
1095
1096 case SYNTH_METHOD:
1097 case LEFT_SQUARE_BRACKET:
1098 return 75;
1099
1100 case DOT:
1101 case NAVIGATE:
1102 return 80;
1103
1104 case KEYWORD_NEW:
1105 return 85;
1106 }
1107
1108 if( throwIfInvalid ) {
1109 throw new GroovyBugError( "precedence requested for non-operator" );
1110 }
1111
1112 return -1;
1113 }
1114
1115
1116
1117
1118 //---------------------------------------------------------------------------
1119 // TEXTS
1120
1121 private static final Map TEXTS = new HashMap(); // symbol/keyword type -> text
1122 private static final Map LOOKUP = new HashMap(); // text -> symbol/keyword type
1123
1124
1125 /**
1126 * Returns the type for the specified symbol/keyword text. Returns UNKNOWN
1127 * if the text isn't found. You can filter finds on a type.
1128 */
1129
1130 public static int lookup( String text, int filter ) {
1131 int type = UNKNOWN;
1132
1133 if( LOOKUP.containsKey(text) ) {
1134 type = ((Integer)LOOKUP.get(text)).intValue();
1135 if( filter != UNKNOWN && !ofType(type, filter) ) {
1136 type = UNKNOWN;
1137 }
1138 }
1139
1140 return type;
1141 }
1142
1143
1144 /**
1145 * Returns the type for the specified keyword text. Returns UNKNOWN
1146 * if the text isn't found.
1147 */
1148
1149 public static int lookupKeyword( String text ) {
1150 return lookup( text, KEYWORD );
1151 }
1152
1153
1154 /**
1155 * Returns the type for the specified symbol text. Returns UNKNOWN
1156 * if the text isn't found.
1157 */
1158
1159 public static int lookupSymbol( String text ) {
1160 return lookup( text, SYMBOL );
1161 }
1162
1163
1164 /**
1165 * Returns the text for the specified type. Returns "" if the
1166 * text isn't found.
1167 */
1168
1169 public static String getText( int type ) {
1170 Integer key = new Integer( type );
1171 String text = "";
1172
1173 if( TEXTS.containsKey(key) ) {
1174 text = (String)TEXTS.get( key );
1175 }
1176
1177 return text;
1178 }
1179
1180
1181 /**
1182 * Adds a element to the TEXTS and LOOKUP.
1183 */
1184
1185 private static void addTranslation( String text, int type ) {
1186 Integer key = new Integer( type );
1187
1188 TEXTS.put( key, text );
1189 LOOKUP.put( text, key );
1190 }
1191
1192
1193 static {
1194
1195 //
1196 // SYMBOLS
1197
1198 addTranslation( "\n" , NEWLINE );
1199
1200 addTranslation( "{" , LEFT_CURLY_BRACE );
1201 addTranslation( "}" , RIGHT_CURLY_BRACE );
1202 addTranslation( "[" , LEFT_SQUARE_BRACKET );
1203 addTranslation( "]" , RIGHT_SQUARE_BRACKET );
1204 addTranslation( "(" , LEFT_PARENTHESIS );
1205 addTranslation( ")" , RIGHT_PARENTHESIS );
1206
1207 addTranslation( "." , DOT );
1208 addTranslation( ".." , DOT_DOT );
1209 addTranslation( "..." , DOT_DOT_DOT );
1210
1211 addTranslation( "->" , NAVIGATE );
1212
1213 addTranslation( "=~" , FIND_REGEX );
1214 addTranslation( "==~" , MATCH_REGEX );
1215 addTranslation( "~" , REGEX_PATTERN );
1216
1217 addTranslation( "=" , EQUAL );
1218
1219 addTranslation( "!=" , COMPARE_NOT_EQUAL );
1220 addTranslation( "===" , COMPARE_IDENTICAL );
1221 addTranslation( "!==" , COMPARE_NOT_IDENTICAL );
1222 addTranslation( "==" , COMPARE_EQUAL );
1223 addTranslation( "<" , COMPARE_LESS_THAN );
1224 addTranslation( "<=" , COMPARE_LESS_THAN_EQUAL );
1225 addTranslation( ">" , COMPARE_GREATER_THAN );
1226 addTranslation( ">=" , COMPARE_GREATER_THAN_EQUAL );
1227 addTranslation( "<=>" , COMPARE_TO );
1228
1229 addTranslation( "!" , NOT );
1230 addTranslation( "||" , LOGICAL_OR );
1231 addTranslation( "&&" , LOGICAL_AND );
1232
1233 addTranslation( "||=" , LOGICAL_OR_EQUAL );
1234 addTranslation( "&&=" , LOGICAL_AND_EQUAL );
1235
1236 addTranslation( "+" , PLUS );
1237 addTranslation( "-" , MINUS );
1238 addTranslation( "*" , MULTIPLY );
1239 addTranslation( "/" , DIVIDE );
1240 addTranslation( "\\" , INTDIV );
1241 addTranslation( "%" , MOD );
1242
1243 addTranslation( "**" , POWER );
1244
1245 addTranslation( "+=" , PLUS_EQUAL );
1246 addTranslation( "-=" , MINUS_EQUAL );
1247 addTranslation( "*=" , MULTIPLY_EQUAL );
1248 addTranslation( "/=" , DIVIDE_EQUAL );
1249 addTranslation( "\\=" , INTDIV_EQUAL );
1250 addTranslation( "%=" , MOD_EQUAL );
1251 addTranslation( "**=" , POWER_EQUAL );
1252
1253 addTranslation( "++" , PLUS_PLUS );
1254 addTranslation( "--" , MINUS_MINUS );
1255
1256 addTranslation( "<<" , LEFT_SHIFT );
1257 addTranslation( ">>" , RIGHT_SHIFT );
1258 addTranslation( ">>>" , RIGHT_SHIFT_UNSIGNED );
1259
1260 addTranslation( "<<=" , LEFT_SHIFT_EQUAL );
1261 addTranslation( ">>=" , RIGHT_SHIFT_EQUAL );
1262 addTranslation( ">>>=" , RIGHT_SHIFT_UNSIGNED_EQUAL );
1263
1264 addTranslation( "&" , BITWISE_AND );
1265 addTranslation( "^" , BITWISE_XOR );
1266
1267 addTranslation( "|=" , BITWISE_OR_EQUAL );
1268 addTranslation( "&=" , BITWISE_AND_EQUAL );
1269 addTranslation( "^=" , BITWISE_XOR_EQUAL );
1270
1271 addTranslation( "," , COMMA );
1272 addTranslation( ":" , COLON );
1273 addTranslation( ";" , SEMICOLON );
1274 addTranslation( "?" , QUESTION );
1275 addTranslation( "|" , PIPE );
1276
1277 addTranslation( "${}" , GSTRING_EXPRESSION_START );
1278
1279
1280 //
1281 // Keywords
1282
1283 addTranslation( "abstract" , KEYWORD_ABSTRACT );
1284 addTranslation( "as" , KEYWORD_AS );
1285 addTranslation( "assert" , KEYWORD_ASSERT );
1286 addTranslation( "break" , KEYWORD_BREAK );
1287 addTranslation( "case" , KEYWORD_CASE );
1288 addTranslation( "catch" , KEYWORD_CATCH );
1289 addTranslation( "class" , KEYWORD_CLASS );
1290 addTranslation( "const" , KEYWORD_CONST );
1291 addTranslation( "continue" , KEYWORD_CONTINUE );
1292 addTranslation( "def" , KEYWORD_DEF );
1293 addTranslation( "defmacro" , KEYWORD_DEF ); // xxx br defmacro
1294 addTranslation( "default" , KEYWORD_DEFAULT );
1295 addTranslation( "do" , KEYWORD_DO );
1296 addTranslation( "else" , KEYWORD_ELSE );
1297 addTranslation( "extends" , KEYWORD_EXTENDS );
1298 addTranslation( "final" , KEYWORD_FINAL );
1299 addTranslation( "finally" , KEYWORD_FINALLY );
1300 addTranslation( "for" , KEYWORD_FOR );
1301 addTranslation( "goto" , KEYWORD_GOTO );
1302 addTranslation( "if" , KEYWORD_IF );
1303 addTranslation( "in" , KEYWORD_IN );
1304 addTranslation( "implements" , KEYWORD_IMPLEMENTS );
1305 addTranslation( "import" , KEYWORD_IMPORT );
1306 addTranslation( "instanceof" , KEYWORD_INSTANCEOF );
1307 addTranslation( "interface" , KEYWORD_INTERFACE );
1308 addTranslation( "mixin" , KEYWORD_MIXIN );
1309 addTranslation( "native" , KEYWORD_NATIVE );
1310 addTranslation( "new" , KEYWORD_NEW );
1311 addTranslation( "package" , KEYWORD_PACKAGE );
1312 addTranslation( "private" , KEYWORD_PRIVATE );
1313 addTranslation( "property" , KEYWORD_PROPERTY );
1314 addTranslation( "protected" , KEYWORD_PROTECTED );
1315 addTranslation( "public" , KEYWORD_PUBLIC );
1316 addTranslation( "return" , KEYWORD_RETURN );
1317 addTranslation( "static" , KEYWORD_STATIC );
1318 addTranslation( "super" , KEYWORD_SUPER );
1319 addTranslation( "switch" , KEYWORD_SWITCH );
1320 addTranslation( "synchronized", KEYWORD_SYNCHRONIZED );
1321 addTranslation( "this" , KEYWORD_THIS );
1322 addTranslation( "throw" , KEYWORD_THROW );
1323 addTranslation( "throws" , KEYWORD_THROWS );
1324 addTranslation( "transient" , KEYWORD_TRANSIENT );
1325 addTranslation( "try" , KEYWORD_TRY );
1326 addTranslation( "volatile" , KEYWORD_VOLATILE );
1327 addTranslation( "while" , KEYWORD_WHILE );
1328
1329 addTranslation( "true" , KEYWORD_TRUE );
1330 addTranslation( "false" , KEYWORD_FALSE );
1331 addTranslation( "null" , KEYWORD_NULL );
1332
1333 addTranslation( "void" , KEYWORD_VOID );
1334 addTranslation( "boolean" , KEYWORD_BOOLEAN );
1335 addTranslation( "byte" , KEYWORD_BYTE );
1336 addTranslation( "int" , KEYWORD_INT );
1337 addTranslation( "short" , KEYWORD_SHORT );
1338 addTranslation( "long" , KEYWORD_LONG );
1339 addTranslation( "float" , KEYWORD_FLOAT );
1340 addTranslation( "double" , KEYWORD_DOUBLE );
1341 addTranslation( "char" , KEYWORD_CHAR );
1342 }
1343
1344
1345
1346
1347 //---------------------------------------------------------------------------
1348 // DESCRIPTIONS
1349
1350
1351 private static final Map DESCRIPTIONS = new HashMap();
1352
1353
1354 /**
1355 * Gets the description for the specified type.
1356 */
1357
1358 public static String getDescription( int type ) {
1359 Integer typeKey = new Integer(type);
1360
1361 if (DESCRIPTIONS.containsKey(typeKey)) {
1362 return (String)DESCRIPTIONS.get(typeKey);
1363 }
1364
1365 return "<>";
1366 }
1367
1368
1369 /**
1370 * Adds a description to the set.
1371 */
1372
1373 private static void addDescription(int type, String description) {
1374 addDescription(new Integer(type), description);
1375 }
1376
1377
1378 /**
1379 * Adds a description to the set.
1380 */
1381
1382 private static void addDescription(Integer type, String description) {
1383 if (description.startsWith("<") && description.endsWith(">")) {
1384 DESCRIPTIONS.put(type, description);
1385 }
1386 else {
1387 DESCRIPTIONS.put(type, '"' + description + '"');
1388 }
1389 }
1390
1391
1392 static {
1393
1394 Iterator iterator = LOOKUP.keySet().iterator();
1395 while( iterator.hasNext() )
1396 {
1397 String text = (String)iterator.next();
1398 Integer key = (Integer)LOOKUP.get(text);
1399
1400 addDescription( key, text );
1401 }
1402
1403 addDescription( NEWLINE , "<newline>" );
1404 addDescription( PREFIX_PLUS_PLUS , "<prefix ++>" );
1405 addDescription( POSTFIX_PLUS_PLUS , "<postfix ++>" );
1406 addDescription( PREFIX_MINUS_MINUS , "<prefix -->" );
1407 addDescription( POSTFIX_MINUS_MINUS , "<postfix -->" );
1408 addDescription( PREFIX_PLUS , "<positive>" );
1409 addDescription( PREFIX_MINUS , "<negative>" );
1410
1411 addDescription( STRING , "<string literal>" );
1412 addDescription( IDENTIFIER , "<identifier>" );
1413 addDescription( INTEGER_NUMBER , "<integer>" );
1414 addDescription( DECIMAL_NUMBER , "<decimal>" );
1415
1416 addDescription( SYNTH_COMPILATION_UNIT , "<compilation unit>" );
1417 addDescription( SYNTH_CLASS , "<class>" );
1418 addDescription( SYNTH_INTERFACE , "<interface>" );
1419 addDescription( SYNTH_MIXIN , "<mixin>" );
1420 addDescription( SYNTH_METHOD , "<method>" );
1421 addDescription( SYNTH_METHOD_CALL , "<method call>" );
1422 addDescription( SYNTH_PROPERTY , "<property>" );
1423 addDescription( SYNTH_PARAMETER_DECLARATION , "<parameter>" );
1424 addDescription( SYNTH_LIST , "<list>" );
1425 addDescription( SYNTH_MAP , "<map>" );
1426 addDescription( SYNTH_TUPLE , "<tuple>" );
1427 addDescription( SYNTH_GSTRING , "<gstring>" );
1428 addDescription( SYNTH_CAST , "<cast>" );
1429 addDescription( SYNTH_BLOCK , "<block>" );
1430 addDescription( SYNTH_CLOSURE , "<closure>" );
1431 addDescription( SYNTH_TERNARY , "<ternary>" );
1432 addDescription( SYNTH_LABEL , "<label>" );
1433 addDescription( SYNTH_VARIABLE_DECLARATION , "<variable declaration>" );
1434
1435 addDescription( GSTRING_START , "<start of gstring tokens>" );
1436 addDescription( GSTRING_END , "<end of gstring tokens>" );
1437 addDescription( GSTRING_EXPRESSION_START , "<start of gstring expression>");
1438 addDescription( GSTRING_EXPRESSION_END , "<end of gstring expression>" );
1439
1440 addDescription( ASSIGNMENT_OPERATOR , "<assignment operator>" );
1441 addDescription( COMPARISON_OPERATOR , "<comparison operator>" );
1442 addDescription( MATH_OPERATOR , "<math operator>" );
1443 addDescription( LOGICAL_OPERATOR , "<logical operator>" );
1444 addDescription( BITWISE_OPERATOR , "<bitwise operator>" );
1445 addDescription( RANGE_OPERATOR , "<range operator>" );
1446 addDescription( REGEX_COMPARISON_OPERATOR , "<regex comparison operator>" );
1447 addDescription( DEREFERENCE_OPERATOR , "<dereference operator>" );
1448 addDescription( PREFIX_OPERATOR , "<prefix operator>" );
1449 addDescription( POSTFIX_OPERATOR , "<postfix operator>" );
1450 addDescription( INFIX_OPERATOR , "<infix operator>" );
1451 addDescription( KEYWORD , "<keyword>" );
1452 addDescription( LITERAL , "<literal>" );
1453 addDescription( NUMBER , "<number>" );
1454 addDescription( NAMED_VALUE , "<named value>" );
1455 addDescription( TRUTH_VALUE , "<truth value>" );
1456 addDescription( PRIMITIVE_TYPE , "<primitive type>" );
1457 addDescription( CREATABLE_PRIMITIVE_TYPE , "<creatable primitive type>" );
1458 addDescription( LOOP , "<loop>" );
1459 addDescription( RESERVED_KEYWORD , "<reserved keyword>" );
1460 addDescription( SYNTHETIC , "<synthetic>" );
1461 addDescription( TYPE_DECLARATION , "<type declaration>" );
1462 addDescription( DECLARATION_MODIFIER , "<declaration modifier>" );
1463 addDescription( TYPE_NAME , "<type name>" );
1464 addDescription( CREATABLE_TYPE_NAME , "<creatable type name>" );
1465 addDescription( MATCHED_CONTAINER , "<matched container>" );
1466 addDescription( LEFT_OF_MATCHED_CONTAINER , "<left of matched container>" );
1467 addDescription( RIGHT_OF_MATCHED_CONTAINER , "<right of matched container>" );
1468 addDescription( SWITCH_ENTRIES , "<valid in a switch body>" );
1469 }
1470
1471 }