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

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

General refactoring.

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