oaaprolognetparse.g-latin1

SRI international 发布的OAA框架软件

/* 
Modified OAA parser.
David Hjelm, Mar 05
[e-mail]

Can parse: 
- infix operators: <, >, =<, >=, is, @<, @>, ==, \=, is,...
- unquoted IclStrs and IclVars containing characters in unicode range 128-255

 */
header {
package com.sri.oaa2.icl;

import java.util.Stack;
}

class OaaPrologParser extends Parser;
options {
    k = 2;
    exportVocab = OaaPrologVocab;
    buildAST = true;
    defaultErrorHandler=false;
}tokens {
    GROUP;
    LIST;
    VAR;
    STRUCT;
    ICLDATAQ;
    STR;
    INT;
    FLOAT;
    DOT;
    SPECIAL_CHAR_LITERAL;
    TERM_LITERAL="term";
    ENDPAREN_LITERAL=").";
    ICLDATAQ_LITERAL="icldataq";
    IS_LITERAL="is";
}
{
    private Stack listStack = new Stack();
}

startMulti
    : (DOT!)? netstruct
    ;
startMultiNonNet
    : struct (DOT!)?
    ;
icldataqTest
    : (icldataqStruct | )
        EOF!
    ;

startOneOnly
    : (struct (DOT!)? | )
        EOF!
    ;

commaSeparatedStructs
    : struct
          (COMMA!
              struct
          )*
    ;

listOnlyExpressionList
    : ( struct
            (COMMA!
                struct
            )*
            (PIPE!
                ( var {((IclASTList)this.listStack.peek()).setHeadTailList(true);}
                | recursiveList! {AST child = returnAST; AST nextChild = null; while(child != null){nextChild = child.getNextSibling();astFactory.addASTChild(currentAST, child); child = nextChild;}})
            )?
        |
        )
    ;


group
    : LBRACE^<AST=IclASTGroup>
        commaSeparatedStructs
        RBRACE! {currentAST.root.setType(GROUP);}
    |   LPAREN^<AST=IclASTGroup>
        commaSeparatedStructs
        RPAREN! {currentAST.root.setType(GROUP);}
    ;

list
    :
      LBRACK^<AST=IclASTList>{this.listStack.push(currentAST.root);}
        listOnlyExpressionList
        RBRACK!
      {this.listStack.pop();currentAST.root.setType(LIST);}
    ;

recursiveList
    :
        LBRACK!
        listOnlyExpressionList
        RBRACK!
    ;


var
    : VARIABLE<AST=IclASTVar>
    {currentAST.root.setType(VAR);}
    ;

netstruct
    :   TERM_LITERAL^<AST=IclASTStruct>
        LPAREN!
        commaSeparatedStructs
        RPAREN!
	{currentAST.root.setType(STRUCT);}
    ;
struct
    :
        semiExpression ((TURNSTILE^<AST=IclASTStruct>) semiExpression)*
    ;

semiExpression
    :
        backslashExpression ((SEMI^<AST=IclASTStruct>) backslashExpression)*
    ;

backslashExpression
    :
        isAssignmentExpression ((BACKSLASH^<AST=IclASTStruct>) isAssignmentExpression)*
    ;

// DH edited Mar 2005
//arithmetic evaluation, e.g. X is 1+2
isAssignmentExpression
    : 
     equalsExpression ((IS_LITERAL^<AST=IclASTStruct>) equalsExpression)*
            //equalsExpression ((IDENT^<AST=IclASTStruct>) equalsExpression)*
