// Copyright 2012- Bill Campbell, Swami Iyer and Bahar Akbal-Delibas
// Edited by Steven Carr for CS451 Compilers+
// Last Edited: March 27th 2024

/**
 * This is the input file to JavaCC for generating a scanner and a parser for j--. From the
 * specification in this file, JavaCC generates, among other files, a JavaCCParser.java program
 * (the parser) and a JavaCCParserTokenManager.java program (the scanner).
 */
PARSER_BEGIN(JavaCCParser)

package jminusminus;

import java.util.ArrayList;

/**
 * Parser generated by JavaCC. It parses a j-- compilation unit (program file), taking tokens from
 * the scanner (also generated by JavaCC), and produces an abstract syntax tree (AST) for it.
 */
class JavaCCParser {
    // Whether a parser error has been found.
    private boolean errorHasOccurred;

    // Name of the file that is parsed.
    private String fileName;

    /**
     * Sets the name of the file being parsed.
     *
     * @param fileName name of the file being parsed.
     */
    public void fileName(String fileName) {
        this.fileName = fileName;
    }

    /**
     * Returns {@code true} if a parser error has occurred up to now, and {@code false} otherwise.
     *
     * @return {@code true} if a parser error has occurred up to now, and {@code false} otherwise.
     */
    public boolean errorHasOccurred() {
        return errorHasOccurred;
    }

    // Pulls out and returns the ambiguous part of a name.
    private AmbiguousName ambiguousPart(TypeName name) {
        String qualifiedName = name.toString();
        int i = qualifiedName.lastIndexOf('.');
        return i == -1 ? null : new AmbiguousName(name.line(), qualifiedName.substring(0, i));
    }

    // Reports a syntax error.
    private void reportParserError(String message, Object... args) {
        errorHasOccurred = true;
        System.err.printf("%s:%d: error: ", fileName, token.beginLine);
        System.err.printf(message, args);
        System.err.println();
    }

    // Recover from the parser error that occurred by skipping to any of the specified tokens.
    // Current error recovery mechanism is rather simple-minded and is based on skipping all the
    // tokens until a SEMI or an EOF is encountered. This scheme can be enhanced by passing in the
    // FOLLOW-SET of the non-terminal at hand.
    private void recoverFromError(int[] skipTo, ParseException e) {
        // Get the possible expected tokens.
        StringBuffer expected = new StringBuffer();
        for (int i = 0; i < e.expectedTokenSequences.length; i++) {
            for (int j = 0; j < e.expectedTokenSequences[i].length; j++) {
                expected.append("\n");
                expected.append("    ");
                expected.append(tokenImage[e.expectedTokenSequences[i][j]]);
                expected.append("...");
            }
        }

        // Print error message.
        if (e.expectedTokenSequences.length == 1) {
            reportParserError("\"%s\" found where %s sought", getToken(1), expected);
        } else {
            reportParserError("\"%s\" found where one of %s sought", getToken(1), expected);
        }

        // Recover.
        boolean loop = true;
        do {
            token = getNextToken(); 
            for (int i = 0; i < skipTo.length; i++) {
                if (token.kind == skipTo[i]) {
                    loop = false;
                    break;
                }
            }
        } while(loop);
    }
}

PARSER_END(JavaCCParser)

/////////////////////////////////////////////////////////
//         The j-- lexical grammar starts here         //
/////////////////////////////////////////////////////////

// Whitespace -- ignored
SKIP: { " " | "\t" | "\n" | "\r" | "\f" }

// Single line comment -- ignored
SKIP: { <BEGIN_COMMENT: "//">: IN_SINGLE_LINE_COMMENT }
<IN_SINGLE_LINE_COMMENT>
SKIP: { <END_COMMENT: "\n" | "\r" | "\r\n">: DEFAULT }
<IN_SINGLE_LINE_COMMENT>
SKIP: { <COMMENT: ~[]> }

// Multi line comment -- ignored -> Added for project4
SKIP: { <BEGIN_MULTI_COMMENT: "/*">: IN_MULTILINE_COMMENT }
<IN_MULTILINE_COMMENT>
SKIP: { <MULTI_COMMENT: ~[]> }
<IN_MULTILINE_COMMENT>
SKIP: { <END_MULTI_COMMENT: "*/">: DEFAULT }


// Reserved words
// Added for project4: break, case, catch, continue, default, do,
//                     double, finally, for, implements, interface, long
//                     switch, throw, throws, try
TOKEN: {
  <ABSTRACT: "abstract">
| <BOOLEAN: "boolean">
| <BREAK: "break">
| <CASE: "case">
| <CATCH: "catch">
| <CHAR: "char">
| <CLASS: "class">
| <CONTINUE: "continue">
| <DEFLT: "default">
| <DO: "do">
| <DOUBLE: "double">
| <ELSE: "else">
| <EXTENDS: "extends">
| <FALSE: "false">
| <FINALLY: "finally">
| <FOR: "for">
| <IF: "if">
| <IMPLEMENTS: "implements">
| <IMPORT: "import">
| <INSTANCEOF: "instanceof">
| <INT: "int">
| <INTERFACE: "interface">
| <LONG: "long">
| <NEW: "new">
| <NULL: "null">
| <PACKAGE: "package">
| <PRIVATE: "private">
| <PROTECTED: "protected">
| <PUBLIC: "public">
| <RETURN: "return">
| <STATIC: "static">
| <SUPER: "super">
| <SWITCH: "switch">
| <THIS: "this">
| <THROW: "throw">
| <THROWS: "throws">
| <TRUE: "true">
| <TRY: "try">
| <VOID: "void">
| <WHILE: "while">
}

// Separators
TOKEN: {
  <COMMA: ",">
| <DOT: ".">
| <LBRACK: "[">
| <LCURLY: "{">
| <LPAREN: "(">
| <RPAREN: ")">
| <RBRACK: "]">
| <RCURLY: "}">
| <SEMI: ";">
}

// Operators
// Added for project4: ?, :, ~, !=, /, /=, -=, *=, %, %=,
//                       >>, >>=, >>>, >>>=, >=, <<, <<=, <, ^, ^=,
//                       |, |=, ||, &, &=

TOKEN: {
  <ALSHIFT: "<<">
| <ALSHIFT_ASSIGN: "<<=">
| <AND: "&">
| <AND_ASSIGN: "&=">
| <ARSHIFT: ">>">
| <ARSHIFT_ASSIGN: ">>=">
| <ASSIGN: "=">
| <COLON: ":">
| <DEC: "--">
| <DIV: "/">
| <DIV_ASSIGN: "/=">
| <EQUAL: "==">
| <GE: ">=">
| <GT: ">">
| <INC: "++">
| <LAND: "&&">
| <LE: "<=">
| <LNOT: "!">
| <LOR: "||">
| <LRSHIFT: ">>>">
| <LRSHIFT_ASSIGN: ">>>=">
| <LT: "<">
| <MINUS: "-">
| <MINUS_ASSIGN: "-=">
| <NOT: "~">
| <NOT_EQUAL: "!=">
| <OR: "|">
| <OR_ASSIGN: "|=">
| <PLUS: "+">
| <PLUS_ASSIGN: "+=">
| <QUESTION: "?">
| <REM: "%">
| <REM_ASSIGN: "%=">
| <STAR: "*">
| <STAR_ASSIGN: "*=">
| <XOR: "^">
| <XOR_ASSIGN: "^=">
}

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

