types.java

大名鼎鼎的java动态脚本语言。已经通过了sun的认证

                return 85;
        }

        if( throwIfInvalid ) {
            throw new GroovyBugError( "precedence requested for non-operator" );
        }

        return -1;
    }




  //---------------------------------------------------------------------------
  // TEXTS

    private static final Map TEXTS  = new HashMap();  // symbol/keyword type -> text
    private static final Map LOOKUP = new HashMap();  // text -> symbol/keyword type


   /**
    *  Returns the type for the specified symbol/keyword text.  Returns UNKNOWN
    *  if the text isn't found.  You can filter finds on a type.
    */

    public static int lookup( String text, int filter ) {
        int type = UNKNOWN;

        if( LOOKUP.containsKey(text) ) {
            type = ((Integer)LOOKUP.get(text)).intValue();
            if( filter != UNKNOWN && !ofType(type, filter) ) {
                type = UNKNOWN;
            }
        }

        return type;
    }


   /**
    *  Returns the type for the specified keyword text.  Returns UNKNOWN
    *  if the text isn't found.
    */

    public static int lookupKeyword( String text ) {
        return lookup( text, KEYWORD );
    }


   /**
    *  Returns the type for the specified symbol text.  Returns UNKNOWN
    *  if the text isn't found.
    */

    public static int lookupSymbol( String text ) {
        return lookup( text, SYMBOL );
    }


   /**
    *  Returns the text for the specified type.  Returns "" if the
    *  text isn't found.
    */

    public static String getText( int type ) {
        Integer key = new Integer( type );
        String text = "";

        if( TEXTS.containsKey(key) ) {
            text = (String)TEXTS.get( key );
        }

        return text;
    }


   /**
    *  Adds a element to the TEXTS and LOOKUP.
    */

    private static void addTranslation( String text, int type ) {
        Integer key = new Integer( type );

        TEXTS.put( key, text );
        LOOKUP.put( text, key );
    }


    static {

        //
        // SYMBOLS

        addTranslation( "\n"          , NEWLINE                     );

        addTranslation( "{"           , LEFT_CURLY_BRACE            );
        addTranslation( "}"           , RIGHT_CURLY_BRACE           );
        addTranslation( "["           , LEFT_SQUARE_BRACKET         );
        addTranslation( "]"           , RIGHT_SQUARE_BRACKET        );
        addTranslation( "("           , LEFT_PARENTHESIS            );
        addTranslation( ")"           , RIGHT_PARENTHESIS           );

        addTranslation( "."           , DOT                         );
        addTranslation( ".."          , DOT_DOT                     );
        addTranslation( "..."         , DOT_DOT_DOT                 );

        addTranslation( "->"          , NAVIGATE                    );

        addTranslation( "=~"          , FIND_REGEX                  );
        addTranslation( "==~"         , MATCH_REGEX                 );
        addTranslation( "~"           , REGEX_PATTERN               );

        addTranslation( "="           , EQUAL                       );

        addTranslation( "!="          , COMPARE_NOT_EQUAL           );
        addTranslation( "==="         , COMPARE_IDENTICAL           );
        addTranslation( "!=="         , COMPARE_NOT_IDENTICAL       );
        addTranslation( "=="          , COMPARE_EQUAL               );
        addTranslation( "<"           , COMPARE_LESS_THAN           );
        addTranslation( "<="          , COMPARE_LESS_THAN_EQUAL     );
        addTranslation( ">"           , COMPARE_GREATER_THAN        );
        addTranslation( ">="          , COMPARE_GREATER_THAN_EQUAL  );
        addTranslation( "<=>"         , COMPARE_TO                  );

        addTranslation( "!"           , NOT                         );
        addTranslation( "||"          , LOGICAL_OR                  );
        addTranslation( "&&"          , LOGICAL_AND                 );

        addTranslation( "||="         , LOGICAL_OR_EQUAL            );
        addTranslation( "&&="         , LOGICAL_AND_EQUAL           );

        addTranslation( "+"           , PLUS                        );
        addTranslation( "-"           , MINUS                       );
        addTranslation( "*"           , MULTIPLY                    );
        addTranslation( "/"           , DIVIDE                      );
        addTranslation( "\\"          , INTDIV                      );
        addTranslation( "%"           , MOD                         );

	addTranslation( "**"          , POWER                       );

        addTranslation( "+="          , PLUS_EQUAL                  );
        addTranslation( "-="          , MINUS_EQUAL                 );
        addTranslation( "*="          , MULTIPLY_EQUAL              );
        addTranslation( "/="          , DIVIDE_EQUAL                );
        addTranslation( "\\="         , INTDIV_EQUAL                );
        addTranslation( "%="          , MOD_EQUAL                   );
        addTranslation( "**="         , POWER_EQUAL                 );

        addTranslation( "++"          , PLUS_PLUS                   );
        addTranslation( "--"          , MINUS_MINUS                 );

        addTranslation( "<<"          , LEFT_SHIFT                  );
        addTranslation( ">>"          , RIGHT_SHIFT                 );
        addTranslation( ">>>"         , RIGHT_SHIFT_UNSIGNED        );

        addTranslation( "<<="         , LEFT_SHIFT_EQUAL            );
        addTranslation( ">>="         , RIGHT_SHIFT_EQUAL           );
        addTranslation( ">>>="        , RIGHT_SHIFT_UNSIGNED_EQUAL  );

        addTranslation( "&"           , BITWISE_AND                 );
        addTranslation( "^"           , BITWISE_XOR                 );

        addTranslation( "|="          , BITWISE_OR_EQUAL           );
        addTranslation( "&="          , BITWISE_AND_EQUAL           );
        addTranslation( "^="          , BITWISE_XOR_EQUAL           );

        addTranslation( ","           , COMMA                       );
        addTranslation( ":"           , COLON                       );
        addTranslation( ";"           , SEMICOLON                   );
        addTranslation( "?"           , QUESTION                    );
        addTranslation( "|"           , PIPE                        );

        addTranslation( "${}"         , GSTRING_EXPRESSION_START    );


        //
        // Keywords

        addTranslation( "abstract"    , KEYWORD_ABSTRACT            );
        addTranslation( "as"          , KEYWORD_AS                  );
        addTranslation( "assert"      , KEYWORD_ASSERT              );
        addTranslation( "break"       , KEYWORD_BREAK               );
        addTranslation( "case"        , KEYWORD_CASE                );
        addTranslation( "catch"       , KEYWORD_CATCH               );
        addTranslation( "class"       , KEYWORD_CLASS               );
        addTranslation( "const"       , KEYWORD_CONST               );
        addTranslation( "continue"    , KEYWORD_CONTINUE            );
        addTranslation( "def"         , KEYWORD_DEF                 );
        addTranslation( "defmacro"    , KEYWORD_DEF                 ); // xxx br defmacro
        addTranslation( "default"     , KEYWORD_DEFAULT             );
        addTranslation( "do"          , KEYWORD_DO                  );
        addTranslation( "else"        , KEYWORD_ELSE                );
        addTranslation( "extends"     , KEYWORD_EXTENDS             );
        addTranslation( "final"       , KEYWORD_FINAL               );
        addTranslation( "finally"     , KEYWORD_FINALLY             );
        addTranslation( "for"         , KEYWORD_FOR                 );
        addTranslation( "goto"        , KEYWORD_GOTO                );
        addTranslation( "if"          , KEYWORD_IF                  );
        addTranslation( "in"          , KEYWORD_IN                  );
        addTranslation( "implements"  , KEYWORD_IMPLEMENTS          );
        addTranslation( "import"      , KEYWORD_IMPORT              );
        addTranslation( "instanceof"  , KEYWORD_INSTANCEOF          );
        addTranslation( "interface"   , KEYWORD_INTERFACE           );
        addTranslation( "mixin"       , KEYWORD_MIXIN               );
        addTranslation( "native"      , KEYWORD_NATIVE              );
        addTranslation( "new"         , KEYWORD_NEW                 );
        addTranslation( "package"     , KEYWORD_PACKAGE             );
        addTranslation( "private"     , KEYWORD_PRIVATE             );
        addTranslation( "property"    , KEYWORD_PROPERTY            );
        addTranslation( "protected"   , KEYWORD_PROTECTED           );
        addTranslation( "public"      , KEYWORD_PUBLIC              );
        addTranslation( "return"      , KEYWORD_RETURN              );
        addTranslation( "static"      , KEYWORD_STATIC              );
        addTranslation( "super"       , KEYWORD_SUPER               );
        addTranslation( "switch"      , KEYWORD_SWITCH              );
        addTranslation( "synchronized", KEYWORD_SYNCHRONIZED        );
        addTranslation( "this"        , KEYWORD_THIS                );
        addTranslation( "throw"       , KEYWORD_THROW               );
        addTranslation( "throws"      , KEYWORD_THROWS              );
        addTranslation( "transient"   , KEYWORD_TRANSIENT           );
        addTranslation( "try"         , KEYWORD_TRY                 );
        addTranslation( "volatile"    , KEYWORD_VOLATILE            );
        addTranslation( "while"       , KEYWORD_WHILE               );

        addTranslation( "true"        , KEYWORD_TRUE                );
        addTranslation( "false"       , KEYWORD_FALSE               );
        addTranslation( "null"        , KEYWORD_NULL                );

        addTranslation( "void"        , KEYWORD_VOID                );
        addTranslation( "boolean"     , KEYWORD_BOOLEAN             );
        addTranslation( "byte"        , KEYWORD_BYTE                );
        addTranslation( "int"         , KEYWORD_INT                 );
        addTranslation( "short"       , KEYWORD_SHORT               );
        addTranslation( "long"        , KEYWORD_LONG                );
        addTranslation( "float"       , KEYWORD_FLOAT               );
        addTranslation( "double"      , KEYWORD_DOUBLE              );
        addTranslation( "char"        , KEYWORD_CHAR                );
    }




  //---------------------------------------------------------------------------
  // DESCRIPTIONS


    private static final Map DESCRIPTIONS = new HashMap();


   /**
    *  Gets the description for the specified type.
    */

    public static String getDescription( int type ) {
        Integer typeKey = new Integer(type);

        if (DESCRIPTIONS.containsKey(typeKey)) {
            return (String)DESCRIPTIONS.get(typeKey);
        }

        return "<>";
    }


   /**
    *  Adds a description to the set.
    */

    private static void addDescription(int type, String description) {
        addDescription(new Integer(type), description);
    }


   /**
    *  Adds a description to the set.
    */

    private static void addDescription(Integer type, String description) {
        if (description.startsWith("<") && description.endsWith(">")) {
            DESCRIPTIONS.put(type, description);
        }
        else {
            DESCRIPTIONS.put(type, '"' + description + '"');
        }
    }


    static {

        Iterator iterator = LOOKUP.keySet().iterator();
        while( iterator.hasNext() )
        {
            String text = (String)iterator.next();
            Integer key = (Integer)LOOKUP.get(text);

            addDescription( key, text );
        }

        addDescription( NEWLINE                     , "<newline>"        );
        addDescription( PREFIX_PLUS_PLUS            , "<prefix ++>"      );
        addDescription( POSTFIX_PLUS_PLUS           , "<postfix ++>"     );
        addDescription( PREFIX_MINUS_MINUS          , "<prefix -->"      );
        addDescription( POSTFIX_MINUS_MINUS         , "<postfix -->"     );
        addDescription( PREFIX_PLUS                 , "<positive>"       );
        addDescription( PREFIX_MINUS                , "<negative>"       );

        addDescription( STRING                      , "<string literal>" );
        addDescription( IDENTIFIER                  , "<identifier>"     );
        addDescription( INTEGER_NUMBER              , "<integer>"        );
        addDescription( DECIMAL_NUMBER              , "<decimal>"        );

        addDescription( SYNTH_COMPILATION_UNIT      , "<compilation unit>" );
        addDescription( SYNTH_CLASS                 , "<class>"          );
        addDescription( SYNTH_INTERFACE             , "<interface>"      );
        addDescription( SYNTH_MIXIN                 , "<mixin>"          );
        addDescription( SYNTH_METHOD                , "<method>"         );
        addDescription( SYNTH_METHOD_CALL           , "<method call>"    );
        addDescription( SYNTH_PROPERTY              , "<property>"       );
        addDescription( SYNTH_PARAMETER_DECLARATION , "<parameter>"      );
        addDescription( SYNTH_LIST                  , "<list>"           );
        addDescription( SYNTH_MAP                   , "<map>"            );
        addDescription( SYNTH_TUPLE                 , "<tuple>"          );
        addDescription( SYNTH_GSTRING               , "<gstring>"        );
        addDescription( SYNTH_CAST                  , "<cast>"           );
        addDescription( SYNTH_BLOCK                 , "<block>"          );
        addDescription( SYNTH_CLOSURE               , "<closure>"        );
        addDescription( SYNTH_TERNARY               , "<ternary>"        );
        addDescription( SYNTH_LABEL                 , "<label>"          );
        addDescription( SYNTH_VARIABLE_DECLARATION  , "<variable declaration>"       );

        addDescription( GSTRING_START               , "<start of gstring tokens>"    );
        addDescription( GSTRING_END                 , "<end of gstring tokens>"      );
        addDescription( GSTRING_EXPRESSION_START    , "<start of gstring expression>");
        addDescription( GSTRING_EXPRESSION_END      , "<end of gstring expression>"  );

        addDescription( ASSIGNMENT_OPERATOR         , "<assignment operator>"        );
        addDescription( COMPARISON_OPERATOR         , "<comparison operator>"        );
        addDescription( MATH_OPERATOR               , "<math operator>"              );
        addDescription( LOGICAL_OPERATOR            , "<logical operator>"           );
        addDescription( BITWISE_OPERATOR            , "<bitwise operator>"           );
        addDescription( RANGE_OPERATOR              , "<range operator>"             );
        addDescription( REGEX_COMPARISON_OPERATOR   , "<regex comparison operator>"  );
        addDescription( DEREFERENCE_OPERATOR        , "<dereference operator>"       );
        addDescription( PREFIX_OPERATOR             , "<prefix operator>"            );
        addDescription( POSTFIX_OPERATOR            , "<postfix operator>"           );
        addDescription( INFIX_OPERATOR              , "<infix operator>"             );
        addDescription( KEYWORD                     , "<keyword>"                    );
        addDescription( LITERAL                     , "<literal>"                    );
        addDescription( NUMBER                      , "<number>"                     );
        addDescription( NAMED_VALUE                 , "<named value>"                );
        addDescription( TRUTH_VALUE                 , "<truth value>"                );
        addDescription( PRIMITIVE_TYPE              , "<primitive type>"             );
        addDescription( CREATABLE_PRIMITIVE_TYPE    , "<creatable primitive type>"   );
        addDescription( LOOP                        , "<loop>"                       );
        addDescription( RESERVED_KEYWORD            , "<reserved keyword>"           );
        addDescription( SYNTHETIC                   , "<synthetic>"                  );
        addDescription( TYPE_DECLARATION            , "<type declaration>"           );
        addDescription( DECLARATION_MODIFIER        , "<declaration modifier>"       );
        addDescription( TYPE_NAME                   , "<type name>"                  );
        addDescription( CREATABLE_TYPE_NAME         , "<creatable type name>"        );
        addDescription( MATCHED_CONTAINER           , "<matched container>"          );
        addDescription( LEFT_OF_MATCHED_CONTAINER   , "<left of matched container>"  );
        addDescription( RIGHT_OF_MATCHED_CONTAINER  , "<right of matched container>" );
        addDescription( SWITCH_ENTRIES              , "<valid in a switch body>"     );
    }

}