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

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

Structure Pablo to target language into phases (parse, semantic analysis, unparse, template write).

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