Inheritance, interface, urg, sorry...

Question

(this question stems from http://forum.java.sun.com/thread.jspa?threadID=5271181)
Hi,
I've written a propositional logic grammar for a JavaCC parser that compiles fine.
JavaCC generates a SimpleNode class to represent the input. I have methods to be added to the SimpleNode class but would prefer to leave SimpleNode as untouched as possible incase the JavaCC grammar ever needs to be modified, which would lead to the SimpleNode class being regenerated and potentially overwriting the added methods.
So far to get around this I've created a 'SimpleNodeSuperclass' that SimpleNode extends, and put the extra methods inside SimpleNodeSuperclass instead.
I then intend to create a subclass of SimpleNode, called Sentence. Sentence will be where I put the logic methods eval(), isContradiction(), isTautology() etc.
So something like
public interface Node {
     // Generated by JavaCC
     // Contains generic Node operations - adding children, traversing the tree...
public abstract class SimpleNodeSuperclass {
     // Added by me
     // Contains a few extra bits needed in SimpleNode - setting a text label for example.
public class SimpleNode extends SimpleNodeSuperclass implements Node {
     // Generated by JavaCC
     // Implements operations required by Node.
public class Sentence extends SimpleNode {
     // Added by me
     // Contains logic operations
     public Boolean eval() {...}
     public Boolean isContradiction() {...}
     public Boolean isTautology() {...}
     // etc.
}I'm having problems when I try to create a new instance of Sentence though. Previously, to create a SimpleNode, I would do the following
PropLogicParser parser = new PropLogicParser(new StringReader("a & !b"));
SimpleNode root = parser.query();
root.dump();Which would output
Root
And
  Atom
  Not
   Atomas expected.
The problem seems to be that of the other JavaCC generated files refer to Nodes and SimpleNodes so the normal operations don't work with the 'Sentence' class.
I'm sure I'm just missing something obvious with my grasp of Abstract vs Interface vs Inheritance but my brain seems to have slowed to a crawl this evening :(
Cheers

Answer 1

>
I know diddly about JavaCC, but from what I read at https://javacc.dev.java.net/ it would appear that it generates some parser code, which in turn generates a parse tree, which you can may then manipulate.
>
That's about it, you drop a grammar in, it generates a parse tree based around SimpleNodes. There's a bit of smartifying needed, for example when you have "a & b" then it knows a and b are atoms, but you need to add a setLabel() method to capture their names so you can tell them apart. It's that method that's gone into the SimpleNodeSuperclass.
package parser;
abstract class SimpleNodeSuperclass {
     protected int id;
     protected String label;
     public void setLabel(String label) {
          this.label = label;
     public String getLabel() {
          return label;
     public void setType(int type) {
          this.id = type;
     public int getType() {
          return id;
}If I make a sentence have a parse tree then it introduces more problems from what I can see.
package logic;
import parser.SimpleNode;
public class Sentence {
     final private int     ROOT          = 0;
     final private int     VOID          = 1;
     final private int     EQUIVALENT     = 2;
     final private int     IMPLIES          = 3;
     final private int     OR               = 4;
     final private int     AND               = 5;
     final private int     TRUE          = 6;
     final private int     FALSE          = 7;
     final private int     NOT               = 8;
     final private int     ATOM          = 9;
     private SimpleNode     node;
     public Boolean eval(Interpretation inter) {
          Boolean val;
          SimpleNode lhs = (SimpleNode) node.jjtGetChild(0);
          SimpleNode rhs = (SimpleNode) node.jjtGetChild(0);
          switch (node.getType()) {
               case ROOT:
                    val = lhs.eval(inter);
                    break;
               case VOID:
                    val = null;
                    break;
               case EQUIVALENT:
                    val = (lhs.eval(inter) == rhs.eval(inter));
                    break;
               case IMPLIES:
                    val = (!lhs.eval(inter) || rhs.eval(inter));
                    break;
               case OR:
                    val = (lhs.eval(inter) || rhs.eval(inter));
                    break;
               case AND:
                    val = (lhs.eval(inter) && rhs.eval(inter));
                    break;
               case NOT:
                    val = !lhs.eval(inter);
                    break;
               case ATOM:
                    val = inter.get(getLabel());
                    break;
               case FALSE:
                    val = false;
                    break;
               case TRUE:
                    val = true;
                    break;
               default:
                    val = null;
                    break;
          return val;
}The eval() method is all well and good, but because a SimpleNode's children are SimpleNodes too then you can't recursively call eval() on the children without first defining an eval for type SimpleNode - and if I did that then there'd be no point making one for Sentence in the first place.
Again, the reason I don't want to edit SimpleNode directly is because it's generated by JavaCC.
What I did before was just have a completely separate class that only contained helper methods, so I'd just use
LogicOperations.eval(mySimpleNode, myInterpretation);
instead of
mySimpleNode.eval(myInterpretation);
package logic;
import java.util.*;
import parser.*;
public class LogicOperations {
     public static Boolean eval(SimpleNode root, Interpretation inter) {
          Boolean val = null;
          SimpleNode left = null;
          SimpleNode right = null;
          switch (root.jjtGetNumChildren()) {
          case 1:
               left = root.jjtGetChild(0);
               right = null;
               break;
          case 2:
               left = root.jjtGetChild(0);
               right = root.jjtGetChild(1);
               break;
          default:
               break;
          switch (root.getID()) {
          case LogicParserTreeConstants.JJTROOT:
               val = eval(left, inter);
               break;
          case LogicParserTreeConstants.JJTVOID:
               val = null;
               break;
          case LogicParserTreeConstants.JJTCOIMP:
               val = (eval(left, inter) == eval(right, inter));
               break;
          case LogicParserTreeConstants.JJTIMP:
               val = (!eval(left, inter) || eval(right, inter));
               break;
          case LogicParserTreeConstants.JJTOR:
               val = (eval(left, inter) || eval(right, inter));
               break;
          case LogicParserTreeConstants.JJTAND:
               val = (eval(left, inter) && eval(right, inter));
               break;
          case LogicParserTreeConstants.JJTNOT:
               val = !eval(left, inter);
               break;
          case LogicParserTreeConstants.JJTATOM:
               val = inter.get(root.getLabel());
               break;
          case LogicParserTreeConstants.JJTCONSTFALSE:
               val = false;
               break;
          case LogicParserTreeConstants.JJTCONSTTRUE:
               val = true;
               break;
          default:
               val = null;
               break;
          return val;
}It's entirely likely that I've missed what you were trying to say with the good ole 'has a' relationship ting Corlettk, let me know if so