sather.g

Java写的词法/语法分析器。可生成JAVA语言或者是C++的词法和语法分析器。并可产生语法分析树和对该树进行遍历

/*
 *  Sather 1.2 Grammar
 *
 *  Version 0.1  Mika Illouz   [e-mail]  
 *    Beware: full of mistakes, but its a start.  I'm particularly unsure
 *    about expression precendence, external class definition, and 
 *    closure create expression.  I started tagging various rules with
 *    imaginary tokens, but that job is far from over if the output of the
 *    parser is ever to be handed off to a tree walker.
 *
 *  This grammar is in the PUBLIC DOMAIN.
 */

options {
	language = "Sather";
}

class SATHER_PARSER extends Parser;
options {
	exportVocab=SATHER;                // Call its vocabulary "SATHER"
	codeGenMakeSwitchThreshold = 2;    // Some optimizations
	codeGenBitsetTestThreshold = 3;
	buildAST = true;
}

tokens {
	CLASS_DEFINITION_LIST;
	PARAMETER_DECLARATION_LIST;
        ABSTRACT_SIGNATURE_LIST;
        TYPE_SPECIFIER_LIST;
}

parse
	: class_definition_list
        ;


class_definition_list
	: ( class_definition ( SEMICOLON! ( class_definition )? )* )?
          { @class_definition_list := 
              @([CLASS_DEFINITION_LIST, "CLASS_DEFINITION_LIST"], 
                @class_definition_list); 
          }
	;

class_definition
	: abstract_class_definition 
	| concrete_class_definition
	| external_class_definition
	;

abstract_class_definition
	: "abstract"^ 
          "class"! 
          ABSTRACT_CLASS_NAME
	  ( LCURLY! parameter_declaration_list RCURLY! )?
	  ( subtyping_clause )?
          ( supertyping_clause )?
          "is"!
	  ( abstract_signature_list )?
          "end"!
	;

concrete_class_definition
	: ( "immutable" | "partial" )?
	  "class"^
	  IDENTIFIER
	  ( LCURLY parameter_declaration_list RCURLY )?
	  ( subtyping_clause )?
          "is"
	  ( class_element_list )?
	  "end"
	;
 	  
external_class_definition
	: "external" ( IDENTIFIER )? 
          "class" 
          IDENTIFIER
	  ( LCURLY parameter_declaration_list RCURLY )?
	  ( subtyping_clause )?
          "is"
	  ( external_class_element_list )?
	  "end"
	;

class_element_list
	: class_element ( SEMICOLON! ( class_element )? )*
	;


class_element
	: "private" unmodified_definition
	| "readonly" ( shared_definition | attr_definition )
	| unmodified_definition
	| stub_
	;

unmodified_definition
	: const_definition 
	| shared_definition
	| attr_definition
	| routine_definition
	| iter_definition
	| include_clause
	;

const_definition
	: "const" 
	  IDENTIFIER
	  ( ( COLON type_specifier ASSIGN expression )
          | ( ( ASSIGN expression )? ( COMMA identifier_list )? )
          )
	;

shared_definition
	: "shared"
	  ( IDENTIFIER 
            ( COLON type_specifier ( ASSIGN expression )?
            | ( COMMA! IDENTIFIER )+ COLON type_specifier 
            )
          )
	;

attr_definition
	: "attr" identifier_list COLON type_specifier 
	;

routine_definition
	: IDENTIFIER
	  ( LPAREN! routine_argument_list RPAREN! )?
	  ( COLON type_specifier )?
	  ( "pre" expression )?
	  ( "post" expression )?
	  "is" ( statement_list | builtin_statement ) "end"  // not optional: typo on page 31 of spec?
	;

iter_definition
	: ITER_NAME
	  ( LPAREN! iter_argument_list RPAREN! )?
	  ( COLON type_specifier )?
	  ( "pre" expression )?
	  ( "post" expression )?
	  "is" ( statement_list | builtin_statement ) "end"
	;

include_clause
	: "include" type_specifier ( feature_modifier_list )?
	;

feature_modifier_list
	: feature_modifier ( COMMA! feature_modifier )*
	;

feature_modifier
	: IDENTIFIER RIGHT_ARROW ( ( "private" | "readonly" )? IDENTIFIER )?
	| ITER_NAME  RIGHT_ARROW ( ( "private" | "readonly" )? ITER_NAME  )?
	;

stub_
	: "stub" abstract_signature // typo on page 34 of spec?
	;

statement_list
	: ( statement )? ( SEMICOLON! ( statement )? )* 
	;

external_class_element
	: "private" unmodified_definition
	| "readonly" ( shared_definition | attr_definition )
        // getting lazy here... should really left-factor, but that would
        // be very messy
        | ( unmodified_definition )=> unmodified_definition 
        | abstract_signature
        ;

external_class_element_list
	: external_class_element ( SEMICOLON! ( external_class_element )? )*
        ;

builtin_statement
	: "builtin" IDENTIFIER ( SEMICOLON! )?
	;

