ParserBackup3.jj

/*******************************
***** SECTION 1 - OPTIONS *****
*******************************/
options { JAVA_UNICODE_ESCAPE = true; }
/*********************************
***** SECTION 2 - USER CODE *****
*********************************/
PARSER_BEGIN(SLPTokeniser)
public class SLPTokeniser {
    public static void main(String args[]) {
        SLPTokeniser tokeniser;
        if (args.length == 0) {
            System.out.println("Reading from standard input . . .");
            tokeniser = new SLPTokeniser(System.in);
        } else if (args.length == 1) {
            try {
                tokeniser = new SLPTokeniser(new java.io.FileInputStream(args[0]));
             } catch (java.io.FileNotFoundException e) {
        System.err.println("File " + args[0] + " not found.");
        return;
         }
        }
        else {
            System.out.println("SLP Tokeniser: Usage is one of:");
            System.out.println(" java SLPTokeniser < inputfile");
            System.out.println("OR");
            System.out.println(" java SLPTokeniser inputfile");
        return;
        }
        /*
        * We’ve now initialised the tokeniser to read from the appropriate place,
        * so just keep reading tokens and printing them until we hit EOF
        */
        for (Token t = getNextToken(); t.kind!=EOF; t = getNextToken()) {
            // Print out the actual text for the constants, identifiers etc.
            if (t.kind==NUM)
            {
                System.out.print("Number");
                System.out.print("("+t.image+") ");
            }
            else if (t.kind==ID)
            {
                System.out.print("Identifier");
                System.out.print("("+t.image+") ");
            }
            else if(t.kind == BOOL){
                System.out.println("Boolean");
                System.out.println("(" + t.image + ")");
            }
            else if(t.kind == VOID){
                System.out.println("Void");
                System.out.println("(" + t.image + ")");
            }
            else
            System.out.print(t.image+" ");
        }
    }
}
PARSER_END(SLPTokeniser)

/*****************************************
***** SECTION 3 - TOKEN DEFINITIONS *****
*****************************************/
TOKEN_MGR_DECLS :
{
    static int commentNesting = 0;
}

SKIP : /*** Ignoring spaces/tabs/newlines ***/
{
    " "
    | "\t"
    | "\n"
    | "\r"
    | "\f"
}

SKIP : /* COMMENTS */
{
    "/*" { commentNesting++; } : IN_COMMENT
    |"--" { } : IN_BASIC_COMMENT
}

/* ENDS ON -STAR FORWARD SLASH-  ALSO ALLOWS FOR NESTING */
<IN_COMMENT> SKIP :
{
    "/*" { commentNesting++; }
    | "*/" { commentNesting--;
        if (commentNesting == 0)
            SwitchTo(DEFAULT);
        }
    | <~[]>
}

/* ENDS ON NEW LINE */
<IN_BASIC_COMMENT> SKIP :
{
    "\n" { SwitchTo(DEFAULT); }
}

TOKEN : /* keywords */
{
    < AND : "and" >
    |< BOOL : "bool" >
    |< CONST : "const" >
    |< DO : "do" >
    |< ELSE : "else">
    |< FALSE : "false">
    |< IF : "if" >
    |< INT : "int" >
    |< MAIN : "main" >
    |< NOT : "not" >
    |< OR : "or" >
    |< RETURN : "return" >
    |< THEN : "then" >
    |< TRUE : "true" >
    |< VAR : "var" >
    |< VOID : "void" >
    |< WHILE : "while" >
    |< BEGIN : "begin" >
    |< END : "end" >

}

TOKEN : /* operators and relations */
{
    < SEMIC : ";" >
    | < ASSIGN : ":=" >
    | < COLON : ":" >
    | < LBR : "(" >
    | < RBR : ")" >
    | < COMMA : "," >
    | < PLUS_SIGN : "+" >
    | < MINUS_SIGN : "-" >
    | < MULT_SIGN : "*" >
    | < DIV_SIGN : "/" >
    | < EQUAL_SIGN : "=" >
    | < NOT_EQUAL_SIGN : "!=" >
    | < LESS_THAN : "<" >
    | < GREATER_THAN : ">" >
    | < LESS_EQUALS : "<=" >
    | < GREATER_EQUALS : ">=" >
}

TOKEN : /* Numbers */
{
    < NUM : (<DIGIT>)+ >
    | < #DIGIT : ["0" - "9"] >
}

TOKEN : /* Identifiers */
{
    < ID : (<LETTER>) (<LETTER> | <DIGIT> | "_")* >
    | < #LETTER : ["a" - "z"] | ["A" - "Z"] >
}