;
// DH edited Mar 2005
// This one is extended w a lot of standard infix  operators
// w the same precedence
equalsExpression
        :                   
            slashExpression ( (EQUAL^<AST=IclASTStruct> |
                                     NOT_EQUAL^<AST=IclASTStruct> |
                               LESS_THAN^<AST=IclASTStruct> |
                               GREATER_THAN^<AST=IclASTStruct> |
                               UNIV^<AST=IclASTStruct> |
                               NUM_EQUAL^<AST=IclASTStruct> |
                               LESS_THAN_OR_EQUAL^<AST=IclASTStruct> |
                               GREATER_THAN_OR_EQUAL^<AST=IclASTStruct> |
                               LITERALLY_EQUAL^<AST=IclASTStruct> |
                               NOT_LITERALLY_EQUAL^<AST=IclASTStruct> |
                               NOT_NUM_EQUAL^<AST=IclASTStruct> |
                               BEFORE^<AST=IclASTStruct> |
                               AFTER^<AST=IclASTStruct> |
                               NOT_BEFORE^<AST=IclASTStruct> |
                               NOT_AFTER^<AST=IclASTStruct> 
                              ) slashExpression)*
        ;



slashExpression
:
( (DIV^<AST=IclASTStruct> colonExpression) | colonExpression )
;

colonExpression
    :
        plusMinusExpression (( COLON^<AST=IclASTStruct> | DBL_COLON^<AST=IclASTStruct>) plusMinusExpression)*
    ;


plusMinusExpression
    :
        multiplicativeExpression (( PLUS^<AST=IclASTStruct> | MINUS^<AST=IclASTStruct> ) multiplicativeExpression)*
    ;

multiplicativeExpression
    :
        hatExpression (( STAR^<AST=IclASTStruct> | DIV^<AST=IclASTStruct> ) hatExpression)*
    ;


// DH edited Mar 2005
// A^B squeezed in here
hatExpression
:
  unaryExpression (HAT^<AST=IclASTStruct> unaryExpression)*
    
;

unaryExpression
{int sign = 1;}
    : normalStruct
    | icldataqStruct
    | PLUS! NUM_INT^<AST=IclASTInt> {currentAST.root.setType(INT);}
    | PLUS! NUM_FLOAT^<AST=IclASTFloat> {currentAST.root.setType(FLOAT);}
    | MINUS! {sign = -1;} NUM_INT^<AST=IclASTInt> {currentAST.root.setType(INT); ((IclASTInt)(currentAST.root)).setSign(sign);}
    | MINUS! {sign = -1;} NUM_FLOAT^<AST=IclASTFloat> {currentAST.root.setType(FLOAT);((IclASTFloat)(currentAST.root)).setSign(sign);}
    | PLUS^<AST=IclASTStruct> unaryExpression {currentAST.root.setType(STRUCT);}
    | MINUS^<AST=IclASTStruct> unaryExpression {currentAST.root.setType(STRUCT);}
    | unaryExpressionNotPlusMinus
    ;

unaryExpressionNotPlusMinus
    : list
    | group
    | var
    | NUM_INT<AST=IclASTInt> {currentAST.root.setType(INT);}
    | NUM_FLOAT<AST=IclASTFloat> {currentAST.root.setType(FLOAT);}
    | str
    ;

icldataqStruct
    : ICLDATAQ_LITERAL!
        LPAREN!
        (icldataqShortStruct | icldataqLongStruct)
        RPAREN!
    ;

icldataqShortStruct
    : DBLQUOTED^<AST=IclASTDataQ>
        {currentAST.root.setType(ICLDATAQ);}
    ;

icldataqLongStruct
    : rawlen:NUM_INT! COMMA! numquotes:NUM_INT! COMMA! DBLQUOTED^<AST=IclASTDataQ>
        {currentAST.root.setType(ICLDATAQ); ((IclASTDataQ)(currentAST.root)).setRawLen(rawlen); ((IclASTDataQ)(currentAST.root)).setNumQuotes(numquotes);}
    ;

normalStruct
    : (BANG^<AST=IclASTStruct> | SEMI^<AST=IclASTStruct> | STRING_LITERAL^<AST=IclASTStruct> |
 SPECIAL_CHAR_LITERAL^<AST=IclASTStruct> |