statement
	: declaration_or_expression_statement
	| if_statement
	| return_statement
	| case_statement
	| typecase_statement
	| loop_statement
	| yield_statement
	| quit_statement
	| protect_statement
	| raise_statement
	| assert_statement
	;

declaration_or_expression_statement
	: ( IDENTIFIER ( COLON | COMMA | DBL_COLON_ASSIGN ) )=> declaration_statement
	| expression
	;

declaration_statement
        : IDENTIFIER 
          ( COLON type_specifier ( ASSIGN expression )? 
          | DBL_COLON_ASSIGN expression
          | ( COMMA! IDENTIFIER )+ COLON type_specifier 
          )
	;

assert_statement
	: "assert" expression
	;

if_statement
	: "if" expression "then" statement_list 
	  ( "elsif" expression "then" statement_list )*  
	  ( "else" statement_list )?
          "end"
	;

return_statement
	: "return" ( expression )?
	;

case_statement
	: "case" expression 
	  ( "when" expression ( COMMA! expression )* "then" statement_list )+
	  ( "else" statement_list )?
	  "end"
	;

typecase_statement
	: "typecase" IDENTIFIER
	  ( "when" type_specifier "then" statement_list )+
	  ( "else" statement_list )?
	  "end"
	;

loop_statement
	: "loop" statement_list "end"
	;

yield_statement
	: "yield" ( expression )?
	;

quit_statement
	: "quit" 
	;

protect_statement
	: "protect" statement_list
	  ( "when" type_specifier "then" statement_list )*
	  ( "else" statement_list )?
	  "end"
	;

raise_statement
	: "raise" expression
	;

// going out on a limb, here.
closure_create_expression
	: "bind"
	  LPAREN
	  closure_class_call_expression
 	  RPAREN
	;

expression_list
	: expression ( COMMA! expression )*
	;

// expressions
// Note that most of these expressions follow the pattern
//   this_level_expression :
//       next_higher_precedence_expression
//           (OPERATOR next_higher_precedence_expression)*
// which is a standard recursive definition for a parsing an expression.

expression
	: assignment_expression
	;

assignment_expression
	: logical_expression ( ASSIGN logical_expression )?
	;

logical_expression
	: relational_expression ( ( "and" | "or" ) relational_expression )*
	;

relational_expression
	: add_sub_expression
	  ( 
	    ( LESS_THAN 
            | LESS_THAN_EQUAL 
	    | EQUAL 
	    | NOT_EQUAL 
	    | GREATER_THAN_EQUAL 
	    | GREATER_THAN
            )
	    add_sub_expression
	  )*
	;

add_sub_expression
	: mult_div_mod_expression ( ( PLUS | MINUS ) mult_div_mod_expression )*
	;

mult_div_mod_expression
	: unary_expression ( ( STAR | SLASH | PERCENT ) unary_expression )*
	;

unary_expression
	: ( NOT | MINUS )? raise_expression
	;

raise_expression
	: class_call_expression ( CARET class_call_expression )*
	;

class_call_expression
	: ( type_specifier DBL_COLON )=>
            type_specifier DBL_COLON deref_expression 
	| deref_expression
	;

deref_expression
	: call_expression ( DOT call_expression )*
	;

call_expression
	: primary_expression 
	  ( LPAREN call_argument_list RPAREN ( LSQUARE expression_list RSQUARE )*
	  | ( LSQUARE call_argument_list RSQUARE )+
	  )?
	| "new" ( LPAREN expression RPAREN )?
	| "void" ( LPAREN expression RPAREN )?
	| HASH ( type_specifier )? ( LPAREN call_argument_list RPAREN )?
	| LSQUARE expression_list RSQUARE // aget() does not accept modes, right?
	;

call_argument_list
	: ( ( iter_mode )? expression ) ( COMMA! ( iter_mode )? expression )*
	;

primary_expression
	: LPAREN expression RPAREN
	| IDENTIFIER
	| ITER_NAME
	| bool_literal_expression
	| CHAR_LITERAL
	| ( STRING_LITERAL )+
	| INT_LITERAL
	| FLT_LITERAL
	| array_expression
	| self_expression
	| while_expression
	| until_expression
	| break_expression
	| except_expression
	| initial_expression
	| result_expression
	| closure_create_expression
	;

// variants for use in closure definitions, where we augment the 
// notion of expression to include an UNDERSCORE.  Used only in
// closure_create_expression
closure_class_call_expression
	: ( type_specifier DBL_COLON )=>
            type_specifier DBL_COLON closure_deref_expression 
	| closure_deref_expression
	;

closure_deref_expression
	: closure_call_expression ( DOT closure_call_expression )?
	;

closure_call_expression
	: ( primary_expression | UNDERSCORE )
	  ( LPAREN closure_argument_list RPAREN ( LSQUARE closure_expression_list RSQUARE )*
	  | ( LSQUARE closure_argument_list RSQUARE )+
	  )?
	| LSQUARE closure_expression_list RSQUARE
	;

closure_argument_list
	: ( ( iter_mode )? closure_expression ) ( COMMA! ( ( iter_mode )? closure_expression ) )*
	;

closure_expression_list
	: closure_expression ( COMMA! closure_expression )*
	;