AST.java

Violations

Source code

/*
 * hgcommons 9
 * Hammurapi Group Common Library
 * Copyright (C) 2003  Hammurapi Group
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * URL: http://www.hammurapi.biz/hammurapi-biz/ef/xmenu/hammurapi-group/products/products/hgcommons/index.html
 * e-Mail: support@hammurapi.biz
 */
package biz.hammurapi.antlr;

import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.PrintStream;
import java.util.LinkedHashMap;

import antlr.CommonAST;
import biz.hammurapi.legacy.review.SourceMarker;
import biz.hammurapi.util.Attributable;
import biz.hammurapi.util.PoliteVisitor;
import biz.hammurapi.util.Visitable;
import biz.hammurapi.util.Visitor;


/**
 * Holds line and column numbers
 * @author Pavel Vlasov
 * @version $Revision: 1.8 $
 */
public class AST extends CommonAST implements SourceMarker, Visitable, Attributable {
    /**
	 * Comment for <code>serialVersionUID</code>
	 */
	private static final long serialVersionUID = -3283377943637002016L;
	private int line;
    private int column;
    private boolean childrenQueried=false;
    private AST parent;
    private String id;
    private Token token;
    private boolean loaded=false;
//  private LanguageElement owner;

    
    private Token firstToken;
    private Token lastToken;
    
    public void initialize(antlr.Token tok) {
        super.initialize(tok);
        line=tok.getLine();
        column=tok.getColumn();
        this.token=(Token) tok;
        this.firstToken=this.token;
        this.lastToken=this.token;
    }
    
    public void initialize(antlr.collections.AST node) {
        super.initialize(node);
        if (node instanceof AST) {
            AST ast = (AST) node;
			line=ast.getLine();
            column=ast.getColumn();
            this.token=ast.token;
            this.firstToken=ast.firstToken;
            this.lastToken=ast.lastToken;
        }
    }
    
    public int getLine() {
//        queryChildren();

        return line;        
    }
    
    public int getColumn() {
//        queryChildren();

        return column;
    }
    
    public Token getToken() {
        return token;
    }
    
    /**
     * Returns leftmost non-zero column among itself and all children
     */
    public int getLeftColumn() {
        int ret=getColumn();
        for (AST child=(AST) getFirstChild(); child!=null; child=(AST) child.getNextSibling()) {
            int c=child.getLeftColumn();
            if (c!=0 && c<ret) ret=c;
        }
        return ret;        
    }
    
    public AST getParent() {
        return parent;
    }
    
    protected void setParent(AST parent) {
    	this.parent=parent;
    }
    
    /**************************************************************************
     * Parent calculation
     *************************************************************************/
    public void addChild(antlr.collections.AST node) {
        super.addChild(node);
        if (node instanceof AST) {
            ((AST) node).parent=this;
        }
    }
    
    public void setFirstChild(antlr.collections.AST c) {
        super.setFirstChild(c);
        if (c instanceof AST) {
            ((AST) c).parent=this;
        }
    }
    
    public void setNextSibling(antlr.collections.AST n) {
		antlr.collections.AST currentNextSibling=getNextSibling();
    	if (currentNextSibling instanceof AST) {
    		((AST) currentNextSibling).setPrevSibling(null);	
    	}
    	
        super.setNextSibling(n);
        
        
        if (n instanceof AST) {
            ((AST) n).setParent(parent);
            ((AST) n).setPrevSibling(this);
        }
    }
    
    private AST prevSibling;
    
    public AST getPrevSibling() {
        return prevSibling;
    }
    
    protected void setPrevSibling(AST prevSibling) {
        this.prevSibling=prevSibling;
    }
    
    /**
     * Removes AST from tree
     */
    public void remove() {
    	if (parent!=null && parent.getFirstChild()==this) {
    		parent.setFirstChild(getNextSibling());
    	}
    	
    	parent=null;
    	
    	if (prevSibling==null) {
    		if (getNextSibling() instanceof AST) {
    			((AST) getNextSibling()).setPrevSibling(null);		
    		}
    	} else {
    		prevSibling.setNextSibling(getNextSibling());
    	}    	    			
    	
    	setPrevSibling(null);    	
    }
    
    /**
     * Reads column and line from children if its own are 0. Also sets first and last
     * tokens taking children's into account.
     */
    public void queryChildren() {
        if (!childrenQueried) {
	        childrenQueried=true;
	        for (AST child = (AST) getFirstChild(); child != null ; child = (AST) child.getNextSibling()) {
	        	child.queryChildren();
	        	
	            if (line==0 && column==0 && child.getLine()!=0) {
	                line=child.getLine();
	                column=child.getColumn();
	            }
	            
	            Token cft=child.getFirstToken();
	            if (cft!=null && (firstToken==null || cft.compareTo(firstToken)<0)) {
	            	firstToken=cft;
	            }
	            
	            Token clt=child.getLastToken();
	            if (clt!=null && (lastToken==null || clt.compareTo(lastToken)>0)) {
	            	lastToken=clt;
	            }
	        }
        }
    }
    
    private String sourceURL;

	public String getSourceURL() {
		return sourceURL;
	}
	
	public void setSourceURL(String sourceURL) {
		this.sourceURL=sourceURL;
	}
	
	/**
	 * Indicates that the node has been processed by superclass and can be ignored
	 * @return Returns the loaded.
	 */
	boolean isLoaded() {
		return loaded;
	}

	/**
	 * @param loaded The loaded to set.
	 */
	void setLoaded(boolean loaded) {
		this.loaded = loaded;
	}

