diff options
Diffstat (limited to 'src/main/java/io/devnulllabs/openjava/ptree/NonLeaf.java')
| -rw-r--r-- | src/main/java/io/devnulllabs/openjava/ptree/NonLeaf.java | 381 |
1 files changed, 381 insertions, 0 deletions
diff --git a/src/main/java/io/devnulllabs/openjava/ptree/NonLeaf.java b/src/main/java/io/devnulllabs/openjava/ptree/NonLeaf.java new file mode 100644 index 0000000..3974e49 --- /dev/null +++ b/src/main/java/io/devnulllabs/openjava/ptree/NonLeaf.java @@ -0,0 +1,381 @@ +/* + * NonLeaf.java 1.0 + * + * This subclass of symbol represents (at least) terminal symbols returned + * by the scanner and placed on the parse stack. At present, this + * class does nothing more than its super class. + * + * Jun 11, 1997 + * + * @see io.devnulllabs.openjava.ptree.ParseTree + * @see io.devnulllabs.openjava.ptree.ParseTreeObject + * @version 1.0 last updated: Jun 11, 1997 + * @author Michiaki Tatsubori + */ +package io.devnulllabs.openjava.ptree; + +import io.devnulllabs.openjava.ptree.util.ParseTreeVisitor; +import io.devnulllabs.openjava.tools.DebugOut; + +/** + * The NonLeaf class presents for node of parse tree. + * + * @see io.devnulllabs.openjava.ptree.ParseTree + * @see io.devnulllabs.openjava.ptree.Leaf + */ +public abstract class NonLeaf extends ParseTreeObject implements ParseTree { + private String comment = ""; + + protected final void replaceChildWith( + ParseTree dist, + ParseTree replacement) + throws ParseTreeException { + DebugOut.println( + "NonLeaf.replaceChildWith() " + dist + " with " + replacement); + for (int i = 0; i < contents.length; ++i) { + if (contents[i] == dist) { + contents[i] = replacement; + ((ParseTreeObject) replacement).setParent(this); + return; + } + } + throw new ParseTreeException( + "no replacing target " + + dist + + " for " + + replacement + + " in the source code : " + + toString()); + } + + /** contents is the array of the elements of this nonleaf-node. */ + private Object[] contents = null; + + /** + * Allocates a new non-leaf(cons-cell), where the first element has + * null and the second element has null. + * + */ + public NonLeaf() { + contents = new Object[0]; + } + + /** + * Makes a new copy (another object) of this nonleaf-node recursively. + * The objects contained by this object will also be copied. + * + * @return the copy of this nonleaf-node as a ptree-node. + */ + public ParseTree makeRecursiveCopy() { + NonLeaf result = (NonLeaf) makeCopy(); + + Object newc[] = new Object[contents.length]; + for (int i = 0; i < contents.length; ++i) { + if (contents[i] instanceof ParseTree) { + ParseTree src = (ParseTree) contents[i]; + newc[i] = (ParseTree) src.makeRecursiveCopy(); + } else if (contents[i] instanceof String[]) { + String[] srcary = (String[]) contents[i]; + String[] destary = new String[srcary.length]; + System.arraycopy(srcary, 0, destary, 0, srcary.length); + newc[i] = destary; + } else if (contents[i] instanceof TypeName[]) { + TypeName[] srcary = (TypeName[]) contents[i]; + TypeName[] destary = new TypeName[srcary.length]; + for (int j = 0; j < srcary.length; ++j) { + destary[j] = (TypeName) srcary[j].makeRecursiveCopy(); + } + newc[i] = destary; + } else if (contents[i] instanceof VariableDeclarator[]) { + VariableDeclarator[] srcary = + (VariableDeclarator[]) contents[i]; + VariableDeclarator[] destary = + new VariableDeclarator[srcary.length]; + for (int j = 0; j < srcary.length; ++j) { + //VariableDe + destary[j] = + (VariableDeclarator) srcary[j].makeRecursiveCopy(); + } + newc[i] = destary; + } else if (contents[i] instanceof Object[]) { + System.err.println( + "makeRecursiveCopy() not supported in " + getClass()); + newc[i] = contents[i]; + } else { + newc[i] = contents[i]; + } + } + + result.set(newc); + + return result; + } + + /** + * Tests if this nonleaf-node's value equals to the specified + * ptree-node's. + * + * @return true if two values are same. + */ + public boolean equals(ParseTree p) { + if (p == null || getClass() != p.getClass()) + return false; + if (this == p) + return true; + + NonLeaf nlp = (NonLeaf) p; + int len = this.getLength(); + if (len != nlp.getLength()) + return false; + + System.err.println("equals() not supported in " + getClass().getName()); + for (int i = 0; i < len; i++) { + /*if(! equal( this.elementAt( i ), nlp.elementAt( i ) )) + return false; + */ + } + return true; + } + + /** + * Makes this ptree a list presenting for + * [ p ] + * + * @param p list's element + */ + protected void set(Object[] ptrees) { + contents = ptrees; + for (int i = 0; i < contents.length; ++i) { + if (contents[i] instanceof ParseTreeObject) { + ((ParseTreeObject) contents[i]).setParent(this); + } + } + } + + /** + * Makes this ptree a list presenting for + * [ p ] + * + * @param p list's element + */ + protected void set(Object p) { + set(new Object[] { p }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 ] + * + * @param p0 list's element + * @param p1 list's element + */ + protected void set(Object p0, Object p1) { + set(new Object[] { p0, p1 }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 p2 ] + * + * @param p0 list's element + * @param p1 list's element + * @param p2 list's element + */ + protected void set(Object p0, Object p1, Object p2) { + set(new Object[] { p0, p1, p2 }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 p2 p3 ] + * + * @param p0 list's element + * @param p1 list's element + * @param p2 list's element + * @param p3 list's element + */ + protected void set(Object p0, Object p1, Object p2, Object p3) { + set(new Object[] { p0, p1, p2, p3 }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 p2 p3 p4 ] + * + * @param p0 list's element + * @param p1 list's element + * @param p2 list's element + * @param p3 list's element + * @param p4 list's element + */ + protected void set(Object p0, Object p1, Object p2, Object p3, Object p4) { + set(new Object[] { p0, p1, p2, p3, p4 }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 p2 p3 p4 p5 ] + * + * @param p0 list's element + * @param p1 list's element + * @param p2 list's element + * @param p3 list's element + * @param p4 list's element + */ + protected void set( + Object p0, + Object p1, + Object p2, + Object p3, + Object p4, + Object p5) { + set(new Object[] { p0, p1, p2, p3, p4, p5 }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 p2 p3 p4 p5 p6 ] + * + * @param p0 list's element + * @param p1 list's element + * @param p2 list's element + * @param p3 list's element + * @param p4 list's element + * @param p5 list's element + * @param p6 list's element + */ + protected void set( + Object p0, + Object p1, + Object p2, + Object p3, + Object p4, + Object p5, + Object p6) { + set(new Object[] { p0, p1, p2, p3, p4, p5, p6 }); + } + + /** + * Makes this ptree a list presenting for + * [ p0 p1 p2 p3 p4 p5 p6 p7 ] + * + * @param p0 list's element + * @param p1 list's element + * @param p2 list's element + * @param p3 list's element + * @param p4 list's element + * @param p5 list's element + * @param p6 list's element + * @param p7 list's element + */ + protected void set( + Object p0, + Object p1, + Object p2, + Object p3, + Object p4, + Object p5, + Object p6, + Object p7) { + set(new Object[] { p0, p1, p2, p3, p4, p5, p6, p7 }); + } + + /** + * Returns the specified element at the specified point of this + * nonleaf-node. + * + * @param i index + * @return the ptree object at the specified point + */ + protected Object elementAt(int i) { + Object ret = null; + + try { + ret = contents[i]; + } catch (ArrayIndexOutOfBoundsException ex) { + System.out.println(ex); + //throw new NonLeafException( ex.toString() ); + } + + return ret; + } + + /** + * Sets the specified element at the specified point of this + * nonleaf-node. + * + * @param p ptree object to set + * @param i index + */ + protected void setElementAt(Object p, int i) { + try { + contents[i] = p; + if (contents[i] instanceof ParseTreeObject) { + ((ParseTreeObject) contents[i]).setParent(this); + } + } catch (ArrayIndexOutOfBoundsException ex) { + System.out.println(ex); + //throw new NonLeafException( ex.toString() ); + } + } + + /** + * Gets the contents of this nonleaf-node. + * + * @return contents + */ + public Object[] getContents() { + /***********/ + return contents; + } + + /** + * getLength() returns the length of this nonleaf-node + * + * @return the length of the list + */ + protected int getLength() { + return contents.length; + } + + /** + * Sets the comment of javadoc format which explains this declaration. + * + * @param comment the Comment object to set + */ + public void setComment(String comment) { + this.comment = comment; + } + + /** + * Obtains the comment of javadoc format which explains this declaration. + * + * @return the string of the comment + */ + public String getComment() { + return this.comment; + } + + /** + * Accepts a <code>ParseTreeVisitor</code> object as the role of a + * Visitor in the Visitor pattern, as the role of an Element in the + * Visitor pattern.<p> + * + * This invoke an appropriate <code>visit()</code> method on each + * child <code>ParseTree</code> object with this visitor. + * + * @param visitor a visitor + **/ + public void childrenAccept(ParseTreeVisitor visitor) + throws ParseTreeException { + if (contents == null) + return; + for (int i = 0; i < contents.length; ++i) { + if (contents[i] instanceof ParseTree) { + ParseTree ptree = (ParseTree) contents[i]; + ptree.accept(visitor); + } + } + } + +} |