// Literals
// Added for project4: long and double literals
TOKEN: {
  <INT_LITERAL: <DIGIT> ( <DIGIT> )*>
| <LONG_LITERAL: <INT_LITERAL> ( "l" | "L" )>
| <EXPONENT: ( "e" | "E" ) ( "+" | "-" )? <INT_LITERAL>>
| <SUFFIX: "d" | "D">
| <DOUBLE_LITERAL: <INT_LITERAL> "." ( <INT_LITERAL> )? ( <EXPONENT> )? ( <SUFFIX> )?
                   | "." <INT_LITERAL> ( <EXPONENT> )? ( <SUFFIX> )?
                   | <INT_LITERAL> <EXPONENT> ( <SUFFIX> )?
                   | <INT_LITERAL> ( <EXPONENT> )? <SUFFIX>>
| <CHAR_LITERAL: "'" ( <ESC> | ~[ "'", "\\" ] ) "'">
| <STRING_LITERAL: "\"" ( <ESC> | ~[ "\"", "\\" ] )* "\"">
| <#ESC: "\\" [ "n", "t", "b", "r", "f", "\\", "'", "\"" ]>
}

// For anything else, we return an ERROR token. Without this definition the TokenManager will throw
// an Error when a lexical error occurs, making it impossible to recover from it. So we define this
// ERROR token.
TOKEN: { <ERROR: ~[]> }

/////////////////////////////////////////////////////////
//       The j-- syntactic grammar starts here         //
/////////////////////////////////////////////////////////

/**
 * Parses a compilation unit (a program file) and returns an AST for it.
 *
 * <pre>
 *   compilationUnit ::= [ PACKAGE qualifiedIdentifier SEMI ]
 *                       { IMPORT  qualifiedIdentifier SEMI }
 *                       { typeDeclaration }
 *                       EOF
 * </pre>
 *
 * @return an AST for a compilation unit.
 */
public JCompilationUnit compilationUnit():
{
    int line = 0;
    TypeName packageName = null;
    TypeName anImport = null;
    ArrayList<TypeName> imports = new ArrayList<TypeName>();
    JAST aTypeDeclaration = null;
    ArrayList<JAST> typeDeclarations = new ArrayList<JAST>();
}
{
    try {
        [
            <PACKAGE>
            { line = token.beginLine; }
            packageName = qualifiedIdentifier()
            <SEMI>
        ]
        (
            <IMPORT>
            { line = line == 0 ? token.beginLine : line; }
            anImport = qualifiedIdentifier()
            { imports.add(anImport); }
            <SEMI>
        )*
        (
            aTypeDeclaration = typeDeclaration()
            {
                line = line == 0 ? aTypeDeclaration.line() : line;
                typeDeclarations.add(aTypeDeclaration);
            }
        )*
        <EOF>
        { line = line == 0 ? token.beginLine : line; }
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JCompilationUnit(fileName, line, packageName, imports, typeDeclarations); }
}

/**
 * Parses and returns a qualified identifier.
 *
 * <pre>
 *   qualifiedIdentifier ::= IDENTIFIER { DOT IDENTIFIER }
 * </pre>
 *
 * @return a qualified identifier.
 */
