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

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

Fixed bug in S2K2B2K transformer.

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   
223    public static FuncDefNode makeFuncDefNode(Locator locator, String identifier) {
224       
225        LextantToken funcToken = Generators.makeLextantToken(locator, Lextant.FUNCTION);
226        FuncDefNode funcDef = new FuncDefNode(funcToken);
227        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
228        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
229        ParameterListNode parameterListNode = Generators.makeParameterListNode(parameterListToken);
230        BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(locator);
231       
232        funcDef.appendChild(identifierNode);
233        funcDef.appendChild(parameterListNode);
234        funcDef.appendChild(blockStmtNode);
235               
236        return funcDef;
237    }
238   
239    public static ParameterListNode makeParameterListNode(Token token) { // KH: Token parameter vs. Locator ?
240        ParameterListNode parameterListNode = new ParameterListNode(token);
241        return parameterListNode;
242    }
243   
244    public static ParameterNode makeParameterNode(Locator locator) {
245        LextantToken parameterListToken = Generators.makeLextantToken(locator, Lextant.LROUND);
246        ParameterNode parameterNode = new ParameterNode(parameterListToken);
247        return parameterNode;
248    }
249
250    public static ParameterModeNode makeParameterModeNode(Token token) {
251        ParameterModeNode parameterModeNode = new ParameterModeNode(token);
252        return parameterModeNode;
253    }   
254   
255    public static void appendParameter(FuncDefNode funcDefNode, ParameterNode parameterNode) {
256       
257        ParameterListNode parameterListNode = null;
258       
259        if(!Accessors.hasParameters(funcDefNode)) {
260            parameterListNode = new ParameterListNode(parameterNode.getToken()); 
261            funcDefNode.insertAfterChild(Accessors.funcIdentifier(funcDefNode), parameterListNode);
262        } else {
263            parameterListNode = Accessors.parameterListNode(funcDefNode);
264        }
265       
266        parameterListNode.appendChild(parameterNode);
267       
268    }
269   
270    //////////////////////////////////////////////////////////////////////////
271    // Function calls     
272    //
273    public static FuncCallNode makeFuncCallNode(Locator locator, String identifier) {       
274        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier); 
275        return Generators.makeFuncCallNode(locator, identifierNode);
276    }
277       
278        public static FuncCallNode makeFuncCallNode(Locator locator, String identifier, ASTNode ...args) {
279                FuncCallNode node = Generators.makeFuncCallNode(locator, identifier);
280                Generators.addFuncCallArgs(node, args);
281                return node;
282        }       
283       
284        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name) {
285                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
286                return Generators.makeFuncCallNode(locator, compoundIdentifierNode);
287        }
288       
289        public static FuncCallNode makeFuncCallNode(Locator locator, String pckage, String name, ASTNode ...args ) {
290                CompoundIdentifierNode compoundIdentifierNode = Generators.makeCompoundIdentifierNode(locator, pckage, name);   
291                FuncCallNode node = Generators.makeFuncCallNode(locator, compoundIdentifierNode);
292                Generators.addFuncCallArgs(node, args);
293                return node;
294        }       
295
296        private static FuncCallNode makeFuncCallNode(Locator locator, ASTNode identifier) {
297                assert ((identifier instanceof IdentifierNode) || (identifier instanceof CompoundIdentifierNode));
298                LextantToken token = Generators.makeLextantToken(locator, Lextant.LROUND);
299                FuncCallNode FuncCallNode = new FuncCallNode(token);
300                FuncCallNode.appendChild(identifier);
301                FuncCallNode.appendChild(new FuncCallArgListNode(token));               
302                return FuncCallNode;
303        }       
304               
305        private static void addFuncCallArgs(FuncCallNode node, ASTNode ...args) {
306                if(args.length > 0) {
307                        for(ASTNode child: args) {
308                                Accessors.funcCallArgsListNode(node).appendChild(child.deepCopy());
309                        }
310                        Accessors.funcCallArgsListNode(node).setToken(args[0].getToken());
311                }       
312        }       
313       
314    //////////////////////////////////////////////////////////////////////////
315    // Assignment
316    // 
317        public static AssignNode makeAssignNode(Locator locator, ASTNode lhs, ASTNode rhs) {
318               
319            LextantToken token = Generators.makeLextantToken(locator, Lextant.ASSIGN);
320                AssignNode assignNode = new AssignNode(token);
321
322                assignNode.appendChild(lhs.deepCopy());
323                assignNode.appendChild(rhs.deepCopy());
324               
325                return assignNode;
326        }
327
328    //////////////////////////////////////////////////////////////////////////
329    // BlockStmt
330    // 
331        public static BlockStmtNode makeBlockStmtNode(Locator locator, ASTNode ...children) {
332            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
333
334            BlockStmtNode result = new BlockStmtNode(token);
335            for(ASTNode child: children) {
336                result.appendChild(child);
337            }
338            return result;
339        }
340
341    //////////////////////////////////////////////////////////////////////////
342    // IfStmt
343    // 
344        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
345            IfStmtNode ifStmtNode = makeIfStmtNode(locator, expression, ifBlockStmt);
346            ifStmtNode.appendChild(elseBlockStmt);
347            return ifStmtNode;
348        }       
349       
350        public static IfStmtNode makeIfStmtNode(Locator locator, ASTNode expression, BlockStmtNode blockStmt) {
351            LextantToken token = Generators.makeLextantToken(locator, Lextant.LCURLY);
352            IfStmtNode ifStmtNode = new IfStmtNode(token);
353            ifStmtNode.appendChild(expression);
354            ifStmtNode.appendChild((ASTNode)blockStmt);
355            return ifStmtNode;
356        }       
357
358        /** Makes a new CompoundIdentifierNode with an array of identifier strings and and the TextLocation taken from locator.
359         * Currently, no special consideration with only one identifier in the array.
360         * (Maybe we can return a IdentifierNode directly in later versions.)
361         * @param locator               a token containing the TextLocation for this new node.
362         * @param identifiers           all identifiers
363         * @return      the new CompoundIdentifierNode
364         */
365        public static CompoundIdentifierNode makeCompoundIdentifierNode(Locator locator, String... identifiers) {
366                Token dotToken = Generators.makeLextantToken(locator, Lextant.DOT);
367                CompoundIdentifierNode CompoundIdentifierNode = new CompoundIdentifierNode(dotToken);
368                for (String identifier : identifiers) {
369                        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, identifier);
370                        CompoundIdentifierNode.appendChild(identifierNode);
371                }
372                return CompoundIdentifierNode;
373        }
374
375        /** Makes a new LextantToken with the given lextant and location taken from the given locator.
376         * @param locator
377         * @param lextant
378         * @return the new LextantToken
379         */
380        public static LextantToken makeLextantToken(Locator locator, Lextant lextant) {
381                return LextantToken.make(locator.getLocation(), lextant.getPrimaryLexeme(), lextant);
382        }       
383       
384        /** Makes a new IdentifierNode with a identifier string and the TextLocation taken from locator.
385         * @param locator               a token containing the TextLocation for this new node.
386         * @param identifier
387         * @return      the new IdentifierNode
388         */
389        public static IdentifierNode makeIdentifierNode(Locator locator, String identifier) {
390                IdentifierToken newToken = makeIdentifierToken(locator, identifier);
391                return new IdentifierNode(newToken);
392        }       
393               
394        /** Makes a new IdentifierToken with the given identifier and location taken from the given locator.
395         * @param locator
396         * @param identifier
397         * @return the new IdentifierToken
398         */
399        public static IdentifierToken makeIdentifierToken(Locator locator, String identifier) {
400                return IdentifierToken.make(LexicalType.IDENTIFIER, locator.getLocation(), identifier);
401        }
402        public static IntegerConstantNode makeIntegerConstantNode(Locator locator, int n) {
403                IntegerConstantNode integerConstantNode = new IntegerConstantNode(makeIntegerConstantToken(locator, n));
404                integerConstantNode.setValue(n);
405            return integerConstantNode;
406        }       
407        public static IntConstantToken makeIntegerConstantToken(Locator locator,  int n) {
408                return (IntConstantToken) IntConstantToken.makeArtifical(LexicalType.INTEGER_CONST, locator.getLocation(), n);
409        }                       
410
411        public static StringConstantNode makeStringConstantNode(Locator locator, String string) {
412        StringConstantToken newToken = makeStringConstantToken(locator, string);
413        return new StringConstantNode(newToken);
414    }
415   
416        public static StringConstantToken makeStringConstantToken(Locator locator, String string) {
417        return StringConstantToken.make(LexicalType.STRING, locator, string);
418    }
419   
420    ///////////////////////////////////////////////////////////////////
421    // Type nodes
422    // 
423    public static VoidTypeNode makeVoidTypeNode(Locator locator) {
424            Token voidTypeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.VOID);
425            return new VoidTypeNode(voidTypeToken);
426    }
427               
428    ///////////////////////////////////////////////////////////////////
429    // SIMD EOF_mask calls
430    //
431    public static IdisaFuncCallNode makeExprAndEofMaskCall(Locator locator, ASTNode expr) {
432        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
433        return Generators.makeIdisaFuncCallNode(locator, SIMD_AND, BITBLOCK_SIZE, arguments(expr, eofMask));
434    }
435   
436    public static IdisaFuncCallNode makeExprOrNotEofMaskCall(Locator locator, ASTNode expr) {
437        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
438        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, arguments(expr, 
439                Generators.makeIdisaFuncCallNode(locator, SIMD_NOT, BITBLOCK_SIZE, arguments(eofMask))));
440    }   
441   
442    public static IdisaFuncCallNode makeExprAndCEofMaskCall(Locator locator, ASTNode expr) {
443        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
444        return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(expr, eofMask));
445    }
446   
447    public static IdisaFuncCallNode makeEofMaskAndCExprCall(Locator locator, ASTNode expr) {
448        ASTNode eofMask = makeIdentifierNode(locator, EOF_MASK.b2kName());
449        return Generators.makeIdisaFuncCallNode(locator, SIMD_ANDC, BITBLOCK_SIZE, arguments(eofMask, expr));
450    }
451   
452    public static ParameterNode makeEofMaskParameter(Locator locator) {
453
454        Token parameterNodeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.BITBLOCK);
455        ParameterNode parameterNode = new ParameterNode(parameterNodeToken); 
456
457        Token bitBlockTypeToken = Generators.makeLextantToken(locator, b2k.lexicalAnalyzer.Lextant.BITBLOCK);
458        BitBlockTypeNode streamTypeNode = new BitBlockTypeNode(bitBlockTypeToken);
459        IdentifierNode identifierNode = Generators.makeIdentifierNode(locator, B2KBuiltin.EOF_MASK.b2kName()); // encoder.getName(S2KBuiltin.EOF_MASK));
460
461        parameterNode.appendChild(streamTypeNode);
462        parameterNode.appendChild(identifierNode);
463
464        return parameterNode;
465    }   
466   
467    ///////////////////////////////////////////////////////////////////
468    // Carry set macro calls   
469    public static ASTNode makeGetCarryCall(Locator locator, Context context, int carry1Position) {
470        return Generators.makeFuncCallNode(
471                locator, 
472                context.getCarrySetIdentifier(), 
473                context.getCode(CarrySetBuiltin.GETCARRY),
474                Generators.makeIntegerConstantNode(locator, carry1Position));
475    }
476
477    public static ASTNode makePending64Call(Locator locator, Context context, int carry1Position) {
478        return Generators.makeFuncCallNode(
479                locator, 
480                context.getCarrySetIdentifier(), 
481                context.getCode(CarrySetBuiltin.PENDING64),
482                Generators.makeIntegerConstantNode(locator, carry1Position));
483    }   
484   
485    public static FuncCallNode makeCarryFlipCall(Locator locator, Context context, int carry1Position) {
486       
487        IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(locator, carry1Position);
488       
489        FuncCallNode carryFlipFuncCall = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
490                                                                        context.getCode(CarrySetBuiltin.CARRYFLIP),
491                                                                        Generators.arguments(indexNode));
492       
493        FuncCallNode setCarryFuncCall  = Generators.makeFuncCallNode(locator,context.getCarrySetIdentifier(),
494                                                                        context.getCode(CarrySetBuiltin.SETCARRY),
495                                                                        Generators.arguments(carryFlipFuncCall,
496                                                                        indexNode)); 
497        return setCarryFuncCall;
498    } 
499   
500    public static IdisaFuncCallNode makeBitwiseOrCarryTest(ASTNode condition,
501                                                            Context context,
502                                                            int carry1Position,
503                                                            int carry1Count) {
504       
505        Locator locator = condition.getLocation();
506
507        ASTNode carry1PositionNode  = Generators.leaf(carry1Position, locator);
508        ASTNode carry1CountNode     = Generators.leaf(carry1Count, locator);
509        ASTNode carryRange          = Generators.makeFuncCallNode(  locator, 
510                                                                    context.getCarrySetIdentifier(),
511                                                                    context.getCode(CarrySetBuiltin.CARRYRANGE),
512                                                                    Generators.arguments(carry1PositionNode, carry1CountNode));
513       
514        return Generators.makeIdisaFuncCallNode(locator, SIMD_OR, BITBLOCK_SIZE, Generators.arguments(condition, carryRange));
515    }   
516   
517    public static FuncCallNode makeCarryDeclareCall(Locator locator, Context context, int carry1Count, int carryNCount) {
518       
519        IdentifierNode carrySetIdentifier       =   Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier()); 
520        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
521        IntegerConstantNode carryNCountNode     =   Generators.makeIntegerConstantNode(locator, carryNCount);
522     
523        FuncCallNode carryDeclareFuncCall       =   Generators.makeFuncCallNode(locator,
524                                                                                context.getCode(CarrySetBuiltin.CARRYDECLARE),
525                                                                                Generators.arguments(carrySetIdentifier,
526                                                                                                     carry1CountNode, 
527                                                                                                     carryNCountNode));       
528        return carryDeclareFuncCall;
529    }
530 
531    public static FuncCallNode makeCarryAdjustmentCall(Locator locator, Context context, int carry1Count) {
532        IntegerConstantNode carry1CountNode =  Generators.leaf(carry1Count, locator);
533
534        FuncCallNode carryAdjustment = Generators.makeFuncCallNode(
535                                        locator, 
536                                        context.getCarrySetIdentifier(),                                   
537                                        context.getCode(CarrySetBuiltin.CARRYADJUST),
538                                        Generators.arguments(carry1CountNode));
539        return carryAdjustment;
540    }   
541
542    public static FuncCallNode makeCarryDequeueEnqueueCall(Locator locator, Context context, int carry1Position, int carry1Count) {
543       
544        IntegerConstantNode carry1PositionNode  =   Generators.makeIntegerConstantNode(locator, carry1Position);
545        IntegerConstantNode carry1CountNode     =   Generators.makeIntegerConstantNode(locator, carry1Count);
546       
547        FuncCallNode carryDequeueEnqueue = Generators.makeFuncCallNode(
548                                            locator, 
549                                            context.getCarrySetIdentifier(),                                   
550                                            context.getCode(CarrySetBuiltin.CARRYDEQUEUEENQUEUE),
551                                            Generators.arguments(carry1PositionNode, carry1CountNode));
552        return carryDequeueEnqueue;
553    } 
554   
555    public static FuncCallNode makeLocalCarryCombineCall(Locator locator, Context context, Context localContext, int carry1Position,
556            int carry1Count) {
557
558        IdentifierNode carrySetIdentifierNode       = Generators.makeIdentifierNode(locator, context.getCarrySetIdentifier());
559        IdentifierNode localCarrySetIdentifierNode  = Generators.makeIdentifierNode(locator, localContext.getCarrySetIdentifier());
560        ASTNode carry1PositionNode                  = leaf(carry1Position, locator);
561        ASTNode carry1CountNode                     = leaf(carry1Count, locator);
562
563        return Generators.makeFuncCallNode(
564                locator,
565                localContext.getCode(CarrySetBuiltin.LOCALCARRYCOMBINE),
566                                        carrySetIdentifierNode,
567                                        localCarrySetIdentifierNode,
568                                        carry1PositionNode,
569                                        carry1CountNode);
570
571    }
572   
573    public static IntegerConstantNode leaf(int n, Locator locator) {
574        return Generators.makeIntegerConstantNode(locator, n);
575    } 
576   
577    ///////////////////////////////////////////////////////////////////
578    // helpers
579    public static ASTNode[] arguments(ASTNode...astNodes) {
580        return astNodes;
581    }
582
583}
Note: See TracBrowser for help on using the repository browser.