header
{
  package nl.tue.win.riaca.gap.parser;

  import antlr.collections.*;
}

class GapOMParser extends Parser;

options
{
	k = 2;
        codeGenMakeSwitchThreshold = 3;
        codeGenBitsetTestThreshold = 4;
        buildAST=true;
        ASTLabelType = "antlr.CommonAST"; // change default of "AST"
}

tokens
{
	AST_TOP;		/* imaginary token */
	AST_LIST;		/* imaginary token */
	AST_FUNCTION;		/* imaginary token */

	UNARY_MINUS;		/* helper token to match unary minus. */
	UNARY_PLUS;		/* helper token to match unary plus.  */
}

expr : assignExpr SEMI!
       {
		#expr = #([AST_TOP, "AST_TOP"], expr);
       }
     ;

assignExpr
        :       
		equalityExpression
                (
                        ASSIGN^
                        assignExpr 
                )?
        ;


/**
 * Matches equality expressions. <p>
 *
 * @since 1.0
 */

equalityExpression
	: relationalExpression ( ( EQ^ | NEQ^ ) relationalExpression )*
	;


/**
 * Matches relational expressions. <p>
 *
 * @since 1.0
 */

relationalExpression
	: additiveExpression ( ( LT^ | GT^ | LE^ | GE^ ) additiveExpression )*
	;


/**
 * Matches additive expressions. <p>
 *
 * @since 1.0
 */

additiveExpression
	: multiplicativeExpression 
   	  ( ( PLUS^ | MINUS^ ) multiplicativeExpression )*
        ;


/**
 * Matches multiplicative expressions. <p>
 *
 * @since 1.0
 */
 
multiplicativeExpression 
	: powerExpression ( ( STAR^ | DIV^ ) powerExpression )*
	;


/**
 * Matches power expressions. <p>
 *
 * @since 1.0
 */

powerExpression
	: unaryExpression ( POWER^  unaryExpression )*
	;

/**
 * Matches the unary expressions. <p>
 *
 * @since 1.0
 */

