| header { | |
| package org.apache.axis2.corba.idl; | |
| import java.io.*; | |
| import java.util.Vector; | |
| import java.util.Hashtable; | |
| } | |
| /** | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| */ | |
| /** | |
| * This is a complete parser for the IDL language as defined | |
| * by the CORBA 3.0.2 specification. It will allow those who | |
| * need an IDL parser to get up-and-running very quickly. | |
| * Though IDL's syntax is very similar to C++, it is also | |
| * much simpler, due in large part to the fact that it is | |
| * a declarative-only language. | |
| * | |
| * Some things that are not included are: Symbol table construction | |
| * (it is not necessary for parsing, btw) and preprocessing (for | |
| * IDL compiler #pragma directives). You can use just about any | |
| * C or C++ preprocessor, but there is an interesting semantic | |
| * issue if you are going to generate code: In C, #include is | |
| * a literal include, in IDL, #include is more like Java's import: | |
| * It adds definitions to the scope of the parse, but included | |
| * definitions are not generated. | |
| * | |
| * Jim Coker, jcoker@magelang.com | |
| * Gary Duzan, gduzan@bbn.com | |
| */ | |
| class IDLParser extends Parser; | |
| options { | |
| exportVocab=IDL; | |
| buildAST=true; | |
| k=4; | |
| } | |
| specification | |
| : (import_dcl)* (definition)+ | |
| ; | |
| definition | |
| : ( type_dcl SEMI! | |
| | const_dcl SEMI! | |
| | except_dcl SEMI! | |
| | (("abstract" | "local")? "interface") => interf SEMI! | |
| | module SEMI! | |
| | (("abstract" | "custom")? "valuetype") => value SEMI! | |
| | type_id_dcl SEMI! | |
| | type_prefix_dcl SEMI! | |
| | (("abstract" | "custom")? "eventtype") => event SEMI! | |
| | component SEMI! | |
| | home_dcl SEMI! | |
| ) | |
| ; | |
| module | |
| : "module"^ | |
| identifier | |
| LCURLY! d:definition_list RCURLY! | |
| ; | |
| definition_list | |
| : (definition)+ | |
| ; | |
| interf | |
| : ( "abstract" | "local" )? | |
| "interface"^ | |
| identifier | |
| // interface_name_dcl | |
| ( interface_dcl | |
| | // forward_dcl | |
| ) | |
| ; | |
| interface_dcl | |
| : interface_header | |
| LCURLY! interface_body RCURLY! | |
| ; | |
| // forward_dcl | |
| // : // interface_name_dcl | |
| // ; | |
| // interface_name_dcl | |
| // : ( "abstract" | "local" )? | |
| // "interface"^ | |
| // identifier | |
| // ; | |
| interface_header | |
| : // interface_name_dcl | |
| ( interface_inheritance_spec )? | |
| ; | |
| interface_body | |
| : ( export )* | |
| ; | |
| export | |
| : ( type_dcl SEMI! | |
| | const_dcl SEMI! | |
| | except_dcl SEMI! | |
| | attr_dcl SEMI! | |
| | op_dcl SEMI! | |
| | type_id_dcl SEMI! | |
| | type_prefix_dcl SEMI! | |
| | PREPROC_DIRECTIVE | |
| ) | |
| ; | |
| interface_inheritance_spec | |
| : COLON^ scoped_name_list | |
| ; | |
| interface_name | |
| : scoped_name | |
| ; | |
| scoped_name_list | |
| : scoped_name (COMMA! scoped_name)* | |
| ; | |
| scoped_name | |
| : ( SCOPEOP^ )? IDENT^ /* identifier */ (SCOPEOP! identifier)* | |
| ; | |
| /*value | |
| : ( value_dcl) | |
| ;*/ | |
| value | |
| : ( value_dcl | |
| | value_abs_dcl | |
| | value_box_dcl | |
| | value_custom_dcl | |
| | value_forward_dcl | |
| ) | |
| ; | |
| value_forward_dcl | |
| : "valuetype"^ | |
| identifier | |
| ; | |
| value_box_dcl | |
| : "valuetype"^ | |
| identifier | |
| type_spec | |
| ; | |
| value_abs_dcl | |
| : "abstract" | |
| "valuetype"^ | |
| identifier | |
| ( value_abs_full_dcl | |
| | // value_abs_forward_dcl | |
| ) | |
| ; | |
| value_abs_full_dcl | |
| : value_inheritance_spec | |
| LCURLY! ( export )* RCURLY! | |
| ; | |
| // value_abs_forward_dcl | |
| // : | |
| // ; | |
| value_dcl | |
| : "valuetype"^ | |
| identifier | |
| value_inheritance_spec | |
| LCURLY! (value_element)* RCURLY! | |
| ; | |
| /*value_dcl | |
| : value_header | |
| LCURLY! ( value_element )* RCURLY! | |
| ; | |
| */ | |
| value_custom_dcl | |
| : "custom"^ | |
| value_dcl | |
| ; | |
| /*value_header | |
| : "valuetype"^ | |
| identifier | |
| value_inheritance_spec | |
| ; | |
| */ | |
| value_inheritance_spec | |
| /* | |
| : ( COLON ( "truncatable" )? | |
| value_name ( COMMA! value_name )* | |
| )? | |
| ( "supports" interface_name ( COMMA! interface_name )* )? | |
| ; | |
| */ | |
| : ( value_value_inheritance_spec )? | |
| ( value_interface_inheritance_spec )? | |
| ; | |
| value_value_inheritance_spec | |
| : COLON^ ( "truncatable" )? | |
| value_name ( COMMA! value_name )* | |
| ; | |
| value_interface_inheritance_spec | |
| : "supports"^ interface_name ( COMMA! interface_name )* | |
| ; | |
| value_name | |
| : scoped_name | |
| ; | |
| value_element | |
| : ( export | |
| | state_member | |
| | init_dcl | |
| ) | |
| ; | |
| state_member | |
| : ( "public" | "private" ) | |
| type_spec declarators SEMI! | |
| ; | |
| init_dcl | |
| : "factory"^ identifier | |
| LPAREN! (init_param_decls)? RPAREN! | |
| (raises_expr)? | |
| SEMI! | |
| ; | |
| init_param_decls | |
| : init_param_decl ( COMMA! init_param_decl )* | |
| ; | |
| init_param_decl | |
| : init_param_attribute | |
| param_type_spec | |
| simple_declarator | |
| ; | |
| init_param_attribute | |
| : "in" | |
| ; | |
| const_dcl | |
| : "const"^ const_type identifier ASSIGN! const_exp | |
| ; | |
| const_type | |
| : (integer_type) => integer_type | |
| | char_type | |
| | wide_char_type | |
| | boolean_type | |
| | floating_pt_type | |
| | string_type | |
| | wide_string_type | |
| | fixed_pt_const_type | |
| | scoped_name | |
| | octet_type | |
| ; | |
| /* EXPRESSIONS */ | |
| const_exp | |
| : or_expr | |
| ; | |
| or_expr | |
| : xor_expr | |
| ( OR^ // or_op | |
| xor_expr | |
| )* | |
| ; | |
| // or_op | |
| // : OR | |
| // ; | |
| xor_expr | |
| : and_expr | |
| ( XOR^ // xor_op | |
| and_expr | |
| )* | |
| ; | |
| // xor_op | |
| // : XOR | |
| // ; | |
| and_expr | |
| : shift_expr | |
| ( AND^ // and_op | |
| shift_expr | |
| )* | |
| ; | |
| // and_op | |
| // : AND | |
| // ; | |
| shift_expr | |
| : add_expr | |
| ( ( LSHIFT^ | |
| | RSHIFT^ | |
| ) // shift_op | |
| add_expr | |
| )* | |
| ; | |
| // shift_op | |
| // : LSHIFT | |
| // | RSHIFT | |
| // ; | |
| add_expr | |
| : mult_expr | |
| ( ( PLUS^ | |
| | MINUS^ | |
| ) // add_op | |
| mult_expr | |
| )* | |
| ; | |
| // add_op | |
| // : PLUS | |
| // | MINUS | |
| // ; | |
| mult_expr | |
| : unary_expr | |
| ( ( STAR^ | |
| | DIV^ | |
| | MOD^ | |
| ) // mult_op | |
| unary_expr | |
| )* | |
| ; | |
| // mult_op | |
| // : STAR | |
| // | DIV | |
| // | MOD | |
| // ; | |
| unary_expr | |
| : ( MINUS^ | |
| | PLUS^ | |
| | TILDE^ | |
| ) // unary_operator | |
| primary_expr | |
| | primary_expr | |
| ; | |
| // unary_operator | |
| // : MINUS | |
| // | PLUS | |
| // | TILDE | |
| // ; | |
| // Node of type TPrimaryExp serves to avoid inf. recursion on tree parse | |
| primary_expr | |
| : scoped_name | |
| | literal | |
| | LPAREN^ const_exp RPAREN | |
| ; | |
| literal | |
| : integer_literal | |
| | string_literal | |
| | wide_string_literal | |
| | character_literal | |
| | wide_character_literal | |
| | fixed_pt_literal | |
| | floating_pt_literal | |
| | boolean_literal | |
| ; | |
| boolean_literal | |
| : "TRUE" | |
| | "FALSE" | |
| ; | |
| positive_int_const | |
| : const_exp | |
| ; | |
| type_dcl | |
| : "typedef"^ type_declarator | |
| | (struct_type) => struct_type | |
| | (union_type) => union_type | |
| | enum_type | |
| | "native"^ simple_declarator | |
| | constr_forward_decl | |
| ; | |
| type_declarator | |
| : type_spec declarators | |
| ; | |
| type_spec | |
| : simple_type_spec | |
| | constr_type_spec | |
| ; | |
| simple_type_spec | |
| : base_type_spec | |
| | template_type_spec | |
| | scoped_name | |
| ; | |
| base_type_spec | |
| : (floating_pt_type) => floating_pt_type | |
| | integer_type | |
| | char_type | |
| | wide_char_type | |
| | boolean_type | |
| | octet_type | |
| | any_type | |
| | object_type | |
| | value_base_type | |
| ; | |
| template_type_spec | |
| : sequence_type | |
| | string_type | |
| | wide_string_type | |
| | fixed_pt_type | |
| ; | |
| constr_type_spec | |
| : struct_type | |
| | union_type | |
| | enum_type | |
| ; | |
| declarators | |
| : declarator (COMMA! declarator)* | |
| ; | |
| declarator | |
| : simple_declarator | |
| | complex_declarator | |
| ; | |
| simple_declarator | |
| : identifier | |
| ; | |
| complex_declarator | |
| : array_declarator | |
| ; | |
| floating_pt_type | |
| : "float" | |
| | "double" | |
| | "long"^ "double" | |
| ; | |
| integer_type | |
| : signed_int | |
| | unsigned_int | |
| ; | |
| signed_int | |
| : signed_short_int | |
| | signed_long_int | |
| | signed_longlong_int | |
| ; | |
| signed_short_int | |
| : "short" | |
| ; | |
| signed_long_int | |
| : "long" | |
| ; | |
| signed_longlong_int | |
| : "long" "long" | |
| ; | |
| unsigned_int | |
| : unsigned_short_int | |
| | unsigned_long_int | |
| | unsigned_longlong_int | |
| ; | |
| unsigned_short_int | |
| : "unsigned" "short" | |
| ; | |
| unsigned_long_int | |
| : "unsigned" "long" | |
| ; | |
| unsigned_longlong_int | |
| : "unsigned" "long" "long" | |
| ; | |
| char_type | |
| : "char" | |
| ; | |
| wide_char_type | |
| : "wchar" | |
| ; | |
| boolean_type | |
| : "boolean" | |
| ; | |
| octet_type | |
| : "octet" | |
| ; | |
| any_type | |
| : "any" | |
| ; | |
| object_type | |
| : "Object" | |
| ; | |
| struct_type | |
| : "struct"^ | |
| identifier | |
| LCURLY! member_list RCURLY! | |
| ; | |
| member_list | |
| : (member)+ | |
| ; | |
| member | |
| : type_spec declarators SEMI! | |
| ; | |
| union_type | |
| : "union"^ | |
| identifier | |
| "switch"! LPAREN! switch_type_spec RPAREN! | |
| LCURLY! switch_body RCURLY! | |
| ; | |
| switch_type_spec | |
| : integer_type | |
| | char_type | |
| | boolean_type | |
| | enum_type | |
| | scoped_name | |
| ; | |
| switch_body | |
| : case_stmt_list | |
| ; | |
| case_stmt_list | |
| : (case_stmt)+ | |
| ; | |
| case_stmt | |
| : // case_label_list | |
| ( "case"^ const_exp COLON! | |
| | "default"^ COLON! | |
| )+ | |
| element_spec SEMI! | |
| ; | |
| // case_label_list | |
| // : (case_label)+ | |
| // ; | |
| // case_label | |
| // : "case"^ const_exp COLON! | |
| // | "default"^ COLON! | |
| // ; | |
| element_spec | |
| : type_spec declarator | |
| ; | |
| enum_type | |
| : "enum"^ identifier LCURLY! enumerator_list RCURLY! | |
| ; | |
| enumerator_list | |
| : enumerator (COMMA! enumerator)* | |
| ; | |
| enumerator | |
| : identifier | |
| ; | |
| sequence_type | |
| : "sequence"^ | |
| LT! simple_type_spec opt_pos_int GT! | |
| ; | |
| opt_pos_int | |
| : (COMMA! positive_int_const)? | |
| ; | |
| string_type | |
| : "string"^ (LT! positive_int_const GT!)? | |
| ; | |
| wide_string_type | |
| : "wstring"^ (LT! positive_int_const GT!)? | |
| ; | |
| array_declarator | |
| : IDENT^ // identifier | |
| (fixed_array_size)+ | |
| ; | |
| fixed_array_size | |
| : LBRACK! positive_int_const RBRACK! | |
| ; | |
| attr_dcl | |
| : readonly_attr_spec | |
| | attr_spec | |
| ; | |
| except_dcl | |
| : "exception"^ | |
| identifier | |
| LCURLY! opt_member_list RCURLY! | |
| ; | |
| opt_member_list | |
| : (member)* | |
| ; | |
| op_dcl | |
| : (op_attribute)? | |
| op_type_spec | |
| IDENT^ // identifier | |
| parameter_dcls | |
| (raises_expr)? | |
| (context_expr)? | |
| ; | |
| op_attribute | |
| : "oneway" | |
| ; | |
| op_type_spec | |
| : param_type_spec | |
| | "void" | |
| ; | |
| parameter_dcls | |
| : LPAREN! (param_dcl_list)? RPAREN! | |
| ; | |
| param_dcl_list | |
| : param_dcl (COMMA! param_dcl)* | |
| ; | |
| param_dcl | |
| : ("in"^ | "out"^ | "inout"^) // param_attribute | |
| param_type_spec simple_declarator | |
| ; | |
| // param_attribute | |
| // : "in" | |
| // | "out" | |
| // | "inout" | |
| // ; | |
| raises_expr | |
| : "raises"^ LPAREN! scoped_name_list RPAREN! | |
| ; | |
| context_expr | |
| : "context"^ LPAREN! string_literal_list RPAREN! | |
| ; | |
| string_literal_list | |
| : string_literal (COMMA! string_literal)* | |
| ; | |
| param_type_spec | |
| : base_type_spec | |
| | string_type | |
| | wide_string_type | |
| | scoped_name | |
| ; | |
| fixed_pt_type | |
| : "fixed"^ LT! positive_int_const COMMA! positive_int_const GT! | |
| ; | |
| fixed_pt_const_type | |
| : "fixed" | |
| ; | |
| value_base_type | |
| : "ValueBase" | |
| ; | |
| constr_forward_decl | |
| : "struct"^ identifier | |
| | "union"^ identifier | |
| ; | |
| import_dcl | |
| : "import"^ imported_scope SEMI! | |
| ; | |
| imported_scope | |
| : scoped_name | |
| | string_literal | |
| ; | |
| type_id_dcl | |
| : "typeid"^ | |
| scoped_name | |
| string_literal | |
| ; | |
| type_prefix_dcl | |
| : "typeprefix"^ | |
| scoped_name | |
| string_literal | |
| ; | |
| readonly_attr_spec | |
| : "readonly" "attribute"^ | |
| param_type_spec | |
| readonly_attr_declarator | |
| ; | |
| readonly_attr_declarator | |
| : simple_declarator | |
| ( raises_expr | |
| | (COMMA! simple_declarator)* | |
| ) | |
| ; | |
| attr_spec | |
| : "attribute"^ param_type_spec attr_declarator | |
| ; | |
| attr_declarator | |
| : simple_declarator | |
| ( ("getraises" | "setraises") => attr_raises_expr | |
| | (COMMA! simple_declarator)* | |
| ) | |
| ; | |
| attr_raises_expr | |
| : (get_excep_expr)? | |
| (set_excep_expr)? | |
| ; | |
| get_excep_expr | |
| : "getraises"^ exception_list | |
| ; | |
| set_excep_expr | |
| : "setraises"^ exception_list | |
| ; | |
| exception_list | |
| : LPAREN! scoped_name (COMMA! scoped_name)* RPAREN! | |
| ; | |
| // Component Stuff | |
| component | |
| : "component"^ | |
| identifier | |
| (component_dcl)? | |
| ; | |
| component_dcl | |
| : (component_inheritance_spec)? | |
| (supported_interface_spec)? | |
| LCURLY! component_body RCURLY! | |
| ; | |
| supported_interface_spec | |
| : "supports"^ scoped_name ( COMMA! scoped_name )* | |
| ; | |
| component_inheritance_spec | |
| : COLON^ scoped_name | |
| ; | |
| component_body | |
| : (component_export)* | |
| ; | |
| component_export | |
| : ( provides_dcl SEMI! | |
| | uses_dcl SEMI! | |
| | emits_dcl SEMI! | |
| | publishes_dcl SEMI! | |
| | consumes_dcl SEMI! | |
| | attr_dcl SEMI! | |
| ) | |
| ; | |
| provides_dcl | |
| : "provides"^ interface_type identifier | |
| ; | |
| interface_type | |
| : ( scoped_name | |
| | "Object" | |
| ) | |
| ; | |
| uses_dcl | |
| : "uses"^ ("multiple")? interface_type identifier | |
| ; | |
| emits_dcl | |
| : "emits"^ scoped_name identifier | |
| ; | |
| publishes_dcl | |
| : "publishes"^ scoped_name identifier | |
| ; | |
| consumes_dcl | |
| : "consumes"^ scoped_name identifier | |
| ; | |
| home_dcl | |
| : home_header home_body | |
| ; | |
| home_header | |
| : "home"^ identifier | |
| (home_inheritance_spec)? | |
| (supported_interface_spec)? | |
| "manages"! scoped_name | |
| (primary_key_spec)? | |
| ; | |
| home_inheritance_spec | |
| : COLON^ scoped_name | |
| ; | |
| primary_key_spec | |
| : "primarykey"^ scoped_name | |
| ; | |
| home_body | |
| : LCURLY! (home_export)* RCURLY! | |
| ; | |
| home_export | |
| : ( export | |
| | factory_dcl SEMI! | |
| | finder_dcl SEMI! | |
| ) | |
| ; | |
| factory_dcl | |
| : "factory"^ identifier | |
| LPAREN! init_param_decls RPAREN! | |
| (raises_expr)? | |
| ; | |
| finder_dcl | |
| : "finder"^ identifier | |
| LPAREN! init_param_decls RPAREN! | |
| (raises_expr)? | |
| ; | |
| event | |
| : ( event_abs | |
| | event_custom | |
| | event_dcl | |
| ) | |
| ; | |
| event_header | |
| : "eventtype"^ | |
| identifier | |
| ; | |
| event_abs | |
| : "abstract"^ | |
| event_header | |
| (event_abs_dcl)? | |
| ; | |
| event_abs_dcl | |
| : value_inheritance_spec | |
| LCURLY! (export)* RCURLY! | |
| ; | |
| event_custom | |
| : "custom"^ | |
| event_header | |
| event_elem_dcl | |
| ; | |
| event_dcl | |
| : event_header | |
| ( event_elem_dcl | |
| | // event_forward_dcl | |
| ) | |
| ; | |
| event_elem_dcl | |
| : value_inheritance_spec | |
| LCURLY! (export)* RCURLY! | |
| ; | |
| // event_forward_dcl | |
| // : | |
| // ; | |
| /* literals */ | |
| integer_literal | |
| : INT | |
| | OCTAL | |
| | HEX | |
| ; | |
| string_literal | |
| : (STRING_LITERAL)+ | |
| ; | |
| wide_string_literal | |
| : (WIDE_STRING_LITERAL)+ | |
| ; | |
| character_literal | |
| : CHAR_LITERAL | |
| ; | |
| wide_character_literal | |
| : WIDE_CHAR_LITERAL | |
| ; | |
| fixed_pt_literal | |
| : FIXED | |
| ; | |
| floating_pt_literal | |
| : f:FLOAT | |
| ; | |
| identifier | |
| : IDENT | |
| ; | |
| /* IDL LEXICAL RULES */ | |
| class IDLLexer extends Lexer; | |
| options { | |
| exportVocab=IDL; | |
| charVocabulary='\u0000'..'\uFFFE'; | |
| k=4; | |
| } | |
| SEMI | |
| options { | |
| paraphrase = ";"; | |
| } | |
| : ';' | |
| ; | |
| QUESTION | |
| options { | |
| paraphrase = "?"; | |
| } | |
| : '?' | |
| ; | |
| LPAREN | |
| options { | |
| paraphrase = "("; | |
| } | |
| : '(' | |
| ; | |
| RPAREN | |
| options { | |
| paraphrase = ")"; | |
| } | |
| : ')' | |
| ; | |
| LBRACK | |
| options { | |
| paraphrase = "["; | |
| } | |
| : '[' | |
| ; | |
| RBRACK | |
| options { | |
| paraphrase = "]"; | |
| } | |
| : ']' | |
| ; | |
| LCURLY | |
| options { | |
| paraphrase = "{"; | |
| } | |
| : '{' | |
| ; | |
| RCURLY | |
| options { | |
| paraphrase = "}"; | |
| } | |
| : '}' | |
| ; | |
| OR | |
| options { | |
| paraphrase = "|"; | |
| } | |
| : '|' | |
| ; | |
| XOR | |
| options { | |
| paraphrase = "^"; | |
| } | |
| : '^' | |
| ; | |
| AND | |
| options { | |
| paraphrase = "&"; | |
| } | |
| : '&' | |
| ; | |
| COLON | |
| options { | |
| paraphrase = ":"; | |
| } | |
| : ':' | |
| ; | |
| COMMA | |
| options { | |
| paraphrase = ","; | |
| } | |
| : ',' | |
| ; | |
| DOT | |
| options { | |
| paraphrase = "."; | |
| } | |
| : '.' | |
| ; | |
| ASSIGN | |
| options { | |
| paraphrase = "="; | |
| } | |
| : '=' | |
| ; | |
| NOT | |
| options { | |
| paraphrase = "!"; | |
| } | |
| : '!' | |
| ; | |
| LT | |
| options { | |
| paraphrase = "<"; | |
| } | |
| : '<' | |
| ; | |
| LSHIFT | |
| options { | |
| paraphrase = "<<"; | |
| } | |
| : "<<" | |
| ; | |
| GT | |
| options { | |
| paraphrase = ">"; | |
| } | |
| : '>' | |
| ; | |
| RSHIFT | |
| options { | |
| paraphrase = ">>"; | |
| } | |
| : ">>" | |
| ; | |
| DIV | |
| options { | |
| paraphrase = "/"; | |
| } | |
| : '/' | |
| ; | |
| PLUS | |
| options { | |
| paraphrase = "+"; | |
| } | |
| : '+' | |
| ; | |
| MINUS | |
| options { | |
| paraphrase = "-"; | |
| } | |
| : '-' | |
| ; | |
| TILDE | |
| options { | |
| paraphrase = "~"; | |
| } | |
| : '~' | |
| ; | |
| STAR | |
| options { | |
| paraphrase = "*"; | |
| } | |
| : '*' | |
| ; | |
| MOD | |
| options { | |
| paraphrase = "%"; | |
| } | |
| : '%' | |
| ; | |
| SCOPEOP | |
| options { | |
| paraphrase = "::"; | |
| } | |
| : "::" | |
| ; | |
| WS | |
| options { | |
| paraphrase = "white space"; | |
| } | |
| : (' ' | |
| | '\t' | |
| | '\n' { newline(); } | |
| | '\r') | |
| { $setType(Token.SKIP); } | |
| ; | |
| PREPROC_DIRECTIVE | |
| options { | |
| paraphrase = "a preprocessor directive"; | |
| } | |
| : | |
| '#'! | |
| (~'\n')* '\n'! | |
| ; | |
| SL_COMMENT | |
| options { | |
| paraphrase = "a comment"; | |
| } | |
| : | |
| "//"! | |
| (~'\n')* '\n' | |
| { $setType(Token.SKIP); newline(); } | |
| ; | |
| ML_COMMENT | |
| options { | |
| paraphrase = "a comment"; | |
| } | |
| : | |
| "/*"! | |
| ( | |
| '\n' { newline(); } | |
| | ('*')+ | |
| ( '\n' { newline(); } | |
| | ~('*' | '/' | '\n') | |
| ) | |
| | ~('*' | '\n') | |
| )* | |
| "*/"! | |
| { $setType(Token.SKIP); } | |
| ; | |
| CHAR_LITERAL | |
| options { | |
| paraphrase = "a character literal"; | |
| } | |
| : | |
| '\''! | |
| ( ESC | ~'\'' ) | |
| '\''! | |
| ; | |
| WIDE_CHAR_LITERAL | |
| options { | |
| paraphrase = "a wide character literal"; | |
| } | |
| : 'L'! CHAR_LITERAL | |
| ; | |
| STRING_LITERAL | |
| options { | |
| paraphrase = "a string literal"; | |
| } | |
| : | |
| '"'! | |
| (ESC|~'"')* | |
| '"'! | |
| ; | |
| WIDE_STRING_LITERAL | |
| options { | |
| paraphrase = "a wide string literal"; | |
| } | |
| : | |
| 'L'! STRING_LITERAL | |
| ; | |
| protected | |
| ESC | |
| options { | |
| paraphrase = "an escape sequence"; | |
| } | |
| : '\\'! | |
| ( 'n' {$setText("\n");} | |
| | 't' {$setText("\t");} | |
| | 'v' {$setText("\013");} | |
| | 'b' {$setText("\b");} | |
| | 'r' {$setText("\r");} | |
| | 'f' {$setText("\r");} | |
| | 'a' {$setText("\007");} | |
| | '\\' {$setText("\\");} | |
| | '?' {$setText("?");} | |
| | '\'' {$setText("'");} | |
| | '"' {$setText("\"");} | |
| | OCTDIGIT | |
| (options {greedy=true;}:OCTDIGIT | |
| (options {greedy=true;}:OCTDIGIT)? | |
| )? | |
| {char realc = (char) Integer.valueOf($getText, 8).intValue(); $setText(realc);} | |
| | 'x'! HEXDIGIT | |
| (options {greedy=true;}:HEXDIGIT)? | |
| {char realc = (char) Integer.valueOf($getText, 16).intValue(); $setText(realc);} | |
| | 'u'! | |
| HEXDIGIT | |
| (options {greedy=true;}:HEXDIGIT | |
| (options {greedy=true;}:HEXDIGIT | |
| (options {greedy=true;}:HEXDIGIT)? | |
| )? | |
| )? | |
| {char realc = (char) Integer.valueOf($getText, 16).intValue(); $setText(realc);} | |
| ) | |
| ; | |
| protected | |
| VOCAB | |
| options { | |
| paraphrase = "an escaped character value"; | |
| } | |
| : '\3'..'\377' | |
| ; | |
| protected | |
| DIGIT | |
| options { | |
| paraphrase = "a digit"; | |
| } | |
| : '0'..'9' | |
| ; | |
| protected | |
| NONZERODIGIT | |
| options { | |
| paraphrase = "a non-zero digit"; | |
| } | |
| : '1'..'9' | |
| ; | |
| protected | |
| OCTDIGIT | |
| options { | |
| paraphrase = "an octal digit"; | |
| } | |
| : '0'..'7' | |
| ; | |
| protected | |
| HEXDIGIT | |
| options { | |
| paraphrase = "a hexadecimal digit"; | |
| } | |
| : ('0'..'9' | 'a'..'f' | 'A'..'F') | |
| ; | |
| HEX | |
| options { | |
| paraphrase = "a hexadecimal value value"; | |
| } | |
| : ("0x" | "0X") (HEXDIGIT)+ | |
| ; | |
| INT | |
| options { | |
| paraphrase = "an integer value"; | |
| } | |
| : NONZERODIGIT (DIGIT)* // base-10 | |
| ( '.' (DIGIT)* | |
| ( (('e' | 'E') ('+' | '-')? (DIGIT)+) {$setType(FLOAT);} | |
| | ('d' | 'D')! {$setType(FIXED);} | |
| | {$setType(FLOAT);} | |
| ) | |
| | ('e' | 'E') ('+' | '-')? (DIGIT)+ {$setType(FLOAT);} | |
| | ('d' | 'D')! {$setType(FIXED);} | |
| )? | |
| ; | |
| OCTAL | |
| options { | |
| paraphrase = "an octal value"; | |
| } | |
| : '0' | |
| ( (DIGIT)+ | |
| | FLOAT {$setType(FLOAT);} | |
| | ('d' | 'D')! {$setType(FIXED);} | |
| | {$setType(INT);} | |
| ) | |
| ; | |
| FLOAT | |
| options { | |
| paraphrase = "a floating point value"; | |
| } | |
| : '.' (DIGIT)+ | |
| ( ('e' | 'E') ('+' | '-')? (DIGIT)+ | |
| | ('d' | 'D')! {$setType(FIXED);} | |
| )? | |
| ; | |
| IDENT | |
| options { | |
| paraphrase = "an identifer"; | |
| testLiterals = true; | |
| } | |
| : ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')* | |
| ; | |
| ESCAPED_IDENT | |
| options { | |
| paraphrase = "an escaped identifer"; | |
| testLiterals = false; // redundant, but explicit is good. | |
| } | |
| // NOTE: Adding a ! to the '_' doesn't seem to work, | |
| // so we adjust _begin manually. | |
| : '_' ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')* | |
| {_begin++;$setType(IDENT);} | |
| ; | |