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

Last change on this file since 3774 was 3774, checked in by ksherdy, 4 years ago

Updated toolchain for filter definitions.

File size: 26.1 KB
Line 
1/*
2 *
3 */
4package toolchain.b2k.ast;
5
6import b2k.ast.*;
7import b2k.tokens.*;
8import b2k.inputHandler.Locator;
9import b2k.tokens.IdentifierToken;
10import b2k.lexicalAnalyzer.Lextant;
11import b2k.lexicalAnalyzer.LexicalType;
12
13import toolchain.b2k.ast.Accessors;
14
15import toolchain.b2k.lang.B2KBuiltin;
16import toolchain.b2k.lang.idisa.IDISABuiltin;
17import toolchain.s2k.lang.carrySet.CarrySetBuiltin;
18import toolchain.s2k.transformer.visitors.S2K2B2K.Context;
19
20import static toolchain.b2k.lang.B2KBuiltin.*;
21import static toolchain.b2k.lang.idisa.IDISABuiltin.*;
22import static toolchain.b2k.lang.types.PrimitiveType.BITBLOCK_SIZE;
23
24public class Generators {
25
26        ////////////////////////////////////////////////////////////////////////////
27        // S2K2S2B Token Conversion 
28        //
29        public static final String LEXICAL_CONTEXT = "main";   
30       
31        public static b2k.tokens.Token makeToken(s2k.tokens.Token sToken) {
32               
33                b2k.tokens.Token bToken = null;
34               
35                if(sToken instanceof s2k.tokens.CharacterToken) {
36                       
37                        bToken = b2k.tokens.CharacterToken.make(LexicalType.LEXTANT, 
38                                                                                                                makeTextLocation(sToken.getLocation()), 
39                                                                                                                sToken.getLexeme());
40                       
41                } else if (sToken instanceof s2k.tokens.CommentToken) {
42
43                        bToken = b2k.tokens.CharacterToken.make(LexicalType.IGNORE, 
44                                        makeTextLocation(sToken.getLocation()), 
45                                        sToken.getLexeme());
46                       
47                } else if (sToken instanceof s2k.tokens.FloatConstantToken) {
48
49                        throw new RuntimeException(sToken.getClass().toString() + ": token class not supported.");
50                       
51                } else if (sToken instanceof s2k.tokens.IdentifierToken) {
52
53                        bToken = b2k.tokens.IdentifierToken.make(LexicalType.IDENTIFIER, 
54                                        makeTextLocation(sToken.getLocation()), 
55                                        sToken.getLexeme());                   
56                       
57                } else if (sToken instanceof s2k.tokens.IntConstantToken) {
58
59                        bToken = b2k.tokens.IntConstantToken.make(LexicalType.INTEGER_CONST, 
60                                        makeTextLocation(sToken.getLocation()), 
61                                        sToken.getLexeme());                                           
62                       
63                } else if (sToken instanceof s2k.tokens.LextantToken) {
64                       
65                        bToken = b2k.tokens.LextantToken.make(makeTextLocation(sToken.getLocation()), 
66                                                                                                        sToken.getLexeme(), 
67                                                                                                        b2k.lexicalAnalyzer.Lextant.forLexeme(sToken.getLexeme(), LEXICAL_CONTEXT));                                                                   
68                       
69                } else if (sToken instanceof s2k.tokens.NullToken) {
70
71                        bToken = b2k.tokens.NullToken.make(LexicalType.NONE, 
72                                        makeTextLocation(sToken.getLocation()));                                               
73                       
74                } else if (sToken instanceof s2k.tokens.StringConstantToken) {
75
76                        String string = sToken.getLexeme();
77                        String stringLexeme = string.substring(1,string.length()-1); // strip leading " and trailing " S2K string constant tokens                       
78                       
79                        bToken = b2k.tokens.StringConstantToken.make(LexicalType.STRING, 
80                                        makeTextLocation(sToken.getLocation()), 
81                                        stringLexeme);                                                                 
82                       
83                } else if (sToken instanceof s2k.tokens.WhitespaceToken) {
84
85                        bToken = b2k.tokens.WhitespaceToken.make(LexicalType.IGNORE, 
86                                        makeTextLocation(sToken.getLocation()), 
87                                        sToken.getLexeme());                           
88                       
89                } else {
90                       
91                        throw new RuntimeException(sToken.getClass().toString() + ": token class not supported.");
92                       
93                }
94               
95                return bToken; 
96        }
97
98        public static b2k.inputHandler.TextLocation makeTextLocation(s2k.inputHandler.TextLocation sTextLocation) {
99                b2k.inputHandler.TextLocation bTextLocation = new b2k.inputHandler.TextLocation(sTextLocation.getFilename(), 
100                                                                                                                                                                                                sTextLocation.getLineNumber(), 
101                                                                                                                                                                                                sTextLocation.getPosition());           
102                return bTextLocation;
103        }
104       
105        ////////////////////////////////////////////////////////////////////////////
106        // Kernel
107        //
108        public static KernelDefNode makeKernelDef(Locator locator,
109                        String name,
110                        InitDefNode initDefNode, 
111                        FuncDefNode doBlockFuncDefNode, 
112                        FuncDefNode doFinalBlockFuncDefNode,
113                        FuncDefNode clearFuncDefNode) {
114               
115                        LextantToken token = Generators.makeLextantToken(locator, Lextant.KERNEL); 
116                        KernelDefNode kernelDefNode = new KernelDefNode(token);
117                        b2k.ast.IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, name);           
118                       
119                        kernelDefNode.appendChild(identifierNode);
120                        kernelDefNode.appendChild(initDefNode);
121                        kernelDefNode.appendChild(doBlockFuncDefNode.deepCopy());
122                        kernelDefNode.appendChild(doFinalBlockFuncDefNode.deepCopy());
123                        kernelDefNode.appendChild(clearFuncDefNode.deepCopy());
124                       
125                        return kernelDefNode;
126        }       
127
128        public static void addFuncCallNode(KernelDefNode kernelDefNode, FuncCallNode funcCallNode) {
129                kernelDefNode.appendChild(funcCallNode);
130        }       
131
132    public static InitDefNode makeInitDefNode (Locator locator) {
133        InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
134        return stateDef;
135    }
136       
137        public static InitDefNode makeInitDefNode (Locator locator, KernelPropertyNode ...stateParameters) {
138                InitDefNode stateDef = new InitDefNode(Generators.makeLextantToken(locator, Lextant.LCURLY));
139                for(KernelPropertyNode stateParameter : stateParameters) {
140                    stateDef.appendChild(stateParameter);
141                }
142                return stateDef;
143        }
144
145        public static KernelPropertyNode makeKernelPropertyNode (IdentifierNode propertyName, PropertyValueNode propertyValue) {
146            KernelPropertyNode stateParameter = new KernelPropertyNode(propertyName.getToken());
147            stateParameter.appendChild(propertyName);
148            stateParameter.appendChild(propertyValue);
149            return stateParameter;
150        }
151   
152        public static PropertyValueNode makePropertyValueNode(Locator locator, Integer... values) {
153            PropertyValueNode stateValue = new PropertyValueNode(Generators.makeLextantToken(locator, Lextant.LSQUARE));
154        for(Integer i : values) {
155            IntegerConstantNode n = Generators.makeIntegerConstantNode(locator, i);
156            stateValue.appendChild(n);
157        }           
158            return stateValue;
159        }
160       
161        public static PropertyValueNode makePropertyValueNode(Locator locator, Integer value) {
162                Integer [] values = new Integer[1];
163                values[0] = value;
164                return Generators.makePropertyValueNode(locator, values);
165        }       
166
167        //////////////////////////////////////////////////////////////////////////
168        // IDISA function calls
169        //
170        public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, IDISABuiltin builtin, int fw, ASTNode... args ) {
171            String packageName = builtin.packageName();
172            String baseName = builtin.baseName();
173            FieldWidthNode fieldWidth = Generators.makeIdisaFieldWidthNode(locator, fw);
174            return makeIdisaFuncCallNode(locator, packageName, baseName, fieldWidth, args);
175    }
176       
177        public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, IDISABuiltin builtin,  FieldWidthNode fieldWidth, ASTNode... args ) {
178            String packageName = builtin.packageName();
179            String baseName = builtin.baseName();
180            return makeIdisaFuncCallNode(locator, packageName, baseName, fieldWidth, args);
181        }
182       
183    public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, String packageName, String baseName, FieldWidthNode fieldWidth, ASTNode... args ) {
184        CompoundIdentifierNode identifier = Generators.makeCompoundIdentifierNode(locator, packageName, baseName);   
185        IdisaFuncCallNode idisaFuncCall = Generators.makeIdisaFuncCallNode(locator, identifier, fieldWidth, args);
186        return idisaFuncCall;
187    }   
188   
189    public static IdisaFuncCallNode makeIdisaFuncCallNode(Locator locator, CompoundIdentifierNode identifier, FieldWidthNode fieldWidth, ASTNode... args) {
190        IdisaFuncCallNode idisaFuncCall = new IdisaFuncCallNode(makeLextantToken(locator, Lextant.LANGLE));
191        idisaFuncCall.appendChild(identifier);
192        idisaFuncCall.appendChild(fieldWidth);
193       
194       
195        idisaFuncCall.appendChild(new IdisaFuncCallArgListNode( Generators.makeLextantToken(locator, Lextant.LROUND)));   
196        Generators.addIdisaFuncCallArgs(idisaFuncCall, args);
197        return idisaFuncCall;
198    }
199
200    private static void addIdisaFuncCallArgs(IdisaFuncCallNode node, ASTNode ...args) {
201        if(args.length > 0) {
202            for(ASTNode child: args) {
203                Accessors.idisaFuncCallArgListNode(node).appendChild(child.deepCopy());
204            }
205            Accessors.idisaFuncCallArgListNode(node).setToken(args[0].getToken());
206        }   
207    }
208       
209    public static FieldWidthNode makeIdisaFieldWidthNode(Locator locator, int fw) {
210        IntConstantToken fieldWidthConstant = Generators.makeIntegerConstantToken(locator, fw);
211        FieldWidthNode fieldWidthNode = new FieldWidthNode(fieldWidthConstant);
212       
213        IntegerConstantNode integerConstant = Generators.makeIntegerConstantNode(locator, fw);
214        fieldWidthNode.appendChild(integerConstant);
215       
216        return fieldWidthNode;
217    }
218   
219    //////////////////////////////////////////////////////////////////////////
220    // Function definitions
221    //
222    public static FuncDefNode makeFuncDefNode(Locator locator, String identifier) {
223       
224        LextantToken funcToken = Generators.makeLextantToken(locator, Lextant.FUNCTION);
225        FuncDefNode funcDef = new FuncDefNode(funcToken);
226        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
227        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
228        ParameterListNode parameterListNode = Generators.makeParameterListNode(parameterListToken);
229        BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(locator);
230       
231        funcDef.appendChild(identifierNode);
232        funcDef.appendChild(parameterListNode);
233        funcDef.appendChild(blockStmtNode);
234               
235        return funcDef;
236    }
237   
238    public static ParameterListNode makeParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
239        ParameterListNode parameterListNode = new ParameterListNode(token);
240        return parameterListNode;
241    }
242   
243    public static ParameterNode makeParameterNode(Locator locator) {
244        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
245        ParameterNode parameterNode = new ParameterNode(parameterListToken);
246        return parameterNode;
247    }
248
249    public static ParameterModeNode makeParameterModeNode(Token token) {
250        ParameterModeNode parameterModeNode = new ParameterModeNode(token);
251        return parameterModeNode;
252    }   
253   
254    public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
255       
256        ParameterListNode parameterListNode = null;
257       
258        if(!Accessors.hasParameters(funcDefNode)) {
259            parameterListNode = new ParameterListNode(parameterNode.getToken()); 
260            funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
261        } else {
262            parameterListNode = Accessors.parameterListNode(funcDefNode);
263        }
264       
265        parameterListNode.appendChild(parameterNode);
266       
267    }
268   
269    //////////////////////////////////////////////////////////////////////////
270    // Function calls     
271    //
272    public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {       
273        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier); 
274        return Generators.makeFuncCallNode(locator, identifierNode);
275    }
276       
277        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier, ASTNode ...args) {
278                FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
279                Generators.addFuncCallArgs(node, args);
280                return node;
281        }       
282       
283        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name) {
284                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
285                return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
286        }
287       
288        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name, ASTNode ...args ) {
289                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
290                FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
291                Generators.addFuncCallArgs(node, args);
292                return node;
293        }       
294
295        private static FuncCallNode makeFuncCallNode(Locator locator, ASTNode identifier) {
296                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
297                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
298                FuncCallNode FuncCallNode = new FuncCallNode(token);
299                FuncCallNode.appendChild(identifier);
300                FuncCallNode.appendChild(new FuncCallArgListNode(token));               
301                return FuncCallNode;
302        }       
303               
304        private static void addFuncCallArgs(FuncCallNode node, ASTNode ...args) {
305                if(args.length > 0) {
306                        for(ASTNode child: args) {
307                                Accessors.funcCallArgsListNode(node).appendChild(child.deepCopy());
308                        }
309                        Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
310                }       
311        }       
312       
313    //////////////////////////////////////////////////////////////////////////
314    // Assignment
315    // 
316        public static AssignNode makeAssignNode(Locator locator, ASTNode lhs, ASTNode rhs) {
317               
318            LextantToken token = Generators.makeLextantToken(locator, Lextant.ASSIGN);
319                AssignNode assignNode = new AssignNode(token);
320
321                assignNode.appendChild(lhs.deepCopy());
322                assignNode.appendChild(rhs.deepCopy());
323               
324                return assignNode;
325        }
326
327    //////////////////////////////////////////////////////////////////////////
328    // BlockStmt
329    // 
330        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
331            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
332
333            BlockStmtNode result = new BlockStmtNode(token);
334            for(ASTNode child: children) {
335                result.appendChild(child);
336            }
337            return result;
338        }
339
340    //////////////////////////////////////////////////////////////////////////
341    // IfStmt
342    // 
343        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
344            IfStmtNode ifStmtNode = makeIfStmtNode(locator, expression, ifBlockStmt);
345            ifStmtNode.appendChild(elseBlockStmt);
346            return ifStmtNode;
347        }       
348       
349        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode blockStmt) {
350            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
351            IfStmtNode ifStmtNode = new IfStmtNode(token);
352            ifStmtNode.appendChild(expression);
353            ifStmtNode.appendChild((ASTNode)blockStmt);
354            return ifStmtNode;
355        }       
356
357        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
358         * Currently, no special consideration with only one identifier in the array.
359         * (Maybe we can return a IdentifierNode directly in later versions.)
360         * @param locator               a token containing the TextLocation for this new node.
361         * @param identifiers           all identifiers
362         * @return      the new CompoundIdentifierNode
363         */
364        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String... identifiers) {
365                Token dotToken = Generators.makeLextantToken(locator, Lextant.DOT);
366                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
367                for (String identifier : identifiers) {
368                        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
369                        CompoundIdentifierNode.appendChild(identifierNode);
370                }
371                return CompoundIdentifierNode;
372        }
373
374        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
375         * @param locator
376         * @param lextant
377         * @return the new LextantToken
378         */
379        public static LextantToken makeLextantToken(Locator locator, Lextant lextant) {
380                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
381        }       
382       
383        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
384         * @param locator               a token containing the TextLocation for this new node.
385         * @param identifier
386         * @return      the new IdentifierNode
387         */
388        public static IdentifierNode makeIdentifierNode(Locator locator, String identifier) {
389                IdentifierToken newToken = makeIdentifierToken(locator, identifier);
390                return new IdentifierNode(newToken);
391        }       
392               
393        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
394         * @param locator
395         * @param identifier
396         * @return the new IdentifierToken
397         */
398        public static IdentifierToken makeIdentifierToken(Locator locator, String identifier) {
399                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
400        }
401        public static IntegerConstantNode makeIntegerConstantNode(Locator locator, int n) {
402                IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(locator, n));
403                integerConstantNode.setValue(n);
404            return integerConstantNode;
405        }       
406        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
407                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
408        }                       
409
410        public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
411        StringConstantToken newToken = makeStringConstantToken(locator, string);
412        return new StringConstantNode(newToken);
413    }
414   
415        public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
416        return StringConstantToken.make(LexicalType.STRING, locator, string);
417    }
418   
419    ///////////////////////////////////////////////////////////////////
420    // Type nodes
421    // 
422    public static VoidTypeNode makeVoidTypeNode(Locator locator) {
423            Token voidTypeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.VOID);
424            return new VoidTypeNode(voidTypeToken);
425    }
426               
427    ///////////////////////////////////////////////////////////////////
428    // SIMD EOF_mask calls
429    //
430    public static IdisaFuncCallNode makeExprAndEofMaskCall(Locator locator, ASTNode expr) {
431        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
432        return Generators.makeIdisaFuncCallNode(locator, SIMD_AND, BITBLOCK_SIZE, arguments(expr, eofMask));
433    }
434   
435    public static IdisaFuncCallNode makeExprOrNotEofMaskCall(Locator locator, ASTNode expr) {
436        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
437        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, arguments(expr, 
438                Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, arguments(eofMask))));
439    }   
440   
441    public static IdisaFuncCallNode makeExprAndCEofMaskCall(Locator locator, ASTNode expr) {
442        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
443        return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(expr, eofMask));
444    }
445   
446    public static IdisaFuncCallNode makeEofMaskAndCExprCall(Locator locator, ASTNode expr) {
447        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
448        return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(eofMask, expr));
449    }
450   
451    public static ParameterNode makeEofMaskParameter(Locator locator) {
452
453        Token parameterNodeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.BITBLOCK);
454        ParameterNode parameterNode = new ParameterNode(parameterNodeToken); 
455
456        Token bitBlockTypeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.BITBLOCK);
457        BitBlockTypeNode streamTypeNode = new BitBlockTypeNode(bitBlockTypeToken);
458        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, B2KBuiltin.EOF_MASK.b2kName()); // encoder.getName(S2KBuiltin.EOF_MASK));
459
460        parameterNode.appendChild(streamTypeNode);
461        parameterNode.appendChild(identifierNode);
462
463        return parameterNode;
464    }   
465   
466    ///////////////////////////////////////////////////////////////////
467    // Carry set macro calls   
468    public static ASTNode makeGetCarryCall(Locator locator, Context context, int carry1Position) {
469        return Generators.makeFuncCallNode(
470                locator, 
471                context.getCarrySetIdentifier(), 
472                context.getCode(CarrySetBuiltin.GETCARRY),
473                Generators.makeIntegerConstantNode(locator, carry1Position));
474    }
475
476    public static ASTNode makePending64Call(Locator locator, Context context, int carry1Position) {
477        return Generators.makeFuncCallNode(
478                locator, 
479                context.getCarrySetIdentifier(), 
480                context.getCode(CarrySetBuiltin.PENDING64),
481                Generators.makeIntegerConstantNode(locator, carry1Position));
482    }   
483   
484    public static FuncCallNode makeCarryFlipCall(Locator locator, Context context, int carry1Position) {
485       
486        IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, carry1Position);
487       
488        FuncCallNode carryFlipFuncCall = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
489                                                                        context.getCode(CarrySetBuiltin.CARRYFLIP),
490                                                                        Generators.arguments(indexNode));
491       
492        FuncCallNode setCarryFuncCall  = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
493                                                                        context.getCode(CarrySetBuiltin.SETCARRY),
494                                                                        Generators.arguments(carryFlipFuncCall,
495                                                                        indexNode)); 
496        return setCarryFuncCall;
497    } 
498   
499    public static IdisaFuncCallNode makeBitwiseOrCarryTest(ASTNode condition,
500                                                            Context context,
501                                                            int carry1Position,
502                                                            int carry1Count) {
503       
504        Locator locator = condition.getLocation();
505
506        ASTNode carry1PositionNode  = Generators.leaf(carry1Position, locator);
507        ASTNode carry1CountNode     = Generators.leaf(carry1Count, locator);
508        ASTNode carryRange          = Generators.makeFuncCallNode(  locator, 
509                                                                    context.getCarrySetIdentifier(),
510                                                                    context.getCode(CarrySetBuiltin.CARRYRANGE),
511                                                                    Generators.arguments(carry1PositionNode, carry1CountNode));
512       
513        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, Generators.arguments(condition, carryRange));
514    }   
515   
516    public static FuncCallNode makeCarryDeclareCall(Locator locator, Context context, int carry1Count, int carryNCount) {
517       
518        IdentifierNode carrySetIdentifier       =   Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier()); 
519        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
520        IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
521     
522        FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(locator,
523                                                                                context.getCode(CarrySetBuiltin.CARRYDECLARE),
524                                                                                Generators.arguments(carrySetIdentifier,
525                                                                                                     carry1CountNode, 
526                                                                                                     carryNCountNode));       
527        return carryDeclareFuncCall;
528    }
529 
530    public static FuncCallNode makeCarryAdjustmentCall(Locator locator, Context context, int carry1Count) {
531        IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, locator);
532
533        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
534                                        locator, 
535                                        context.getCarrySetIdentifier(),                                   
536                                        context.getCode(CarrySetBuiltin.CARRYADJUST),
537                                        Generators.arguments(carry1CountNode));
538        return carryAdjustment;
539    }   
540
541    public static FuncCallNode makeCarryDequeueEnqueueCall(Locator locator, Context context, int carry1Position, int carry1Count) {
542       
543        IntegerConstantNode carry1PositionNode  =   Generators.makeIntegerConstantNode(locator, carry1Position);
544        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
545       
546        FuncCallNode carryDequeueEnqueue = Generators.makeFuncCallNode(
547                                            locator, 
548                                            context.getCarrySetIdentifier(),                                   
549                                            context.getCode(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
550                                            Generators.arguments(carry1PositionNode, carry1CountNode));
551        return carryDequeueEnqueue;
552    } 
553   
554    public static FuncCallNode makeLocalCarryCombineCall(Locator locator, Context context, Context localContext, int carry1Position,
555            int carry1Count) {
556
557        IdentifierNode carrySetIdentifierNode       = Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier());
558        IdentifierNode localCarrySetIdentifierNode  = Generators.makeIdentifierNode(locator, localContext.getCarrySetIdentifier());
559        ASTNode carry1PositionNode                  = leaf(carry1Position, locator);
560        ASTNode carry1CountNode                     = leaf(carry1Count, locator);
561
562        return Generators.makeFuncCallNode(
563                locator,
564                localContext.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
565                                        carrySetIdentifierNode,
566                                        localCarrySetIdentifierNode,
567                                        carry1PositionNode,
568                                        carry1CountNode);
569
570    }
571   
572    public static IntegerConstantNode leaf(int n, Locator locator) {
573        return Generators.makeIntegerConstantNode(locator, n);
574    } 
575   
576    ///////////////////////////////////////////////////////////////////
577    // helpers
578    public static ASTNode[] arguments(ASTNode...astNodes) {
579        return astNodes;
580    }
581
582}
Note: See TracBrowser for help on using the repository browser.