source: proto/pablo/src/ast/ASTNode.java @ 2710

Last change on this file since 2710 was 2710, checked in by ksherdy, 6 years ago

General refactoring.

File size: 7.1 KB
Line 
1// DO NOT MODIFY
2//
3// This code is generated by the scatter parser-generator
4// Any modifications will be lost next time scatter is run.
5//
6
7package ast;
8
9import java.util.ArrayList;
10import java.util.List;
11
12import tokens.Token;
13
14public class ASTNode {
15        public static final ASTNode NO_PARENT = null;
16        public static final int NO_TAG = -1;
17       
18        List<ASTNode>   children;
19        ASTNode parent;
20        Token token;
21        int productionTag = NO_TAG;
22
23        boolean simplifiable;
24
25       
26        public ASTNode(Token token) {
27                this.token = token;
28                this.parent = NO_PARENT;
29                this.simplifiable = false;
30                initChildren();
31        }
32        // "detached" copy constructor.  Copies all info except tree info (parent and children)
33        public ASTNode(ASTNode node) {
34                this.token = node.token;
35        }
36       
37        protected ASTNode deepCopy() {
38                ASTNode parent = new ASTNode(this.getToken());
39               
40                for(ASTNode child: this.getChildren()) {
41                        ASTNode copy = child.deepCopy();
42                        parent.appendChild(copy);
43                }
44               
45            return parent;             
46        }
47               
48        public Token getToken() {
49                return token;
50        }
51
52        public void setToken(Token token) {
53                this.token = token;
54        }
55       
56       
57////////////////////////////////////////////////////////////////////////////////////
58// attributes
59
60        public void setSimplifiable(boolean value) {
61                simplifiable = value;
62        }
63        public boolean isSimplifiable() {
64                return simplifiable;
65        }
66        public void setProductionTag(int tag) {
67                productionTag = tag;
68        }
69        public int getProductionTag() {
70                return productionTag;
71        }
72       
73       
74////////////////////////////////////////////////////////////////////////////////////
75// dealing with children and parent
76//
77// note: there is no provision as of yet for removal of children.  Be sure to update
78// the removed child's parent pointer if you do implement it.
79       
80        public ASTNode getParent() {
81                return parent;
82        }
83        protected void setParent(ASTNode parent) {
84                this.parent = parent;
85        }
86        public List<ASTNode> getChildren() {
87                return children;
88        }
89        public ASTNode child(int i) {
90                return children.get(i);
91        }
92        public ASTNode reverseChild(int i) {
93                int index = children.size() - 1 - i;
94                return children.get(index);
95        }
96        public void initChildren() {
97                children = new ArrayList<ASTNode>();
98        }
99        // adds a new child to this node (as first child) and sets its parent link.
100        public void insertChild(ASTNode child) {
101                children.add(0, child);
102                child.setParent(this);
103        }
104        // adds a new child to this node (as last child) and sets its parent link.
105        public void appendChild(ASTNode child) {
106                children.add(child);
107                child.setParent(this);
108        }
109        public int nChildren() {
110                return children.size();
111        }
112        public void replaceChild(ASTNode node, ASTNode replacement) {
113                int index = children.indexOf(node);
114                replaceChild(index, replacement);
115        }
116        private void replaceChild(int index, ASTNode replacement) {
117                ASTNode oldChild = children.remove(index);
118                oldChild.setParent(null);
119               
120                if(index == children.size()) {
121                        children.add(replacement);
122                }
123                else {
124                        children.add(index, replacement);
125                }
126                replacement.setParent(this);
127        }
128        public void removeChild(int i) {
129                ASTNode child = children.get(i);
130                children.remove(i);
131                child.setParent(null);
132        }
133        // does nothing if called on root.
134    public void updateSelf(ASTNode replacement) {
135        if(getParent() != NO_PARENT) {
136            getParent().replaceChild(this, replacement);
137        }
138    }
139        public void insertAfterChild(ASTNode node, ASTNode successor) {
140                int index = children.indexOf(node);
141                insertChildAfter(index, successor);
142                successor.setParent(this);
143    }
144    private void insertChildAfter(int index, ASTNode successor) {
145            if(index == children.size()-1) { 
146                    children.add(successor);
147            } else {
148                    children.add(index+1, successor);
149            }       
150    }   
151
152////////////////////////////////////////////////////////////////////////////////////
153// Iterable<ASTNode> pathToRoot
154
155        public Iterable<ASTNode> pathToRoot() {
156                return new ASTPathToRootIterable(this);
157        }
158        public ASTNode getRoot() {
159                ASTNode result = this;
160                for(ASTNode current: pathToRoot()) {
161                        result = current;
162                }
163                return result;
164        }
165       
166       
167////////////////////////////////////////////////////////////////////////////////////
168// toString()
169
170        public String toString() {
171                return ASTPrinter.print(this);
172        }
173       
174        /** determines if the token at this node should be printed when
175         *  pretty-printing the tree.
176         * 
177         * @return whether to print the token or not
178         */
179        public boolean suppressTokenPrinting() {
180                return false;
181        }
182       
183        /** a no-newline string that represents the attributes
184         *  at this node.  This is used when pretty-printing the tree.
185         * 
186         * @return string conveying important attributes at this node.
187         */
188        public String attributeString() {
189                return "";
190        }
191       
192       
193////////////////////////////////////////////////////////////////////////////////////
194// visitor pattern : see also ASTVisitor.java
195       
196        public <T> T accept(ASTVisitor<T> visitor) {
197                visitor.visitEnter(this);
198                List<T> results = visitChildren(visitor);
199                return visitor.visitLeave(this, results);
200        }
201        public void accept(VoidVisitor visitor) {
202                visitor.visitEnter(this);
203                visitChildren(visitor);
204                visitor.visitLeave(this);
205        }
206        // in transformers, you are required to visit the children in the visit() routine
207        // if you want to visit them at all. :)
208        public ASTNode accept(ASTTransformer transformer) {
209                return transformer.visit(this);
210        }       
211        public void accept(SimpleVisitor visitor) {
212                visitor.visit(this);
213        }
214       
215       
216        //////////////////////////////////////////////////////////////////////////
217        // call skipChildren() in visitEnter and the next call to visitChildren
218        // will return immediately.  Shared variable between all visitors.
219       
220        private boolean skipChildren = false;
221        public void skipChildren() {
222                skipChildren = true;
223        }
224        protected <T> List<T> visitChildren(ASTVisitor<T> visitor) {
225                if(skipChildren) {
226                        skipChildren = false;
227                        return null;            // could be: return new ArrayList<T>();
228                }
229               
230                List<T> childResults = new ArrayList<T>();
231                for(ASTNode child : children) {
232                        childResults.add(child.accept(visitor));
233                }
234                return childResults;
235        }
236        protected void visitChildren(VoidVisitor visitor) {
237                if(skipChildren) {
238                        skipChildren = false;
239                }
240                else {
241                        // not using "for(child: children)" because the child visit may call
242                        // replaceSelf() and thereby mess up a list iterator traversal.
243                        for(int i=0; i<children.size(); i++) {
244                                ASTNode child = child(i);
245                                child.accept(visitor);
246                        }
247                }
248        }       
249       
250        // no skipChildren() mechanism on ASTTransformer or SimpleVisitor
251        // because in them you call visitChildren in your visit() method
252        // if you want to see the children.  Just don't call it if you don't want 'em.
253        protected void visitChildren(ASTTransformer visitor) {
254                // not using "for(child: children)" because the child visit may call
255                // replaceSelf() and thereby mess up a list iterator traversal.
256                for(int i=0; i<children.size(); i++) {
257                        ASTNode child = child(i);
258                        replaceChild(i, child.accept(visitor));
259                }
260        }       
261        protected void visitChildren(SimpleVisitor visitor) {
262                // not using "for(child: children)" because the child visit may call
263                // replaceSelf() and thereby mess up a list iterator traversal.
264                for(int i=0; i<children.size(); i++) {
265                        ASTNode child = child(i);
266                        child.accept(visitor);
267                }
268        }       
269}
Note: See TracBrowser for help on using the repository browser.