unaryExpression
	: MINUS^ { #MINUS.setType( UNARY_MINUS ); } unaryExpression
	| PLUS^  { #PLUS.setType( UNARY_PLUS );   } unaryExpression
	| unaryExpressionRest
	;

/**
 * Matches the rest of the unary expressions. <p>
 *
 * @since 1.0
 */

unaryExpressionRest
	: postFixExpression
	;


/**
 * Matches a postfix expression, either
 * function call or an atom. <p>
 *
 * @since 1.0
 */

postFixExpression :   ( id:ID LPAREN )=>
                /*
                 * Matches function call syntax like "id( arg,arg )" 
                 */
		id2:ID^ ( parenArgs )?
		{
			#postFixExpression = 
			  #([AST_FUNCTION, "AST_FUNCTION"], postFixExpression);
		}
            |   atom
        ;

parenArgs
        :
      LPAREN!
      (
         assignExpr
         (
            COMMA!
                assignExpr
         )*
      )?
      RPAREN!
        ;

atom
        :       ID
        |       INT
        |       CHAR_LITERAL 
        |       STRING_LITERAL
        |       LPAREN! assignExpr RPAREN!
	|	LBRACK! ( additiveExpression 
		( COMMA! additiveExpression )* )? RBRACK!
	{
		#atom = #([AST_LIST, "AST_LIST"], #atom);
	}
        ;


/**
 * The Gap Lexer. <p>
 *
 * It reads in the input that is said to be GAP input. It tries
 * to read the tokens that valid GAP input should have. If it
 * succeeds it generates a sequence of tokens, which in turn can
 * be read by the Gap parser. <p>
 *
 * @author Manfred Riem (mriem@win.tue.nl).
 * @version 1.0
 */

class GapOMLexer 
      extends Lexer;

options 
{
	k = 2;
}

/**
 * Reads whitespace and throws it away. <p>
 *
 * @since 1.0
 */

WS      :       (' '
        |       '\t'
        |       '\n'
        |       '\r')
                { _ttype = Token.SKIP; }
        ;


/**
 * Reads the last semi-colon. <p>
 *
 * @since 1.0 
 */

SEMI		:	';' ;


/**
 * Reads the left parenthesis. <p>
 *
 * @since 1.0
 */

LPAREN		:	'(' ;


/**
 * Reads the right parenthesis. <p>
 *
 * @since 1.0
 */

RPAREN		:	')' ;


/**
 * Reads the left bracket. <p>
 *
 * @since 1.0
 */

LBRACK		:	'[' ;


/**
 * Reads the right bracket. <p>
 *
 * @since 1.0
 */

RBRACK		:	']' ;


/**
 * Reads the plus operator. <p>
 *
 * @since 1.0
 */

PLUS : '+';


/**
 * Reads the minus operator. <p>
 *
 * @since 1.0
 */

MINUS : '-';


/**
 * Reads the star operator. <p>
 *
 * @since 1.0
 */

STAR :	'*';


/**
 * Reads the divide operator. <p>
 *
 * @since 1.0
 */

DIV : '/';


/*
 * Reads the power operator. <p>
 *
 * @since 1.0
 */

POWER : '^';


/**
 * Reads the assignment operator. <p>
 *
 * @since 1.0
 */

ASSIGN		:	":=" ;


/**
 * Reads the comma operator. <p>
 *
 * @since 1.0
 */

COMMA		:	',' ;


/**
 * Reads the '<' operator. <p>
 *
 * @since 1.0
 */

LT : '<';


/**
 * Reads the '>' operator. <p>
 *
 * @since 1.0
 */

GT : '>';


/**
 * Reads the "<=" operator. <p>
 *
 * @since 1.0
 */

LE : "<=";


/**
 * Reads the ">=" operator. <p>
 *
 * @since 1.0
 */

GE : ">=";


/**
 * Reads the '=' operator. <p>
 *
 * @since 1.0
 */

EQ : '=';


/**
 * Reads the "<>" operator. <p>
 *
 * @since 1.0
 */

NEQ : "<>";


/**
 * Reads a simple character-literal. <p>
 *
 * @since 1.0
 */

CHAR_LITERAL	:	'\'' (ESC|~'\'') '\'' ;


/**
 * Reads a string literal. <p>
 *
 * @since 1.0
 */

STRING_LITERAL	:	'"' (ESC|~'"')* '"' ;


/**
 * Reads an escape-sequence. <p>
 *
 * @since 1.0
 */

protected
ESC     :       '\\'
                (       'n'
                |       'r'
                |       't'
                |       'b'
                |       'f'
                |       '"'
                |       '\''
                |       '\\'
                |       ('0'..'3')
                        (
                                options {
                                        warnWhenFollowAmbig = false;
                                }
                        :       ('0'..'9')
                                (
                                        options {
                                                warnWhenFollowAmbig = false;
                                        }
                                :       '0'..'9'
                                )?
                        )?
                |       ('4'..'7')
                        (
                                options {
                                        warnWhenFollowAmbig = false;
                                }
                        :       ('0'..'9')
                        )?
                )
        ;

protected
DIGIT
        :       '0'..'9'
        ;

INT 
        : (DIGIT)+
        ;

ID
options 
{
	testLiterals = true;
}
        :       ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*
        ;


/**
 * Tree walker. <p>
 *
 * Transform the AST-tree to an XML-encoded OpenMath object. It does
 * NOT use any of the libraries for OpenMath to make it possible to
 * run without any of those libraries. <p>
 *
 * @author Manfred Riem (mriem@win.tue.nl)
 * @version 1.0
 */

class GapOMTreeWalker extends TreeParser;

expr returns [String tResult]
{
	String tLeft,tRight;
	tResult  = "";
}
	: tTop : AST_TOP
	  {
		AST tChild = tTop.getFirstChild();
	
		tResult = "<OMOBJ>\n";

		if ( tChild != null )
		{
		   tResult += this.expr( tChild );
		}

		tResult += "</OMOBJ>\n";
	  }

	| #( tMinus:MINUS tLeft=expr tRight=expr )	
	  {
 		tResult = "<OMA>\n" +
			  "<OMS cd=\"arith1\" name=\"minus\"/>\n" + 
			  tLeft   +
			  tRight  +
			  "</OMA>\n" ;
	  }

	| tUnaryMinus:UNARY_MINUS
	  {
		AST tAST = tUnaryMinus.getFirstChild();

		if ( tAST.getType() == INT )
		   tResult = "<OMI>-" + tAST + "</OMI>\n";
		else
		   tResult = "<OMA>\n" +
		             "<OMS cd=\"arith1\" name=\"unary_minus\"/>\n" +
			     this.expr( tAST )  +
			     "</OMA>";
	  }

	| #( tPlus:PLUS tLeft=expr tRight=expr  )
	  {
 		tResult = "<OMA>\n" +
			  "<OMS cd=\"arith1\" name=\"plus\"/>\n" + 
			  tLeft   +
			  tRight  +
			  "</OMA>\n" ;
	  }

	| #( tLess:LT tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"relation1\" name=\"lt\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| #( tGreater:GT tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"relation1\" name=\"gt\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| #( tLessEqual:LE tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"relation1\" name=\"le\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| #( tGreaterEqual:GE tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"relation1\" name=\"ge\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| tUnaryPlus:UNARY_PLUS
	  {
		AST tAST = tUnaryPlus.getFirstChild();

		if ( tAST.getType() == INT )
		   tResult = "<OMI>" + tAST + "</OMI>\n";
		else
		   tResult = this.expr( tAST );
	  }

	| #( tStar:STAR tLeft=expr tRight=expr )	
	  { 
		tResult = "<OMA>\n" +
		  	  "<OMS cd=\"arith1\" name=\"times\"/>\n" +
			  tLeft   +
			  tRight  +
			  "</OMA>\n";
	  }

	| #( tDiv:DIV tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
		 	  "<OMS cd=\"arith1\" name=\"divide\"/>\n" +
			  tLeft   +
			  tRight  +
			  "</OMA>\n";
	  }

	| #( tPower:POWER tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"arith1\" name=\"power\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| #( tEqual:EQ tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"relation1\" name=\"eq\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| #( tNotEqual:NEQ tLeft=expr tRight=expr )
	  {
		tResult = "<OMA>\n" +
			  "<OMS cd=\"relation1\" name=\"neq\"/>\n" +
			  tLeft +
			  tRight +
			  "</OMA>\n";
	  }

	| tInteger : INT
	  {
		tResult = "<OMI>" + tInteger.getText() + "</OMI>\n";
	  }

	| tList : AST_LIST
	  {
		/*
		 * Add each child to the list. <p>
		 */
		 
		AST tChild = tList.getFirstChild();
	
		tResult = "<OMA>\n" +
		          " <OMS cd=\"list1\" name=\"list\"/>\n";

		if ( tChild != null )
		{
		   tResult += this.expr( tChild );
		   
		   tChild = tChild.getNextSibling();

		   while( tChild != null )
		   {
			tResult += this.expr( tChild );
			tChild = tChild.getNextSibling();
		   }
		}
	
		tResult +=  "</OMA>\n";
	  }

	| tFunction : AST_FUNCTION
	  {
		/*
		 * A function call.
		 */

		AST tChild = tFunction.getFirstChild();

		tResult = "<OMA>\n" +
		          "<OMS cd=\"gap\" name=\"" +
			  tChild.getText() + 
			  "\"/>\n"; 
		 
		tChild = tChild.getFirstChild();

		while( tChild != null )
		{
			tResult += this.expr( tChild );
			tChild = tChild.getNextSibling();
		}
	
		tResult +=  "</OMA>\n";
	  }

	| tIdentifier : ID
	  {
		if ( tIdentifier.getText().equals( "true" ) ||
		     tIdentifier.getText().equals( "false" ) )
		{
			tResult = 
				"<OMS cd=\"logic1\" name=\"" +
				tIdentifier.getText() +
				"\"/>\n";
		}
		else 
		{
			tResult = "<OMV name=\"" + 
				  tIdentifier.getText() +
				  "\"/>\n";
		}
  	  }
	;