	public boolean equals(Object obj) {
		if (obj==null) {
			return false;
		}
		
		if (obj==this) {
			return true;
		}
		
		if (getClass().equals(obj.getClass())) {
			return false;
		}
		
		AST ast=(AST) obj;
		
		if (super.equals(ast)) {
			
			if (ast.getNumberOfChildren()!=getNumberOfChildren()) {
				return false;
			}
			
			for (AST child=(AST) getFirstChild(), otherChild=(AST) ast.getFirstChild(); child!=null && otherChild!=null; child=(AST) child.getNextSibling(), otherChild=(AST) otherChild.getNextSibling()) {
				if (!child.equals(ast.getFirstChild())) {
					return false;
				}
			}
			return true;
		}
		
		return false;
	}
	
	public int hashCode() {
		int ret=getType();
		ret^=getClass().getName().hashCode();
		
		if (getText()!=null) {
			ret^=getText().hashCode();
		}
		for (AST child=(AST) getFirstChild(); child!=null; child=(AST) child.getNextSibling()) {
			ret^=child.hashCode();
		}
		return ret;
	}
	
	public int getSize() {
		int ret=1;
		for (AST child=(AST) getFirstChild(); child!=null; child=(AST) child.getNextSibling()) {
			ret+=child.getSize();
		}
		
		return ret;
	}

	public Token getFirstToken() {
		queryChildren();
		return firstToken;
	}

	public Token getLastToken() {
		queryChildren();
		return lastToken;
	}
	
//	protected LanguageElement getOwner() {

//		return owner;

//	}


//	protected void setOwner(LanguageElement owner) {

//		this.owner = owner;

//	}


	public String getId() {
		return id;
	}
	
	private void enumerateChildren() {
		int i=0;
		for (AST node=(AST) getFirstChild(); node!=null; node=(AST) node.getNextSibling(), i++) {
			node.id = id==null ? String.valueOf(i) : id+'.'+i;
			node.enumerateChildren();			
		}
	}
	
	public void enumerate() {
		int i=0;
		for (AST node=this; node!=null; node=(AST) node.getNextSibling(), i++) {
			node.id=String.valueOf(i);
			node.enumerateChildren();
		}
	}

	public boolean accept(Visitor visitor) {
		if (visitor.visit(this)) {
			if (getFirstChild()!=null) {
				((Visitable) getFirstChild()).accept(visitor);
			}
			
			if (visitor instanceof PoliteVisitor) {
				((PoliteVisitor) visitor).leave(this);
			}
			
			if (getNextSibling()!=null) {
				return ((Visitable) getNextSibling()).accept(visitor);
			}
			
			return true;						
		}
		
		return false;
	}

	public Integer getSourceId() {
		return null;
	}
	
	public void print(String[] tokenNames, boolean withSiblings) {		
		print(tokenNames, System.out, 0, withSiblings);
	}
	
	public void print(String[] tokenNames, PrintStream out, int level, boolean withSiblings) {
		if (withSiblings) {
			visitAll(tokenNames, this, level, out);			
		} else {
			visit(tokenNames, this, level, out);			
		}
	}

	protected void tabs(PrintStream out, int level) {
		for (int i = 0; i < level; i++) {
			out.print("   ");
		}
	}
	
	protected void visit(String[] tokenNames, AST node, int level, PrintStream out) {
		tabs(out, level);        
		out.print(tokenNames[node.getType()]+" ");
		out.print(node.getText()==null ? "nil" : node.getText());
		out.println(" "+node.getLine()+(node.getColumn()==node.getLeftColumn() ? ":"+node.getColumn() : ":"+node.getColumn()+"("+node.getLeftColumn()+") "));
		visitAll(tokenNames, (AST) node.getFirstChild(), level+1, out);
	}

	protected void visitAll(String[] tokenNames, AST node, int level, PrintStream out) {
		while (node!=null) {
			visit(tokenNames, node, level, out); 
			node = (AST) node.getNextSibling();
		}
	}
	
	public void show(String[] tokenNames) {
		final ASTFrame frame = new ASTFrame("AST: "+getText(), this, tokenNames);
		frame.setVisible(true);
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				frame.setVisible(false); // hide the Frame

				frame.dispose();
			}
		});
	}
	
	public void showWithSiblings(String title, String[] tokenNames) {
		AST root=new AST();
		root.setText(title);
		root.setFirstChild(this);
		final ASTFrame frame = new ASTFrame(title, root, tokenNames);
		frame.setVisible(true);
		frame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				frame.setVisible(false); // hide the Frame

				frame.dispose();
			}
		});
	}	
	
	private LinkedHashMap attributes = new LinkedHashMap();
	
	public void setAttribute(Object key, Object value) {
		attributes.put(key, value);
	}

	public Object getAttribute(Object key) {
		return attributes.get(key);
	}

	public Object removeAttribute(Object key) {
		return attributes.remove(key);
	}
	
	/**
	 * Finds AST of given type in this AST and siblings.
	 * @param type
	 * @return
	 */
	public AST find(int type) {
		if (type == getType()) {
			return this;
		}
		
		AST nextSibling = (AST) getNextSibling();
		return nextSibling == null ? null : nextSibling.find(type);
	}

	/**
	 * Finds child of given type.
	 * @param type
	 */
	public AST findChild(int type) {
		AST firstChild = (AST) getFirstChild();
		return firstChild == null ? null : firstChild.find(type);
	}
}