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