types.java
来自「Groovy动态语言 运行在JVM中的动态语言 可以方便的处理业务逻辑变化大的业」· Java 代码 · 共 1,472 行 · 第 1/4 页
JAVA
1,472 行
}
switch( specific )
{
case KEYWORD_INSTANCEOF:
case GSTRING_EXPRESSION_START:
case GSTRING_EXPRESSION_END:
case GSTRING_END:
return false;
}
return true;
case PRECLUDES_CAST_OPERATOR:
switch( specific )
{
case PLUS:
case MINUS:
case PREFIX_MINUS:
case PREFIX_MINUS_MINUS:
case PREFIX_PLUS:
case PREFIX_PLUS_PLUS:
case LEFT_PARENTHESIS:
return false;
}
return !ofType( specific, COMPLEX_EXPRESSION );
case OPERATOR_EXPRESSION:
return specific >= DOT && specific <= RIGHT_SHIFT_UNSIGNED;
case SYNTH_EXPRESSION:
switch( specific )
{
case SYNTH_CAST:
case SYNTH_CLOSURE:
case SYNTH_TERNARY:
return true;
}
break;
case KEYWORD_EXPRESSION:
switch( specific )
{
case KEYWORD_NEW:
case KEYWORD_THIS:
case KEYWORD_SUPER:
case KEYWORD_INSTANCEOF:
case KEYWORD_TRUE:
case KEYWORD_FALSE:
case KEYWORD_NULL:
return true;
}
break;
case LITERAL_EXPRESSION:
return specific >= STRING && specific <= DECIMAL_NUMBER;
case ARRAY_EXPRESSION:
return specific == LEFT_SQUARE_BRACKET;
case EXPRESSION:
if( specific >= DOT && specific <= RIGHT_SHIFT_UNSIGNED )
{
return true;
}
if( specific >= STRING && specific <= DECIMAL_NUMBER )
{
return true;
}
switch( specific )
{
case SYNTH_CAST:
case SYNTH_CLOSURE:
case SYNTH_TERNARY:
case SYNTH_GSTRING:
case KEYWORD_NEW:
case KEYWORD_THIS:
case KEYWORD_SUPER:
case KEYWORD_INSTANCEOF:
case KEYWORD_TRUE:
case KEYWORD_FALSE:
case KEYWORD_NULL:
case LEFT_SQUARE_BRACKET:
return true;
}
break;
case COMPLEX_EXPRESSION:
switch( specific )
{
case KEYWORD_NEW:
case SYNTH_METHOD_CALL:
case SYNTH_GSTRING:
case SYNTH_LIST:
case SYNTH_MAP:
case SYNTH_CLOSURE:
case SYNTH_TERNARY:
case SYNTH_VARIABLE_DECLARATION:
return true;
}
/* FALL THROUGH */
case SIMPLE_EXPRESSION:
if( specific >= STRING && specific <= DECIMAL_NUMBER ) {
return true;
}
switch( specific ) {
case KEYWORD_SUPER:
case KEYWORD_THIS:
case KEYWORD_TRUE:
case KEYWORD_FALSE:
case KEYWORD_NULL:
return true;
}
break;
}
return false;
}
//---------------------------------------------------------------------------
// TYPE COERSIONS
/**
* Given two types, returns true if the first can be viewed as the second.
* NOTE that <code>canMean()</code> is orthogonal to <code>ofType()</code>.
*/
public static boolean canMean( int actual, int preferred ) {
if( actual == preferred ) {
return true;
}
switch( preferred ) {
case SYNTH_PARAMETER_DECLARATION:
case IDENTIFIER:
switch( actual ) {
case IDENTIFIER:
case KEYWORD_DEF:
case KEYWORD_DEFMACRO:
case KEYWORD_CLASS:
case KEYWORD_INTERFACE:
case KEYWORD_MIXIN:
return true;
}
break;
case SYNTH_CLASS:
case SYNTH_INTERFACE:
case SYNTH_MIXIN:
case SYNTH_METHOD:
case SYNTH_PROPERTY:
return actual == IDENTIFIER;
case SYNTH_LIST:
case SYNTH_MAP:
return actual == LEFT_SQUARE_BRACKET;
case SYNTH_CAST:
return actual == LEFT_PARENTHESIS;
case SYNTH_BLOCK:
case SYNTH_CLOSURE:
return actual == LEFT_CURLY_BRACE;
case SYNTH_LABEL:
return actual == COLON;
case SYNTH_VARIABLE_DECLARATION:
return actual == IDENTIFIER;
}
return false;
}
/**
* Converts a node from a generic type to a specific prefix type.
* Throws a <code>GroovyBugError</code> if the type can't be converted
* and requested.
*/
public static void makePrefix( CSTNode node, boolean throwIfInvalid ) {
switch( node.getMeaning() ) {
case PLUS:
node.setMeaning( PREFIX_PLUS );
break;
case MINUS:
node.setMeaning( PREFIX_MINUS );
break;
case PLUS_PLUS:
node.setMeaning( PREFIX_PLUS_PLUS );
break;
case MINUS_MINUS:
node.setMeaning( PREFIX_MINUS_MINUS );
break;
default:
if( throwIfInvalid ) {
throw new GroovyBugError( "cannot convert to prefix for type [" + node.getMeaning() + "]" );
}
}
}
/**
* Converts a node from a generic type to a specific postfix type.
* Throws a <code>GroovyBugError</code> if the type can't be converted.
*/
public static void makePostfix( CSTNode node, boolean throwIfInvalid ) {
switch( node.getMeaning() ) {
case PLUS_PLUS:
node.setMeaning( POSTFIX_PLUS_PLUS );
break;
case MINUS_MINUS:
node.setMeaning( POSTFIX_MINUS_MINUS );
break;
default:
if( throwIfInvalid ) {
throw new GroovyBugError( "cannot convert to postfix for type [" + node.getMeaning() + "]" );
}
}
}
//---------------------------------------------------------------------------
// OPERATOR PRECEDENCE
/**
* Returns the precendence of the specified operator. Non-operator's will
* receive -1 or a GroovyBugError, depending on your preference.
*/
public static int getPrecedence( int type, boolean throwIfInvalid ) {
switch( type ) {
case LEFT_PARENTHESIS:
return 0;
case EQUAL:
case PLUS_EQUAL:
case MINUS_EQUAL:
case MULTIPLY_EQUAL:
case DIVIDE_EQUAL:
case INTDIV_EQUAL:
case MOD_EQUAL:
case POWER_EQUAL:
case LOGICAL_OR_EQUAL:
case LOGICAL_AND_EQUAL:
case LEFT_SHIFT_EQUAL:
case RIGHT_SHIFT_EQUAL:
case RIGHT_SHIFT_UNSIGNED_EQUAL:
case BITWISE_OR_EQUAL:
case BITWISE_AND_EQUAL:
case BITWISE_XOR_EQUAL:
return 5;
case QUESTION:
return 10;
case LOGICAL_OR:
return 15;
case LOGICAL_AND:
return 20;
case BITWISE_OR:
case BITWISE_AND:
case BITWISE_XOR:
return 22;
case COMPARE_IDENTICAL:
case COMPARE_NOT_IDENTICAL:
return 24;
case COMPARE_NOT_EQUAL:
case COMPARE_EQUAL:
case COMPARE_LESS_THAN:
case COMPARE_LESS_THAN_EQUAL:
case COMPARE_GREATER_THAN:
case COMPARE_GREATER_THAN_EQUAL:
case COMPARE_TO:
case FIND_REGEX:
case MATCH_REGEX:
case KEYWORD_INSTANCEOF:
return 25;
case DOT_DOT:
case DOT_DOT_DOT:
return 30;
case LEFT_SHIFT:
case RIGHT_SHIFT:
case RIGHT_SHIFT_UNSIGNED:
return 35;
case PLUS:
case MINUS:
return 40;
case MULTIPLY:
case DIVIDE:
case INTDIV:
case MOD:
return 45;
case NOT:
case REGEX_PATTERN:
return 50;
case SYNTH_CAST:
return 55;
case PLUS_PLUS:
case MINUS_MINUS:
case PREFIX_PLUS_PLUS:
case PREFIX_MINUS_MINUS:
case POSTFIX_PLUS_PLUS:
case POSTFIX_MINUS_MINUS:
return 65;
case PREFIX_PLUS:
case PREFIX_MINUS:
return 70;
case POWER:
return 72;
case SYNTH_METHOD:
case LEFT_SQUARE_BRACKET:
return 75;
case DOT:
case NAVIGATE:
return 80;
case KEYWORD_NEW:
⌨️ 快捷键说明
复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?