//TOKEN :
//{
//    //<#DIGIT: ["0"-"9"] >
//    | <#CHAR: ["a"-"z"]|["A"-"Z"] >
//    | <ID: (<CHAR>)(<CHAR> | <DIGIT>)* >
//    | <NUM: (<DIGIT>)+ >
//    | <REAL: ( (<DIGIT>)+ "." (<DIGIT>)* ) |
//    ( (<DIGIT>)* "." (<DIGIT>)* ) >
//}

TOKEN : /* Anything not recognised so far */
{
    < OTHER : ~[] >
}

/*************************************************************************************
***** SECTION 4 - THE GRAMMAR & PRODUCTION RULES  *****
**************************************************************************************/

void program() : {}
{
    ( decl() )*
    ( function() )*
    main_prog()
}

void decl () : {}
{
    ( var_decl() | const_decl() )
}

void var_decl() : {}
{
    <VAR> ident_list() <COMMA> type() ( <COMMA> ident_list() <COLON> type() )* <SEMIC>
}

void const_decl() : {}
{
    <CONST> <ID> <COLON> type() <EQUAL_SIGN> expression() ( <COMMA> <ID> <COLON> type() <EQUAL_SIGN> expression() )* <SEMIC>
}

void function() : {}
{
    type() <ID> <LBR> param_list() <RBR>
    <BEGIN>
    decl()
    statement()
    <RETURN> ( expression() | {} ) <SEMIC>
    <END>
}

void param_list() : {}
{
    ( <ID> <COLON> type() ( <COMMA> <ID> <COLON> type() )* | {}  )
}

void type() : {}
{
    <INT> | <BOOL> | <VOID>
}

void main_prog() : {}
{
    <MAIN>
    <BEGIN>
    decl()
    ( statement() <SEMIC> )*
    <END>
}

void statement() : {}
{
    <ID> (<ASSIGN> expression() | <LBR> arg_list() <RBR>)
    //| <ID> <LBR> arg_list() <RBR> // combined with above line
    | <BEGIN> ( statement() <SEMIC> )* <END>
    | <IF> condition() <THEN> statement() <ELSE> statement()
    | <WHILE> condition() <DO> statement()
    | {}
}

void expression() : {}
{
    //[<LBR> arg_list() <RBR>] | <NUM> ( <PLUS_SIGN> | <MINUS_SIGN> ) ( ( <PLUS_SIGN> | <MINUS_SIGN> | <MULT_SIGN> | <DIV_SIGN> ) fragment())*
    //fragment() ( ( <PLUS_SIGN> | <MINUS_SIGN> | <MULT_SIGN> | <DIV_SIGN> )  fragment() )*

    fragment() ( ( <PLUS_SIGN> | <MINUS_SIGN> | <MULT_SIGN> | <DIV_SIGN> )  fragment() )*
    | <LBR> expression() <RBR>
    | <ID> <LBR> arg_list() <RBR>
}

void fragment() : {} // possibly combine with expression
{
    <ID> | <TRUE> | <FALSE> | <NUM> | ( <PLUS_SIGN> | <MINUS_SIGN> ) fragment() | expression()
}

//void condition() : {}
//{
//    <NOT> expression()
//    | expression() ( <EQUAL_SIGN> | <NOT_EQUAL_SIGN> | <LESS_THAN> | <GREATER_THAN> | <LESS_EQUALS> | <GREATER_EQUALS> | <AND> | <OR>) expression()
//    | <ID>
//}

void condition() : {}
{
    <NOT> condition()
    | expression() ( <EQUAL_SIGN> | <NOT_EQUAL_SIGN> | <LESS_THAN> | <GREATER_THAN> | <LESS_EQUALS> | <GREATER_EQUALS> ) expression()
    //| condition() ( <AND> | <OR>) condition()
    | conditionPrime()
    | <ID> <LBR> arg_list() <RBR>
}

void conditionPrime() : {}
{
    <NOT> condition() ( <AND> | <OR> ) condition()
    | ( expression() ( <EQUAL_SIGN> | <NOT_EQUAL_SIGN> | <LESS_THAN> | <GREATER_THAN> | <LESS_EQUALS> | <GREATER_EQUALS> ) expression() ) ( <AND> | <OR> ) condition()
    | {}
}

void ident_list() : {}
{
    <ID> ( <COMMA> <ID> )*
}

void arg_list() : {}
{
    ( <ID> ( <COMMA> <ID> )* | {}  )
}