private TypeName qualifiedIdentifier():
{
    int line = 0;
    String qualifiedIdentifier = "";
}
{
    try {
        <IDENTIFIER>
        {
            line = token.beginLine;
            qualifiedIdentifier = token.image;
        }
        (
            // Lookahead added to suppress JavaCC warnings.
            LOOKAHEAD(<DOT> <IDENTIFIER>)
            <DOT> <IDENTIFIER>
            { qualifiedIdentifier += "." + token.image; }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new TypeName(line, qualifiedIdentifier); }
}

/**
 * Parses a type declaration and returns an AST for it.
 *
 * <pre>
 *   typeDeclaration ::= modifiers classDeclaration
 * </pre>
 *
 * @return an AST for a type declaration.
 */
private JAST typeDeclaration():
{
    ArrayList<String> mods = null;
    JAST classDeclaration = null;
}
{
    try {
        mods = modifiers()
        classDeclaration = classDeclaration(mods)
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return classDeclaration; }
}

/**
 * Parses and returns a list of modifiers.
 *
 * <pre>
 *   modifiers ::= { ABSTRACT | PRIVATE | PROTECTED | PUBLIC | STATIC }
 * </pre>
 *
 * @return a list of modifiers.
 */
private ArrayList<String> modifiers():
{
    ArrayList<String> mods = new ArrayList<String>();
    boolean scannedPUBLIC    = false;
    boolean scannedPROTECTED = false;
    boolean scannedPRIVATE   = false;
    boolean scannedSTATIC    = false;
    boolean scannedABSTRACT  = false;
}
{
    try {
        (
            <ABSTRACT>
            {
                mods.add("abstract");
                if (scannedABSTRACT) {
                    reportParserError("Repeated modifier: abstract");
                }
                scannedABSTRACT = true;
            } |
            <PRIVATE>
            {
                mods.add("private");
                if (scannedPRIVATE) {
                    reportParserError("Repeated modifier: private");
                }
                if (scannedPUBLIC || scannedPROTECTED) {
                    reportParserError("Access conflict in modifiers");
                }
                scannedPRIVATE = true;
            } |
            <PROTECTED>
            {
                mods.add("protected");
                if (scannedPROTECTED) {
                    reportParserError("Repeated modifier: protected");
                }
                if (scannedPUBLIC || scannedPRIVATE) {
                    reportParserError("Access conflict in modifiers");
                }
                scannedPROTECTED = true;
            } |
            <PUBLIC>
            {
                mods.add("public");
                if (scannedPUBLIC) {
                    reportParserError("Repeated modifier: public");
                }
                if (scannedPROTECTED || scannedPRIVATE) {
                    reportParserError("Access conflict in modifiers");
                }
                scannedPUBLIC = true;
            } |
            <STATIC>
            {
                mods.add("static");
                if (scannedSTATIC) {
                    reportParserError("Repeated modifier: static");
                }
                scannedSTATIC = true;
            }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return mods; }
}

/**
 * Parses a class declaration and returns an AST for it.
 *
 * <pre>
 *   classDeclaration ::= CLASS IDENTIFIER [ EXTENDS qualifiedIdentifier ] classBody
 * </pre>
 *
 * @param mods the class modifiers.
 * @return an AST for a class declaration.
 */
private JClassDeclaration classDeclaration(ArrayList<String> mods):
{
    int line = 0;
    String name = "";
    Type superClass = Type.OBJECT;
    ArrayList<JMember> classBody = null;
}
{
    try {
        <CLASS>
        { line = token.beginLine; }
        <IDENTIFIER>
        { name = token.image; }
        [
            <EXTENDS>
            superClass = qualifiedIdentifier()
        ]
        classBody = classBody()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JClassDeclaration(line, mods, name, superClass, null, classBody); }
}

/**
 * Parses a class body and returns a list of members in the body.
 *
 * <pre>
 *   classBody ::= LCURLY { modifiers memberDecl } RCURLY
 * </pre>
 *
 * @return a list of members in the class body.
 */
private ArrayList<JMember> classBody():
{
    ArrayList<String> mods = null;
    JMember aMember        = null;
    ArrayList<JMember> members = new ArrayList<JMember>();
}
{
    try {
        <LCURLY>
        (
            mods = modifiers()
            aMember = memberDecl(mods)
            { members.add(aMember); }
        )*
        <RCURLY>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return members; }
}

/**
 * Parses a member declaration and returns an AST for it.
 *
 * Added THROWS for project4
 * <pre>
 *   memberDecl ::= IDENTIFIER formalParameters [ THROWS qualifiedIdentifier { COMMA qualifiedIdentifier } ] block
 *                | ( VOID | type ) IDENTIFIER formalParameters
                        [ THROWS qualifiedIdentifier { COMMA qualifiedIdentifier } ] ( block | SEMI )
 *                | type variableDeclarators SEMI
 * </pre>
 *
 * @param mods the class member modifiers.
 * @return an AST for a member declaration.
 */
private JMember memberDecl(ArrayList<String> mods):
{
    int line = 0;
    Type type = null;
    String name = "";
    ArrayList<JFormalParameter> params = null;
    JBlock body = null;
    ArrayList<JVariableDeclarator> variableDeclarators = null;
    JMember memberDecl = null;
    ArrayList<TypeName> exceptions = null;
    TypeName qualifiedID = null;
}
{
    try {
        LOOKAHEAD(<IDENTIFIER> <LPAREN>)
        (
            <IDENTIFIER>
            {
                line = token.beginLine;
                name = token.image;
            }
            params = formalParameters()
            [
                <THROWS>
                { exceptions = new ArrayList<TypeName>(); }
                qualifiedID = qualifiedIdentifier()
                { exceptions.add(qualifiedID); }
                (
                    <COMMA>
                    qualifiedID = qualifiedIdentifier()
                    { exceptions.add(qualifiedID); }
                )*
            ]
            body = block()
            { memberDecl = new JConstructorDeclaration(line, mods, name, params, exceptions, body); }
        ) |
        LOOKAHEAD((<VOID> | type()) <IDENTIFIER> <LPAREN>)
        (
            (
                <VOID>
                { type = Type.VOID; } |
                type = type()
            )
            { line = token.beginLine; }
            <IDENTIFIER>
            { name = token.image; }
            params = formalParameters()
            [
                <THROWS>
                { exceptions = new ArrayList<TypeName>(); }
                qualifiedID = qualifiedIdentifier()
                { exceptions.add(qualifiedID); }
                (
                    <COMMA>
                    qualifiedID = qualifiedIdentifier()
                    { exceptions.add(qualifiedID); }
                )*
            ]
            (
                body = block() |
                <SEMI>
            )
            { memberDecl = new JMethodDeclaration(line, mods, name, type, params, exceptions, body); }
        ) |
        (
            type = type()
            { line = token.beginLine; }
            variableDeclarators = variableDeclarators(type)
            { memberDecl = new JFieldDeclaration(line, mods, variableDeclarators); }
            <SEMI>
        )
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return memberDecl; }
}

/**
 * Parses a block and returns an AST for it.
 *
 * <pre>
 *   block ::= LCURLY { blockStatement } RCURLY
 * </pre>
 *
 * @return an AST for a block.
 */
private JBlock block():
{
    int line = 0;
    JStatement aStatement = null;
    ArrayList<JStatement> statements = new ArrayList<JStatement>();
}
{
    try {
        <LCURLY>
        { line = token.beginLine; }
        (
            aStatement = blockStatement()
            { statements.add(aStatement); }
        )*
        <RCURLY>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JBlock(line, statements); }
}

/**
 * Parses a block statement and returns an AST for it.
 *
 * <pre>
 *   blockStatement ::= localVariableDeclarationStatement
 *                    | statement
 * </pre>
 *
 * @return an AST for a block statement.
 */
private JStatement blockStatement():
{
    JStatement statement = null;
}
{
    try {
        LOOKAHEAD(type() <IDENTIFIER>)
        statement = localVariableDeclarationStatement() |
        statement = statement()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return statement; }
}

/**
 * Parses a statement and returns an AST for it.
 * Added for project4: Do statement, For statement, Break Statement, Switch Statement, Throw Statement
 *
 * <pre>
 *   statement ::= block
 *               | BREAK SEMI
 *               | CONTINUE SEMI
 *               | DO statement WHILE parExpression SEMI
 *               | FOR LPAREN [ forInit ] SEMI [ expression ] SEMI [ forUpdate ] RPAREN statement
 *               | IF parExpression statement [ ELSE statement ]
 *               | RETURN [ expression ] SEMI
 *               | SEMI
 *               | SWITCH parExpression LCURLY { switchBlockStatementGroup } RCURLY
 *               | THROW expression SEMI
 *               | WHILE parExpression statement
 *               | statementExpression SEMI
 * </pre>
 *
 * @return an AST for a statement.
 */
private JStatement statement():
{
    int line = 0;
    JStatement statement                                 = null;
    JExpression test                                     = null;
    JStatement consequent                                = null;
    JStatement alternate                                 = null;
    JStatement body                                      = null;
    JExpression expr                                     = null;
    ArrayList<JStatement> inits                          = null;
    ArrayList<JStatement> updates                        = null;
    ArrayList<SwitchStatementGroup> switchBlockStmtGroup = null;
    SwitchStatementGroup switchStmtGrp                   = null;
    JBlock tryBlock                                      = null;
    ArrayList<JFormalParameter> params                   = null;
    ArrayList<JBlock> catchBlocks                        = null;
    JBlock cBlock                                        = null;
    JFormalParameter parameter                           = null;
    JBlock finallyBlock                                  = null;
}
{
    try {
        statement = block() |
        <BREAK>
        { line = token.beginLine; }
        <SEMI>
        { statement = new JBreakStatement(line); } |
        <CONTINUE>
        { line = token.beginLine; }
        <SEMI>
        { statement = new JContinueStatement(line); } |
        <DO>
        { line = token.beginLine; }
        body = statement()
        <WHILE>
        test = parExpression()
        <SEMI>
        { statement = new JDoStatement(line, body, test); } |
        <FOR>
        { line = token.beginLine; }
        (
            <LPAREN>
            [ inits = forInit() ]
            <SEMI>
            [ expr = expression() ]
            <SEMI>
            [ updates = forUpdate() ]
            <RPAREN>
            body = statement()
        )
        { statement = new JForStatement(line, inits, expr, updates, body); } |
        <IF>
        { line = token.beginLine; }
        test = parExpression()
        consequent = statement()
        // Even without the lookahead below, which is added to suppress JavaCC warnings, dangling
        // if-else problem is resolved by binding the alternate to the closest consequent.
        [
            LOOKAHEAD(<ELSE>)
            <ELSE>
            alternate = statement()
        ]
        { statement = new JIfStatement(line, test, consequent, alternate); } |
        <RETURN>
        { line = token.beginLine; }
        [
            expr = expression()
        ]
        <SEMI>
        { statement = new JReturnStatement(line, expr); } |
        <SEMI>
        {
            line = token.beginLine;
            statement = new JEmptyStatement( line );
        } |
        <SWITCH>
        { line = token.beginLine;
          switchBlockStmtGroup = new ArrayList<SwitchStatementGroup>(); }
        test = parExpression()
        <LCURLY>
        (
            switchStmtGrp = switchBlockStatementGroup()
            { switchBlockStmtGroup.add(switchStmtGrp); }
        )*
        <RCURLY>
        { statement = new JSwitchStatement(line, test, switchBlockStmtGroup); } |
        <THROW>
        { line = token.beginLine; }
        expr = expression()
        <SEMI>
        { statement = new JThrowStatement(line, expr); } |
        <TRY>
        { line = token.beginLine;
          params = new ArrayList<JFormalParameter>();
          catchBlocks = new ArrayList<JBlock>(); }
        tryBlock = block()
        (
            <CATCH>
            <LPAREN>
            parameter = formalParameter()
            { params.add(parameter); }
            <RPAREN>
            cBlock = block()
            { catchBlocks.add(cBlock); }
        )*
        [
            <FINALLY>
            finallyBlock = block()
            { return new JTryStatement(line, tryBlock, params, catchBlocks, finallyBlock); }
        ]
        { statement = new JTryStatement(line, tryBlock, params, catchBlocks, null); } |
        <WHILE>
        { line = token.beginLine; }
        test = parExpression()
        body = statement()
        { statement = new JWhileStatement(line, test, body); } |
        // Must be a statementExpression.
        statement = statementExpression()
        <SEMI>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return statement; }
}

/**
 * Parses and returns a list of formal parameters.
 *
 * <pre>
 *   formalParameters ::= LPAREN [ formalParameter { COMMA  formalParameter } ] RPAREN
 * </pre>
 *
 * @return a list of formal parameters.
 */
private ArrayList<JFormalParameter> formalParameters():
{
    ArrayList<JFormalParameter> parameters = new ArrayList<JFormalParameter>();
    JFormalParameter aParameter = null;
}
{
    try {
        <LPAREN>
        [
            aParameter = formalParameter()
            { parameters.add(aParameter); }
            (
                <COMMA>
                aParameter = formalParameter()
                { parameters.add(aParameter); }
            )*
        ]
        <RPAREN>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return parameters; }
}

/**
 * Parses a formal parameter and returns an AST for it.
 *
 * <pre>
 *   formalParameter ::= type IDENTIFIER
 * </pre>
 *
 * @return an AST for a formal parameter.
 */
private JFormalParameter formalParameter():
{
    int line    = 0;
    Type type   = null;
    String name = "";
}
{
    try {
        type = type()
        { line = token.beginLine; }
        <IDENTIFIER>
        { name = token.image; }
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JFormalParameter(line, name, type); }
}

/**
 * Parses a parenthesized expression and returns an AST for it.
 *
 * <pre>
 *   parExpression ::= LPAREN expression RPAREN
 * </pre>
 *
 * @return an AST for a parenthesized expression.
 */
private JExpression parExpression():
{
    JExpression expr = null;
}
{
    try {
        <LPAREN>
        expr = expression()
        <RPAREN>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}

/**
 * Added for project4
 * Parses the initializations for a for loop.
 *
 * <pre>
 *   forInit ::= statementExpression { COMMA statementExpression }
 *             | type variableDeclarators
 * </pre>
 *
 * @return a list of initialization statements.
 */

 private ArrayList<JStatement> forInit():
 {
    int line = 0;
    ArrayList<JStatement> init = new ArrayList<JStatement>();
    ArrayList<JVariableDeclarator> vdecls = null;
    JStatement expr = null;
    Type type = null;
 }
 {
    try {
        LOOKAHEAD(statementExpression())
        expr = statementExpression()
        { init.add(expr); }
        (
            <COMMA>
            expr = statementExpression()
            { init.add(expr); }
        )* |
        (
          type = type()
          vdecls = variableDeclarators(type)
          { line = token.beginLine;
          init.add(new JVariableDeclaration(line, vdecls)); }
        )
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return init; }
 }

/**
 * Added for project4
 * Parses the update expressions for a for loop.
 *
 * <pre>
 *   forUpdate ::= statementExpression { COMMA statementExpression }
 * </pre>
 *
 * @return a list of update statements.
 */

 private ArrayList<JStatement> forUpdate():
 {
    ArrayList<JStatement> updates = new ArrayList<JStatement>();
    JStatement expr = null;
 }
 {
    try {
        expr = statementExpression()
        { updates.add(expr); }
        (
            <COMMA>
            expr = statementExpression()
            { updates.add(expr); }
        )*

    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return updates; }
 }

/**
 * Added for project4
 * Parses a switch block statement group.
 *
 * <pre>
 *   switchBlockStatementGroup ::= switchLabel { switchLabel } { blockStatement }
 * </pre>
 *
 * @return an object that contains the labels and block statements.
 */

 private SwitchStatementGroup switchBlockStatementGroup():
 {
    ArrayList<JExpression> switchLabels = new ArrayList<JExpression>();
    ArrayList<JStatement> blockStatements = new ArrayList<JStatement>();
    JExpression swLabel = null;
    JStatement blockSt = null;
 }
 {
    try {
        swLabel = switchLabel()
        { switchLabels.add(swLabel); }
        (
            <CASE>
            swLabel = switchLabel()
            { switchLabels.add(swLabel); } |
            <DEFLT>
            swLabel = switchLabel()
            { switchLabels.add(swLabel); }
        )*
        (
            blockSt = blockStatement()
            { blockStatements.add(blockSt); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new SwitchStatementGroup(switchLabels, blockStatements); }
 }

 /**
  * Added for project4
  * Parses a switch label.
  *
  * <pre>
  *   switchLabel ::= CASE expression COLON
  *                 | DEFLT COLON
  * </pre>
  *
  * @return the expression for the case label or null for the default label.
  */

  private JExpression switchLabel():
  {
    JExpression expr = null;
  }
  {
    try {
        <CASE>
        expr = expression()
        <COLON> |
        <DEFLT>
        <COLON>
    } catch (ParseException e) {
          recoverFromError(new int[] { SEMI, EOF }, e);
    }
      { return expr; }
  }

/**
 * Parses a local variable declaration statement and returns an AST for it.
 *
 * <pre>
 *   localVariableDeclarationStatement ::= type variableDeclarators SEMI
 * </pre>
 *
 * @return an AST for a local variable declaration statement.
 */
private JVariableDeclaration localVariableDeclarationStatement():
{
    int line = 0;
    Type type = null;
    ArrayList<JVariableDeclarator> vdecls = null;
}
{
    try {
        type = type()
        { line = token.beginLine; }
        vdecls = variableDeclarators(type)
        <SEMI>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JVariableDeclaration(line, vdecls); }
}

/**
 * Parses and returns a list of variable declarators.
 *
 * <pre>
 *   variableDeclarators ::= variableDeclarator { COMMA variableDeclarator }
 * </pre>
 *
 * @param type type of the variables.
 * @return a list of variable declarators.
 */
private ArrayList<JVariableDeclarator> variableDeclarators(Type type):
{
    JVariableDeclarator aVariableDeclarator = null;
    ArrayList<JVariableDeclarator> variableDeclarators = new ArrayList<JVariableDeclarator>();
}
{
    try {
        aVariableDeclarator = variableDeclarator(type)
        { variableDeclarators.add(aVariableDeclarator); }
        (
            <COMMA>
            aVariableDeclarator = variableDeclarator(type)
            { variableDeclarators.add(aVariableDeclarator); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return variableDeclarators; }
}

/**
 * Parses a variable declarator and returns an AST for it.
 *
 * <pre>
 *   variableDeclarator ::= IDENTIFIER [ ASSIGN variableInitializer ]
 * </pre>
 *
 * @param type type of the variable.
 * @return an AST for a variable declarator.
 */
private JVariableDeclarator variableDeclarator(Type type):
{
    int line = 0;
    JExpression initial = null;
    String name = "";
}
{
    try {
        <IDENTIFIER>
        {
            line = token.beginLine;
            name = token.image;
        }
        [
            <ASSIGN>
            initial = variableInitializer(type)
        ]
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JVariableDeclarator(line, name, type, initial); }
}

/**
 * Parses a variable initializer and returns an AST for it.
 *
 * <pre>
 *   variableInitializer ::= arrayInitializer | expression
 * </pre>
 *
 * @param type type of the variable.
 * @return an AST for a variable initializer.
 */
private JExpression variableInitializer(Type type):
{
    JExpression initializer = null;
}
{
    try {
        initializer = arrayInitializer(type) |
        initializer = expression()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return initializer; }
}

/**
 * Parses an array initializer and returns an AST for it.
 *
 * <pre>
 *   arrayInitializer ::= LCURLY [variableInitializer {COMMA variableInitializer} [COMMA]] RCURLY
 * </pre>
 *
 * @param type type of the array.
 * @return an AST for an array initializer.
 */
private JArrayInitializer arrayInitializer(Type type):
{
    int line = 0;
    ArrayList<JExpression> initials = new ArrayList<JExpression>();
    JExpression anInitializer = null;
}
{
    try {
        <LCURLY>
        { line = token.beginLine; }
        [
            anInitializer = variableInitializer(type.componentType())
            { initials.add(anInitializer); }
            (
                <COMMA>
                anInitializer = variableInitializer(type.componentType())
                { initials.add(anInitializer); }
            )*
        ]
        <RCURLY>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JArrayInitializer(line, type, initials); }
}

/**
 * Parses and returns a list of arguments.
 *
 * <pre>
 *   arguments ::= LPAREN [ expression { COMMA expression } ] RPAREN
 * </pre>
 *
 * @return a list of arguments.
 */
private ArrayList<JExpression> arguments():
{
    ArrayList<JExpression> args = new ArrayList<JExpression>();
    JExpression anExpression = null;
}
{
    try {
        <LPAREN>
        [
            anExpression = expression()
            { args.add(anExpression); }
            (
                <COMMA>
                anExpression = expression()
                { args.add(anExpression); }
            )*
        ]
        <RPAREN>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return args; }
}

/**
 * Parses and returns a type.
 *
 * <pre>
 *   type ::= referenceType | basicType
 * </pre>
 *
 * @return a type.
 */
private Type type():
{
    Type type = null;
}
{
    try {
        LOOKAHEAD(<IDENTIFIER> | basicType() <LBRACK> <RBRACK>)
        type = referenceType() |
        type = basicType()
    } catch (ParseException e) {
       recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return type; }
}

/**
 * Parses and returns a basic type.
 * Added long and double basic types for project4
 *
 * <pre>
 *   basicType ::= BOOLEAN | CHAR | DOUBLE | INT | LONG
 * </pre>
 *
 * @return a basic type.
 */
private Type basicType():
{
    Type type = Type.ANY;
}
{
    try {
        <BOOLEAN>
        { type = Type.BOOLEAN; } |
        <CHAR>
        { type = Type.CHAR; } |
        <DOUBLE>
        { type = Type.DOUBLE; } |
        <INT>
        { type = Type.INT; } |
        <LONG>
        { type = Type.LONG; }
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    {
        if (type == Type.ANY) {
            reportParserError("Type sought where %s found", token.image);
        }
        return type;
    }
}

/**
 * Parses and returns a reference type.
 *
 * <pre>
 *   referenceType ::= basicType LBRACK RBRACK { LBRACK RBRACK }
 *                   | qualifiedIdentifier { LBRACK RBRACK }
 * </pre>
 *
 * @return a reference type.
 */
private Type referenceType():
{
    Type type = Type.ANY;
}
{
    try {
        type = basicType()
        <LBRACK> <RBRACK>
        { type = new ArrayTypeName(type); }
        (
            <LBRACK> <RBRACK>
            { type = new ArrayTypeName(type); }
        )* |
        type = qualifiedIdentifier()
        (
            <LBRACK> <RBRACK>
            { type = new ArrayTypeName(type); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return type; }
}

/**
 * Parses a statement expression and returns an AST for it.
 *
 * <pre>
 *   statementExpression ::= expression
 * </pre>
 *
 * @return an AST for a statement expression.
 */
private JStatement statementExpression():
{
    int line = 0;
    JExpression expr = null;
}
{
    try {
        expr = expression()
        {
            line = expr.line();
            if (expr instanceof JAssignment
             || expr instanceof JPreIncrementOp
             || expr instanceof JPreDecrementOp
             || expr instanceof JPostIncrementOp
             || expr instanceof JPostDecrementOp
             || expr instanceof JMessageExpression
             || expr instanceof JSuperConstruction
             || expr instanceof JThisConstruction 
             || expr instanceof JNewOp
             || expr instanceof JNewArrayOp) {
                // So as not to save on stack.
                expr.isStatementExpression = true;
            } else {
                reportParserError("Invalid statement expression; it does not have a side-effect");
            }
        }
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JStatementExpression( line, expr ); }
}

/**
 * Parses an expression and returns an AST for it.
 *
 * <pre>
 *   expression ::= assignmentExpression
 * </pre>
 *
 * @return an AST for an expression.
 */
private JExpression expression():
{
    JExpression expr = null;
}
{
    try {
        expr = assignmentExpression()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}

/**
 * Parses an assignment expression and returns an AST for it.
 * Added for project4: <ALSHIFT_ASSIGN>, <AND_ASSIGN>, <ARSHIFT_ASSIGN>, <DIV_ASSIGN>, <LRSHIFT_ASSIGN>, <MINUS_ASSIGN>,
 *                      <OR ASSIGN>, <REM_ASSIGN>, <STAR_ASSIGN>, <XOR_ASSIGN>
 *
 * <pre>
 *   assignmentExpression ::= conditionalAndExpression
 *                                [ ( ASSIGN | PLUS_ASSIGN ) assignmentExpression ]
 * </pre>
 *
 * @return an AST for an assignment expression.
 */
private JExpression assignmentExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
}
{
    try {
        lhs = conditionalExpression()
        { line = lhs.line(); }
        [
            <ALSHIFT_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JALeftShiftAssignOp(line, lhs, rhs); } |
            <AND_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JAndAssignOp(line, lhs, rhs); } |
            <ARSHIFT_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JARightShiftAssignOp(line, lhs, rhs); } |
            <ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JAssignOp(line, lhs, rhs); } |
            <DIV_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JDivAssignOp(line, lhs, rhs); } |
            <LRSHIFT_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JLRightShiftAssignOp(line, lhs, rhs); } |
            <MINUS_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JMinusAssignOp(line, lhs, rhs); } |
            <OR_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JOrAssignOp(line, lhs, rhs); } |
            <PLUS_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JPlusAssignOp(line, lhs, rhs); } |
            <REM_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JRemAssignOp(line, lhs, rhs); } |
            <STAR_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JStarAssignOp(line, lhs, rhs); } |
            <XOR_ASSIGN>
            rhs = assignmentExpression()
            { lhs = new JXorAssignOp(line, lhs, rhs); }
        ]
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
* Added for project4
 * Parses a conditional expression and return an AST for it.
 *
 * <pre>
 *   conditionalExpression ::= conditionalOrExpression [ QUESTION expression COLON conditionalExpression ]
 * </pre>
 *
 * @return an AST for a conditional expression.
 */

  private JExpression conditionalExpression():
  {
      int line = 0;
      JExpression expr = null, thenPart = null, elsePart = null;
  }
  {
      try {
          expr = conditionalOrExpression()
          { line = expr.line(); }
          [
            <QUESTION>
            thenPart = expression()
            <COLON>
            elsePart = conditionalExpression()
            { expr = new JConditionalExpression(line, expr, thenPart, elsePart); }
          ]
      } catch (ParseException e) {
          recoverFromError(new int[] { SEMI, EOF }, e);
      }
      { return expr; }
  }

/**
* Added for project4
 * Parses a conditional-or expression and returns an AST for it.
 *
 * <pre>
 *   conditionalOrExpression ::= conditionalAndExpression { LOR conditionalAndExpression }
 * </pre>
 *
 * @return an AST for a conditional-and expression.
 */

 private JExpression conditionalOrExpression():
 {
     int line = 0;
     JExpression lhs = null, rhs = null;
 }
 {
     try {
         lhs = conditionalAndExpression()
         { line = lhs.line(); }
         (
            <LOR>
            rhs = conditionalAndExpression()
            { lhs = new JLogicalOrOp(line, lhs, rhs); }
         )*
     } catch (ParseException e) {
         recoverFromError(new int[] { SEMI, EOF }, e);
     }
     { return lhs; }
 }

/**
 * Parses a conditional-and expression and returns an AST for it.
 *
 * <pre>
 *   conditionalAndExpression ::= inclusiveOrExpression { LAND inclusiveOrExpression }
 * </pre>
 *
 * @return an AST for a conditional-and expression.
 */

private JExpression conditionalAndExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
}
{
    try {
        lhs = inclusiveOrExpression()
        { line = lhs.line(); }
        (
            <LAND>
            rhs = inclusiveOrExpression()
            { lhs = new JLogicalAndOp(line, lhs, rhs); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
* Added for project4
* Parses an inclusive-or expression and returns an AST for it.
*
* <pre>
*   inclusiveOrExpression ::= exclusiveOrExpression { OR exclusiveOrExpression }
* </pre>
*
* @return an AST for an inclusive-or expression.
*/

private JExpression inclusiveOrExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
}
{
    try {
        lhs = exclusiveOrExpression()
        { line = lhs.line(); }
        (
            <OR>
            rhs = exclusiveOrExpression()
            { lhs = new JOrOp(line, lhs, rhs); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
* Added for project4
 * Parses an exclusive-or expression and returns an AST for it.
 *
 * <pre>
 *   exclusiveOrExpression ::= andExpression { XOR andExpression }
 * </pre>
 *
 * @return an AST for a exclusive-or expression.
 */

 private JExpression exclusiveOrExpression():
 {
    int line = 0;
    JExpression lhs = null, rhs = null;
 }
 {
    try {
        lhs = andExpression()
        { line = lhs.line(); }
        (
            <XOR>
            rhs = andExpression()
            { lhs = new JXorOp(line, lhs, rhs); }
        )*
    }  catch (ParseException e) {
          recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
 }

/**
* Added for project4
 * Parses an and expression and returns an AST for it.
 *
 * <pre>
 *   andExpression ::= equalityExpression { AND equalityExpression }
 * </pre>
 *
 * @return an AST for an and expression.
 */

 private JExpression andExpression():
 {
    int line = 0;
    JExpression lhs = null, rhs = null;
 }
 {
    try {
        lhs = equalityExpression()
        { line = lhs.line(); }
        (
            <AND>
            rhs = equalityExpression()
            { lhs = new JAndOp(line, lhs, rhs); }
        )*
    }  catch (ParseException e) {
          recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
 }

/**
 * Parses an equality expression and returns an AST for it.
 * Added for project4: <NOT_EQUAL>
 *
 * <pre>
 *   equalityExpression ::= relationalExpression { EQUAL relationalExpression }
 * </pre>
 *
 * @return an AST for an equality expression.
 */
private JExpression equalityExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
}
{
    try {
        lhs = relationalExpression()
        { line = lhs.line(); }
        (
            <EQUAL>
            rhs = relationalExpression()
            { lhs = new JEqualOp(line, lhs, rhs); } |
            <NOT_EQUAL>
            rhs = relationalExpression()
            { lhs = new JNotEqualOp(line, lhs, rhs); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
 * Parses a relational expression and returns an AST for it.
 *
 * <pre>
 *   relationalExpression ::= shiftExpression [ ( GT | LE ) shiftExpression | INSTANCEOF referenceType ]
 * </pre>
 *
 * @return an AST for a relational expression.
 */
private JExpression relationalExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
    Type type = null;
}
{
    try {
        lhs = shiftExpression()
         { line = lhs.line(); }
        [
            <GE>
            rhs = shiftExpression()
            { lhs = new JGreaterEqualOp(line, lhs, rhs); } |
            <GT>
            rhs = shiftExpression()
            { lhs = new JGreaterThanOp(line, lhs, rhs); } |
            <LE>
            rhs = shiftExpression()
            { lhs = new JLessEqualOp(line, lhs, rhs); } |
            <LT>
            rhs = shiftExpression()
            { lhs = new JLessThanOp(line, lhs, rhs); } |
            <INSTANCEOF>
            type = referenceType()
            { lhs = new JInstanceOfOp(line, lhs, type); }
        ]
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
* Added for project4
 * Parses a shift expression and returns an AST for it.
 *
 * <pre>
 *   shiftExpression ::= additiveExpression { ( ALSHIFT | ARSHIFT | LRSHIFT ) additiveExpression }
 * </pre>
 *
 * @return an AST for a shift expression.
 */

 private JExpression shiftExpression():
 {
    int line = 0;
    JExpression lhs = null, rhs = null;
 }
 {
    try {
        lhs = additiveExpression()
        { line = lhs.line(); }
        (
            <ALSHIFT>
            rhs = additiveExpression()
            { lhs = new JALeftShiftOp(line, lhs, rhs); } |
            <ARSHIFT>
            rhs = additiveExpression()
            { lhs = new JARightShiftOp(line, lhs, rhs); } |
            <LRSHIFT>
            rhs = additiveExpression()
            { lhs = new JLRightShiftOp(line, lhs, rhs); }
        )*
    }  catch (ParseException e) {
          recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
 }

/**
 * Parses an additive expression and returns an AST for it.
 *
 * <pre>
 *   additiveExpression ::= multiplicativeExpression { ( MINUS | PLUS ) multiplicativeExpression }
 * </pre>
 *
 * @return an AST for an additive expression.
 */
private JExpression additiveExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
}
{
    try {
        lhs = multiplicativeExpression()
        { line = lhs.line(); }
        (
            <MINUS>
            rhs = multiplicativeExpression()
            { lhs = new JSubtractOp(line, lhs, rhs); } |
            <PLUS>
            rhs = multiplicativeExpression()
            { lhs = new JPlusOp(line, lhs, rhs); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
 * Parses a multiplicative expression and returns an AST for it.
 * Added for project4: <DIV>, <REM>
 *
 * <pre>
 *   multiplicativeExpression ::= unaryExpression { STAR unaryExpression }
 * </pre>
 *
 * @return an AST for a multiplicative expression.
 */
private JExpression multiplicativeExpression():
{
    int line = 0;
    JExpression lhs = null, rhs = null;
}
{
    try {
        lhs = unaryExpression()
        { line = lhs.line(); }
        (
            <DIV>
            rhs = unaryExpression()
            { lhs = new JDivideOp(line, lhs, rhs); } |
            <REM>
            rhs = unaryExpression()
            { lhs = new JRemainderOp(line, lhs, rhs); } |
            <STAR>
            rhs = unaryExpression()
            { lhs = new JMultiplyOp(line, lhs, rhs); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return lhs; }
}

/**
 * Parses an unary expression and returns an AST for it.
 *
 * <pre>
 *   unaryExpression ::= INC unaryExpression
 *                     | MINUS unaryExpression
 *                     | simpleUnaryExpression
 * </pre>
 *
 * @return an AST for an unary expression.
 */
private JExpression unaryExpression():
{
    int line = 0;
    JExpression expr = null, unaryExpr = null;
}
{
    try {
        <DEC>
        { line = token.beginLine; }
        unaryExpr = unaryExpression()
        { expr = new JPreDecrementOp(line, unaryExpr); } |
        <INC>
        { line = token.beginLine; }
        unaryExpr = unaryExpression()
        { expr = new JPreIncrementOp(line, unaryExpr); } |
        <MINUS>
        { line = token.beginLine; }
        unaryExpr = unaryExpression()
        { expr = new JNegateOp(line, unaryExpr); } |
        <PLUS>
        { line = token.beginLine; }
        unaryExpr = unaryExpression()
        { expr = new JUnaryPlusOp(line, unaryExpr); } |
        expr = simpleUnaryExpression()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}

/**
 * Parses a simple unary expression and returns an AST for it.
 *
 * <pre>
 *   simpleUnaryExpression ::= LNOT unaryExpression
 *                           | LPAREN basicType RPAREN unaryExpression
 *                           | LPAREN referenceType RPAREN simpleUnaryExpression
 *                           | postfixExpression
 * </pre>
 *
 * @return an AST for a simple unary expression.
 */
private JExpression simpleUnaryExpression():
{
    int line = 0;
    Type type = null;
    JExpression expr = null, unaryExpr = null, simpleUnaryExpr = null;
}
{
    try {
        <LNOT>
        { line = token.beginLine; }
        unaryExpr = unaryExpression()
        { expr = new JLogicalNotOp(line, unaryExpr); } |
        <NOT>
        { line = token.beginLine; }
        unaryExpr = unaryExpression()
        { expr = new JComplementOp(line, unaryExpr); } |
        LOOKAHEAD(<LPAREN> basicType() <RPAREN>)
        <LPAREN>
        { line = token.beginLine; }
        type = basicType()
        <RPAREN>
        unaryExpr = unaryExpression()
        { expr = new JCastOp(line, type, unaryExpr); } |
        LOOKAHEAD(<LPAREN> referenceType() <RPAREN>)
        <LPAREN>
        { line = token.beginLine; }
        type = referenceType()
        <RPAREN>
        simpleUnaryExpr = simpleUnaryExpression()
        { expr = new JCastOp(line, type, simpleUnaryExpr); } |
        expr = postfixExpression()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr ; }
}

/**
 * Parses a postfix expression and returns an AST for it.
 *
 * <pre>
 *   postfixExpression ::= primary { selector } { DEC }
 * </pre>
 *
 * @return an AST for a postfix expression.
 */
private JExpression postfixExpression():
{
    int line = 0; 
    JExpression primaryExpr = null;
}
{
    try {
        primaryExpr = primary()
        { line = primaryExpr.line(); }
        (
            primaryExpr = selector(primaryExpr)
        )*
        (
            <DEC>
            { primaryExpr = new JPostDecrementOp(line, primaryExpr); } |
            <INC>
            { primaryExpr = new JPostIncrementOp(line, primaryExpr); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return primaryExpr; }
}

/**
 * Parses a selector and returns an AST for it.
 *
 * <pre>
 *   selector ::= DOT qualifiedIdentifier [ arguments ]
 *              | LBRACK expression RBRACK
 * </pre>
 *
 * @param target the target expression for this selector.
 * @return an AST for a selector.
 */
private JExpression selector(JExpression target):
{
    int line = 0;
    ArrayList<JExpression> args = null;
    TypeName id = null;
    JExpression expr = null;
}
{
    try {
        <DOT>
        { line = token.beginLine; }
        id = qualifiedIdentifier()
        { expr = new JFieldSelection(line, ambiguousPart(id), target, id.simpleName()); }
        [
            args = arguments()
            { expr = new JMessageExpression(line, target, ambiguousPart(id), id.simpleName(),
                                            args); }
        ] |
        <LBRACK>
        { line = token.beginLine; }
        { expr = new JArrayExpression(line, target, expression()); }
        <RBRACK>
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}

/**
 * Parses a primary expression and returns an AST for it.
 *
 * <pre>
 *   primary ::= parExpression
 *             | NEW creator
 *             | THIS [ arguments ]
 *             | SUPER ( arguments | DOT IDENTIFIER [ arguments ] )
 *             | qualifiedIdentifier [ arguments ]
 *             | literal
 * </pre>
 *
 * @return an AST for a primary expression.
 */
private JExpression primary():
{
    int line = 0;
    String name = "";
    JExpression expr = null;
    JExpression newTarget = null;
    ArrayList<JExpression> args = null;
    TypeName id = null;
}
{
    try {
        expr = parExpression() |
        <NEW>
        expr = creator() |
        <THIS>
        {
            line = token.beginLine;
            expr = new JThis(line);
        }
        [
            args = arguments()
            { expr = new JThisConstruction(line, args); }
        ] |
        <SUPER>
        { line = token.beginLine; }
        (
            args = arguments()
            { expr = new JSuperConstruction(line, args); } |
            <DOT> <IDENTIFIER>
            {
                name = token.image;
                newTarget = new JSuper(line);
                expr = new JFieldSelection(line, newTarget, name);
            }
            [
                args = arguments()
                { expr = new JMessageExpression(line, newTarget, null, name, args); }
            ]
        ) |
        // Language is ambiguous here. JavaCC is unable to choose between qualifiedIdentifier and
        // selector. Semantic analysis will sort it out.
        id = qualifiedIdentifier()
        {
            line = id.line();
            if (ambiguousPart(id) == null) {
                expr = new JVariable(line, id.simpleName());
            } else {
                expr = new JFieldSelection(line, ambiguousPart(id), null, id.simpleName());
            }
        }
        [
            args = arguments()
            { expr = new JMessageExpression(line, null, ambiguousPart(id), id.simpleName(), args); }
        ] |
        expr = literal()
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}

/**
 * Parses a creator and returns an AST for it.
 *
 * <pre>
 *   creator ::= ( basicType | qualifiedIdentifier )
 *                   ( arguments
 *                   | LBRACK RBRACK { LBRACK RBRACK } [ arrayInitializer ]
 *                   | newArrayDeclarator
 *                   )
 * </pre>
 *
 * @return an AST for a creator.
 */
private JExpression creator():
{
    int line = 0;
    Type type = null;
    ArrayList<JExpression> args = null;
    ArrayList<JExpression> dims = null;
    JArrayInitializer init =  null;
    JExpression expr = null;
    Type expected = null;
}
{
    try {
        (
            type = basicType() |
            type = qualifiedIdentifier()
        )
        {
            line = token.beginLine;
            expected = type;
        }
        (
            args = arguments()
            { expr = new JNewOp(line, type, args); } |
            LOOKAHEAD(<LBRACK> <RBRACK>)
            <LBRACK> <RBRACK>
            { expected = new ArrayTypeName(expected); }
            (
                LOOKAHEAD(<LBRACK> <RBRACK>)
                <LBRACK> <RBRACK>
                { expected = new ArrayTypeName(expected); }
            )*
            [
               expr = arrayInitializer(expected)
            ] |
            expr = newArrayDeclarator(type)
        )
    } catch (ParseException e) {
        expr = new JWildExpression(token.beginLine);
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}

/**
 * Parses a new array declarator and returns an AST for it.
 *
 * <pre>
 *   newArrayDeclarator ::= LBRACK expression RBRACK { LBRACK expression RBRACK } { LBRACK RBRACK }
 * </pre>
 *
 * @param line line in which the declarator occurred.
 * @param type type of the array.
 * @return an AST for a new array declarator.
 */
private JNewArrayOp newArrayDeclarator(Type type):
{
    int line = 0;
    ArrayList<JExpression> dimensions = new ArrayList<JExpression>();
    JExpression expr = null;
}
{
    try {
        <LBRACK>
        { line = token.beginLine; }
        expr = expression() 
        {
            dimensions.add(expr);
            type = new ArrayTypeName(type);
        }
        <RBRACK>
        (
            LOOKAHEAD(<LBRACK> expression() <RBRACK>)
            <LBRACK>
            expr = expression()
            {
                dimensions.add(expr);
                type = new ArrayTypeName(type);
            }
            <RBRACK>
        )*
        (
            LOOKAHEAD(<LBRACK> <RBRACK>)
            <LBRACK> <RBRACK>
            { type = new ArrayTypeName(type); }
        )*
    } catch (ParseException e) {
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return new JNewArrayOp(line, type, dimensions); }
}

/**
 * Parses a literal and returns an AST for it.
 * Added DOUBLE_LITERAL and LONG_LITERAL for project4
 *
 * <pre>
 *   literal ::= CHAR_LITERAL | DOUBLE_LITERAL | FALSE | INT_LITERAL | LONG_LITERAL | NULL | STRING_LITERAL | TRUE
 * </pre>
 *
 * @return an AST for a literal.
 */
private JExpression literal():
{
    JExpression expr = null;
}
{
    try {
        <CHAR_LITERAL>
        { expr = new JLiteralChar(token.beginLine, token.image); } |
        <DOUBLE_LITERAL>
        { expr = new JLiteralDouble(token.beginLine, token.image); } |
        <FALSE>
        { expr = new JLiteralBoolean(token.beginLine, token.image); } |
        <INT_LITERAL>
        { expr = new JLiteralInt(token.beginLine, token.image); } |
        <LONG_LITERAL>
        { expr = new JLiteralLong(token.beginLine, token.image); } |
        <NULL>
        { expr = new JLiteralNull(token.beginLine); } |
        <STRING_LITERAL>
        { expr = new JLiteralString(token.beginLine, token.image); } |
        <TRUE>
        { expr = new JLiteralBoolean(token.beginLine, token.image); }
    } catch (ParseException e) {
        expr = new JWildExpression(token.beginLine);
        recoverFromError(new int[] { SEMI, EOF }, e);
    }
    { return expr; }
}