Error reporting

You should just be able to do toString() of any node to get its source. See this simple grammar:

PARSER_PACKAGE=ex;
PARSER_CLASS=Calc;

SKIP : " " | "\t" | "\n" | "\r" ;

TOKEN :
   <PLUS : "+">
   |
   <MINUS : "-">
   |
   <TIMES : "*">
   |
   <DIVIDE : "/">
   |
   <COMMA : ",">
   |
   <LPAREN : "(">
   |
   <RPAREN : ")">
   |
   <NUMBER :  (["0"-"9"])+ ("."(["0"-"9"])+)?>
   |
   <COS : "cos">
   |
   <SIN : "sin">
   |
   <TAN : "tan">
   |
   <ATAN : "atan">
   |
   <ATAN2 : "atan2">
;

AdditiveExpression :
    MultiplicativeExpression
    (
      (<PLUS>|<MINUS>)
      MultiplicativeExpression
    )*
;

MultiplicativeExpression :
    (<NUMBER> | ParentheticalExpression)
    (
       (<TIMES>|<DIVIDE>)
       (<NUMBER> | ParentheticalExpression)
    )*
    | FuncExpression
;

FuncExpression :
    (<COS> | <SIN> | <TAN> | <ATAN> | <ATAN2>) { CURRENT_NODE.kind = peekNode(); }
    <LPAREN>
    [
        AdditiveExpression { CURRENT_NODE.params.add(peekNode()); } ( <COMMA> AdditiveExpression { CURRENT_NODE.params.add(peekNode()); } )*
    ]
    <RPAREN>
;

ParentheticalExpression :
    <LPAREN>
    AdditiveExpression
    <RPAREN>
;

Root : AdditiveExpression <EOF> ;

INJECT PARSER_CLASS :
    import java.util.Scanner;
{
    static public void main(String[] args) throws ParseException {
       while (true) {
         System.out.println("Enter an arithmetic expression:");
         Scanner scanner = new Scanner(System.in);
         String input = scanner.nextLine();

         if (input.equals(""))
            break;


           try {
               PARSER_CLASS parser = new PARSER_CLASS(input);
               parser.Root();
               Node root = parser.rootNode();
               System.out.println(String.format("Dumping the AST of '%s'...", root));
               root.dump();
               System.out.println("The result is: " + root.evaluate());
           }
           catch (ParseException e) {
             System.err.println("Failed to parse expression: " + input + ": " + e);
           }
           catch (UnsupportedOperationException e) {
             System.err.println("Failed to evaluate expression: " + e);
           }
        }
    }
}

INJECT Node :
{
    default double evaluate() {throw new UnsupportedOperationException();}
}

INJECT FuncExpression :
{
    public Node kind;
    public List<Node> params = new ArrayList<>();

    public double evaluate() {
        String s = kind.toString();
        int numParams = (s.equals("cos") || s.equals("sin") || s.equals("tan") || s.equals("atan")) ? 1 : 2;
        int n = params.size();

        if (numParams != n) {
            throw new UnsupportedOperationException(String.format("calling %s with %d parameters is not supported", s, n));
        }
        if (s.equals("cos")) {
            return Math.cos(params.get(0).evaluate());
        }
        if (s.equals("tan")) {
            return Math.tan(params.get(0).evaluate());
        }
        if (s.equals("atan")) {
            return Math.atan(params.get(0).evaluate());
        }
        if (s.equals("atan2")) {
            return Math.atan2(params.get(0).evaluate(), params.get(1).evaluate());
        }
        else if (s.equals("sin")) {
            return Math.sin(params.get(0).evaluate());
        }
        throw new UnsupportedOperationException(String.format("calling %s is not supported", s));
    }
}

INJECT NUMBER :
{
    public double evaluate() {
        return Double.parseDouble(toString());
    }
}

INJECT AdditiveExpression :
{
    public double evaluate() {
        double result = get(0).evaluate();
        for (int i=1; i< size(); i+=2) {
            boolean subtract = get(i) instanceof MINUS;
            double nextOperand = get(i+1).evaluate();
            if (subtract) result -= nextOperand;
            else result += nextOperand;
        }
        return result;
    }
}

INJECT MultiplicativeExpression :
{
    public double evaluate() {
        double result = get(0).evaluate();
        for (int i=1; i< size(); i+=2) {
            boolean divide = get(i) instanceof DIVIDE;
            double nextOperand = get(i+1).evaluate();
            if (divide) result /= nextOperand;
            else result *= nextOperand;
        }
        return result;
    }
}

INJECT ParentheticalExpression :
{
    public double evaluate() {
        return get(1).evaluate();
    }
}

INJECT Root :
{
    public double evaluate() {
        return get(0).evaluate();
    }
}

If you compile it using java -jar congocc.jar Arithmetic.ccc and then javac ex/Calc.java and then java ex.Calc you can play around with what happens when you type in correct or wrong data.

opeongo Sure. I used the input as a convenience, but as I explained in my last post, it's easy enough to generalise it. The tokens themselves will each contain their start and end offsets, and start and end line and column information, so you could of course reconstruct the input from them, but you would have to account for whitespace between the tokens. In my view, it's easier to just fetch the source line corresponding to the error token and go from there. It's been so long since I used legacy JavaCC that I cannot remember its API, but the CongoCC API is pretty capable of being used for good error reporting.

I've made a slight change to the Token API to facilitate getting the source line. So with the latest congocc.jar, the exception clause in the parsing loop above could look like this:

                Token token = (Token) e.getToken();
                int errCol = token.getBeginColumn();
                Node root = parser.rootNode();
                int startCol = 1;
                System.err.println("Failed to parse expression: " + input + ": " + e);
                System.err.println(token.getSourceLine());
                int spaces = errCol - startCol + 1;
                String fmt = "%" + spaces + "s";
                System.err.println(String.format(fmt, "^"));

The token.getSourceLine() gets the line of source which contains the token.

Just to throw another chicken in the pot, I use the ATTEMPT ... RECOVER extensively in my grammar to catch the error, issue an appropriate message and skip over what I think is the problem. Unlike JavaCC's try/catch, this leaves the parser in a known state prior to performing the RECOVER code and/or expansion. This might be something to look at as well.