source: proto/s2k/trunk/framework/src/toolchain/s2k/ast/Generators.java @ 3829

Last change on this file since 3829 was 3829, checked in by ksherdy, 5 years ago

Fixed bug. Added support for foreach to while translation.

File size: 11.5 KB
Line 
1/*
2 *
3 * Static factories for various node types.
4 *
5 * Add factories as needed.
6 *
7 * @author <ksherdy at sfu dot ca>
8 */
9
10package toolchain.s2k.ast;
11
12
13import s2k.ast.*;
14import s2k.inputHandler.Locator;
15import s2k.lexicalAnalyzer.*;
16import s2k.tokens.*;
17import toolchain.s2k.lang.*;
18
19public class Generators {
20       
21        public static void appendParameter(FilterDefNode funcDefNode, FilterParameterNode parameterNode) {
22                FilterParameterListNode parameterListNode = null;
23                parameterListNode = Accessors.parameterListNode(funcDefNode);
24                parameterListNode.appendChild(parameterNode);
25        }
26       
27        public static VarDeclNode makeVarDeclNode(Locator locator, ASTNode type, ASTNode lhs) {
28            Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
29            VarDeclNode localVarDecl = new VarDeclNode(assignToken);
30            localVarDecl.appendChild(type);
31            localVarDecl.appendChild(lhs);
32            return localVarDecl;
33        }
34       
35        public static VarDeclNode makeVarDeclNode(Locator locator, ASTNode type, ASTNode name, ASTNode rhs) {           
36            VarDeclNode localVarDecl = makeVarDeclNode(locator,type, name);
37                localVarDecl.appendChild(rhs);
38                return localVarDecl;
39        }
40       
41        public static AssignNode makeAssignNode(Locator locator, ASTNode lhs, ASTNode rhs) {
42                Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
43                AssignNode assign = new AssignNode(assignToken);
44                assign.appendChild(lhs);
45                assign.appendChild(rhs);
46                return assign;
47        }
48       
49    ///////////////////////////////////////////////////////////////////
50    // Function call variants
51        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {
52                IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);     
53                return Generators.makeFuncCallNode(locator, identifierNode);
54        }
55               
56        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier, ASTNode ...args) {
57                FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
58                Generators.addFuncCallArgs(node, args);
59                return node;
60        }       
61       
62        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name) {
63                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
64                return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
65        }
66       
67        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name, ASTNode ...args) {
68                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
69                FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
70                Generators.addFuncCallArgs(node, args);
71                return node;
72        }       
73       
74        private static FuncCallNode makeFuncCallNode(Locator locator, ASTNode identifier) {
75                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
76
77                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
78                FuncCallNode FuncCallNode = new FuncCallNode(token);
79                FuncCallNode.appendChild(identifier);
80                FuncCallNode.appendChild(new FuncCallArgListNode(token));               
81
82                return FuncCallNode;
83        }       
84               
85        private static void addFuncCallArgs(FuncCallNode node, ASTNode ... args) {
86            for(ASTNode child: args) {
87                Accessors.argsListNode(node).appendChild(child.deepCopy());
88            }
89            Accessors.argsListNode(node).setToken(args[0].getToken());
90        }
91       
92        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String pckage, String name) {
93                return makeCompoundIdentifierNode(locator, new String [] {pckage, name});
94        }
95       
96        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
97         * Currently, no special consideration with only one identifier in the array.
98         * (Maybe we can return a IdentifierNode directly in later versions.)
99         * @param locator               a token containing the TextLocation for this new node.
100         * @param identifiers           all identifiers
101         * @return      the new CompoundIdentifierNode
102         */
103        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String ... identifiers) {
104                Token dotToken = Generators.makeLextantToken(locator, Lextant.DOT);
105                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
106                for (String identifier : identifiers) {
107                        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
108                        CompoundIdentifierNode.appendChild(identifierNode);
109                }
110                return CompoundIdentifierNode;
111        }
112
113        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
114         * @param locator               a token containing the TextLocation for this new node.
115         * @param identifier
116         * @return      the new IdentifierNode
117         */
118        public static IdentifierNode makeIdentifierNode(Locator locator, String identifier) {
119                IdentifierToken newToken = Generators.makeIdentifierToken(locator, identifier);
120                return new IdentifierNode(newToken);
121        }
122       
123        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
124         * @param locator
125         * @param lextant
126         * @return the new LextantToken
127         */
128        public static LextantToken makeLextantToken(Locator locator, Lextant lextant) {
129                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
130        }
131
132        /** Makes a new StringConstantToken with the given string and location taken from the given locator.
133         * @param locator
134         * @param string
135         * @return the new StringConstantToken
136         */
137        public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
138                return StringConstantToken.make(LexicalType.STRING, locator.getLocation(), string);
139        }
140
141        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
142         * @param locator
143         * @param identifier
144         * @return the new IdentifierToken
145         */
146        public static IdentifierToken makeIdentifierToken(Locator locator, String identifier) {
147                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
148        }
149
150        /** Makes a new StringConstantNode with the given string and the TextLocation taken from locator.
151         * @param locator                       a locator containing the TextLocation for this new node.
152         * @param string                        string value/lexeme of new node.
153         * @return      the new StringConstantNode
154         */
155        public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
156                StringConstantToken newToken = makeStringConstantToken(locator, string);
157                return new StringConstantNode(newToken);
158        }
159
160        /** Makes a new IntegerConstantNode with a value of n and the TextLocation taken from locator.
161         * @param locator               a token containing the TextLocation for this new node.
162         * @param n                     integer value of new node.
163         * @return      the new IntegerConstantNode
164         */
165        public static IntegerConstantNode makeIntegerConstantNode(Locator locator, int n) {
166                Token newToken = IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
167                IntegerConstantNode integerConstantNode = new IntegerConstantNode(newToken);
168                integerConstantNode.setValue(n);
169            return integerConstantNode;
170        }
171       
172        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
173                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
174        }       
175       
176        public static StreamTypeNode makeStreamType(Locator locator) {
177                Token streamToken = Generators.makeLextantToken(locator, Lextant.STREAM);
178                return new StreamTypeNode(streamToken);
179        }
180       
181        public static BinaryOperatorNode makeBinaryOperatorNode(ASTNode lhs, ASTNode rhs, Token token) {
182                BinaryOperatorNode node = new BinaryOperatorNode(token);
183                node.appendChild(lhs.deepCopy());
184                node.appendChild(rhs.deepCopy());
185                return node;
186        }       
187       
188        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
189                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
190               
191                BlockStmtNode result = new BlockStmtNode(token);
192                for(ASTNode child: children) {
193                        result.appendChild(child);
194                }
195                return result;
196        }
197
198        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode condition, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
199                IfStmtNode ifStmtNode = makeIfStmtNode(locator, condition, ifBlockStmt);
200                ifStmtNode.appendChild(elseBlockStmt);
201                return ifStmtNode;
202        }       
203       
204        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode condition, BlockStmtNode blockStmt) {
205                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
206                IfStmtNode ifStmtNode = new IfStmtNode(token);
207                ifStmtNode.appendChild(condition);
208                ifStmtNode.appendChild((ASTNode)blockStmt);
209                return ifStmtNode;
210        }
211
212        public static WhileStmtNode makeWhileStmtNode(Locator locator, ASTNode condition, BlockStmtNode body) {
213                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
214                WhileStmtNode whileStmtNode = new WhileStmtNode(token);
215                whileStmtNode.appendChild(condition);
216                whileStmtNode.appendChild((ASTNode)body);
217                return whileStmtNode;
218        }
219       
220    ///////////////////////////////////////////////////////////////////
221    // Mask calls
222        public static FuncCallNode makeMaskFuncCall(Locator locator, int fieldWidth, int value) {
223                IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, value);
224                IntegerConstantNode fieldWidthNode =    Generators.makeIntegerConstantNode(locator, fieldWidth);
225
226                FuncCallNode mask = Generators.makeFuncCallNode(locator, S2KBuiltins.FLOW_MASK.packageName(), 
227                                S2KBuiltins.FLOW_MASK.name(), 
228                                arguments(fieldWidthNode, zeroConstantNode));
229                return mask;
230        }
231
232    ///////////////////////////////////////////////////////////////////
233    // Helpers
234        public static ASTNode[] arguments(ASTNode...astNodes) {
235            return astNodes;
236        }
237       
238        public static String capitalize(String str) {
239                return str.substring(0, 1).toUpperCase() + str.substring(1);
240        }
241       
242        public static String unCapitalize(String str) {
243                return str.substring(0, 1).toLowerCase() + str.substring(1);
244        }
245
246// KH: Unused (for now)
247//     
248//  public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, String packageName, String baseName, FieldWidthNode fieldWidth, ASTNode... args ) {
249//  CompoundIdentifierNode identifier = Generators.makeCompoundIdentifierNode(locator, packageName, baseName);   
250//  IdisaFuncCallNode idisaFuncCall = Generators.makeIdisaFuncCallNode(locator, identifier, fieldWidth, args);
251//  return idisaFuncCall;
252//}   
253//
254//public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, CompoundIdentifierNode identifier, FieldWidthNode fieldWidth, ASTNode... args) {
255//  IdisaFuncCallNode idisaFuncCall = new IdisaFuncCallNode(makeLextantToken(locator, Lextant.LANGLE));
256//  idisaFuncCall.appendChild(identifier);
257//  idisaFuncCall.appendChild(fieldWidth);
258// 
259// 
260//  idisaFuncCall.appendChild(new IdisaFuncCallArgListNode( Generators.makeLextantToken(locator, Lextant.LROUND)));   
261//  Generators.addIdisaFuncCallArgs(idisaFuncCall, args);
262//  return idisaFuncCall;
263//}
264//
265//private static void addIdisaFuncCallArgs(IdisaFuncCallNode node, ASTNode ...args) {
266//  if(args.length > 0) {
267//      for(ASTNode child: args) {
268//          Accessors.argListNode(node).appendChild(child.deepCopy());
269//      }
270//      Accessors.argListNode(node).setToken(args[0].getToken());
271//  }   
272//}     
273//
274//public static FieldWidthNode makeIdisaFieldWidthNode(Locator locator, int fw) {
275//  IntConstantToken fieldWidthConstant = Generators.makeIntegerConstantToken(locator, fw);
276//  FieldWidthNode fieldWidthNode = new FieldWidthNode(fieldWidthConstant);
277// 
278//  IntegerConstantNode integerConstant = Generators.makeIntegerConstantNode(locator, fw);
279//  fieldWidthNode.appendChild(integerConstant);
280// 
281//  return fieldWidthNode;
282//}     
283       
284}
Note: See TracBrowser for help on using the repository browser.