source: proto/pablo/src/compiler/ast/Generators.java @ 2702

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

General refactoring (variable names). Added final block XFormer. Move final block operations atEOF/inFile out of carry intro transformer to final block transformer.

File size: 8.5 KB
Line 
1package compiler.ast;
2
3import ast.*;
4import java.util.ArrayList;
5import java.util.List;
6
7import lexicalAnalyzer.LexicalType;
8import lexicalAnalyzer.Lextant;
9import tokens.IdentifierToken;
10import tokens.IntConstantToken;
11import tokens.LextantToken;
12import tokens.StringConstantToken;
13import tokens.Token;
14
15public class Generators {
16
17       
18        ////////////////////////////////////////////////////////////////////////////
19        // Static factories for various nodes
20        //
21        ////////////////////////////////////////////////////////////////////////////
22
23        /** Makes a new FuncCallNode with a Func identifier string and the TextLocation taken from token.
24         * @param identifier
25         * @param locationToken
26         * @return FuncCallNode
27         */
28        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken) {
29                IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);       
30                return Generators.makeFuncCallNode(identifierNode, locationToken);
31        }
32
33        /** Makes a new compound FuncCallNode with a array of identifiers string and the TextLocation taken from token.
34         * @param identifiers - a compound identifier a.b()     
35         * @param locationToken
36         * @return
37         */
38        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken) {
39               
40                CompoundIdentifierNode identifierNode = Generators.makeCompoundIdentifierNode(identifiers, locationToken);
41                return Generators.makeFuncCallNode(identifierNode, locationToken);
42        }
43
44        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, ASTNode[] args) {
45               
46                FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
47                Generators.addFuncCallArgs(node, args);
48                return node;
49        }       
50
51        public static FuncCallNode makeFuncCallNode(String identifier, Token locationToken, List<ASTNode> args) {
52               
53                FuncCallNode node = Generators.makeFuncCallNode(identifier, locationToken);
54                Generators.addFuncCallsArgs(node, args);
55                return node;
56        }       
57       
58        private static void addFuncCallArgs(FuncCallNode node, ASTNode[] args) {
59                if(args.length > 0) {
60                        for(ASTNode child: args) {
61                                Accessors.funcCallArgsListNode(node).appendChild(child);
62                        }
63                        Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
64                }       
65        }
66
67        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken, ASTNode[] args) {
68       
69                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
70                List<ASTNode> list = new ArrayList<ASTNode>();
71                for(ASTNode arg: args) {
72                        list.add(arg);
73                }
74                Generators.addFuncCallsArgs(node, list);
75                return node;
76        }
77
78        public static FuncCallNode makeFuncCallNode(String[] identifiers, Token locationToken,  List<ASTNode> args) {
79               
80                FuncCallNode node = Generators.makeFuncCallNode(identifiers, locationToken);
81                Generators.addFuncCallsArgs(node, args);
82                return node;
83        }       
84       
85        private static void addFuncCallsArgs(FuncCallNode node, List<ASTNode> args) {
86               
87                if(args.size() > 0) {
88                        for(ASTNode child: args) {
89                                Accessors.funcCallArgsListNode(node).appendChild(child);
90                        }
91                        Accessors.funcCallArgsListNode(node).setToken(args.get(0).getToken());
92                }               
93        }
94       
95        private static FuncCallNode makeFuncCallNode(ASTNode identifier, Token locationToken) {
96                assert identifier instanceof IdentifierNode || identifier instanceof CompoundIdentifierNode;
97
98                LextantToken token = Generators.makeLextantToken(Lextant.LROUND, locationToken);
99                FuncCallNode FuncCallNode = new FuncCallNode(token);
100                FuncCallNode.appendChild(identifier);
101                FuncCallNode.appendChild(new FuncCallArgListNode(locationToken));
102
103                return FuncCallNode;
104        }       
105               
106        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from token.
107         * Currently, no special consideration with only one identifier in the array.
108         * (Maybe we can return a IdentifierNode directly in later versions.)
109         * @param identifiers           all identifiers
110         * @param locationToken         a token containing the TextLocation for this new node.
111         * @return      the new CompoundIdentifierNode
112         */
113        public static CompoundIdentifierNode makeCompoundIdentifierNode(String[] identifiers, Token locationToken) {
114                Token dotToken = Generators.makeLextantToken(Lextant.DOT, locationToken);
115                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
116                for (String identifier : identifiers) {
117                        IdentifierNode identifierNode = Generators.makeIdentifierNode(identifier, locationToken);
118                        CompoundIdentifierNode.appendChild(identifierNode);
119                }
120                return CompoundIdentifierNode;
121        }
122
123        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from token.
124         * @param identifier
125         * @param locationToken         a token containing the TextLocation for this new node.
126         * @return      the new IdentifierNode
127         */
128        public static IdentifierNode makeIdentifierNode(String identifier, Token locationToken) {
129                IdentifierToken newToken = Generators.makeIdentifierToken(identifier, locationToken);
130                return new IdentifierNode(newToken);
131        }
132
133        ////////////////////////////////////////////////////////////////////////////
134        // Static factories for various tokens
135        //
136        ////////////////////////////////////////////////////////////////////////////
137       
138        /** Makes a new LextantToken with the given lextant and location taken from the given token.
139         * @param lextant
140         * @param locationToken
141         * @return the new LextantToken
142         */
143        public static LextantToken makeLextantToken(Lextant lextant, Token locationToken) {
144                return LextantToken.make(locationToken.getLocation(), lextant.getPrimaryLexeme(), lextant);
145        }
146
147        /** Makes a new StringConstantToken with the given string and location taken from the given token.
148         * @param string
149         * @param locationToken
150         * @return the new StringConstantToken
151         */
152        public static StringConstantToken makeStringConstantToken(String string, Token locationToken) {
153                return StringConstantToken.make(LexicalType.STRING, locationToken.getLocation(), string);
154        }
155
156        /** Makes a new IdentifierToken with the given identifier and location taken from the given token.
157         * @param identifier
158         * @param locationToken
159         * @return the new IdentifierToken
160         */
161        public static IdentifierToken makeIdentifierToken(String identifier, Token locationToken) {
162                return IdentifierToken.make(LexicalType.IDENTIFIER, locationToken.getLocation(), identifier);
163        }
164
165        /** Makes a new StringConstantNode with the given string and the TextLocation taken from token.
166         * @param string                        string value/lexeme of new node.
167         * @param locationToken         a token containing the TextLocation for this new node.
168         * @return      the new StringConstantNode
169         */
170        public static StringConstantNode makeStringConstantNode(String string, Token locationToken) {
171                StringConstantToken newToken = makeStringConstantToken(string, locationToken);
172                return new StringConstantNode(newToken);
173        }
174
175        /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from token.
176         * @param n                     integer value of new node.
177         * @param locationToken         a token containing the TextLocation for this new node.
178         * @return      the new IntegerConstantNode
179         */
180        public static IntegerConstantNode makeIntegerConstantNode(int n, Token locationToken) {
181                Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locationToken.getLocation(), n);
182                IntegerConstantNode integerConstantNode = new IntegerConstantNode(newToken);
183                integerConstantNode.setValue(n);
184            return integerConstantNode;
185        }
186
187        /** Makes a new BinaryOperatorNode
188         * @param lhs                   left hand side
189         * @param rhs                   right hand side
190         * @param locationToken         a token containing the operation and TextLocation for this new node.
191         * @return      the new IntegerConstantNode
192         */
193        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token tokenLocation) {
194                BinaryOperatorNode node = new BinaryOperatorNode(tokenLocation);
195                node.appendChild(lhs);
196                node.appendChild(rhs);
197                return node;
198        }       
199       
200        public static BlockStmtNode makeBlockStmtNode(Token tokenLocation) {
201                LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, tokenLocation);
202                return new BlockStmtNode(token);
203        }
204       
205        public static IfStmtNode makeIfStmtNode(Token tokenLocation, ASTNode expression, BlockStmtNode blockStmt) {
206                LextantToken token = Generators.makeLextantToken(Lextant.LCURLY, tokenLocation);
207                IfStmtNode ifStmtNode = new IfStmtNode(token);
208                ifStmtNode.appendChild(expression);
209                ifStmtNode.appendChild((ASTNode)blockStmt);
210                return ifStmtNode;
211        }
212       
213        // Helper
214        public static String capitalize(String str) {
215                return str.substring(0, 1).toUpperCase() + str.substring(1);
216        }
217       
218        public static String unCapitalize(String str) {
219                return str.substring(0, 1).toLowerCase() + str.substring(1);
220        }
221}
Note: See TracBrowser for help on using the repository browser.