Changeset 2804


Ignore:
Timestamp:
Jan 9, 2013, 2:16:20 PM (6 years ago)
Author:
ksherdy
Message:

Partial while loop implementation.

Location:
proto/pablo
Files:
9 added
2 deleted
18 edited
5 moved

Legend:

Unmodified
Added
Removed
  • proto/pablo/input/grammar/scatter/pabloB.scatter

    r2796 r2804  
    9898        kernelName                      #-> identifier ;
    9999       
    100         funcDef                         ->      FUNCTION type funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR?;
     100        funcDef                         ->      FUNCTION returnType funcName LROUND parameterList? RROUND basicBlockStmt TERMINATOR?;
    101101       
    102102        returnType                      #-> type ;      // Note: Strictly not required.
     
    113113       
    114114        optFuncDef                      #-> funcDef ;
    115        
    116         // kernel CCGO // ?
     115                               
     116        // kernel state         // kernelState -> '[' ']'
    117117       
    118118        //
     
    166166                                            | integerConstant ;
    167167                                           
    168         integerConstant                 -> INTEGER_CONST {@value = @@value;} ;
     168        integerConstant                 -> INTEGER_CONST {@value = @@value;} ; // map to a 32 bit integer
    169169       
    170170        stringConstant                  -> STRING | SQ_STRING ;
  • proto/pablo/input/grammar/scatter/pabloS.scatter

    r2749 r2804  
    9595        // f u n c t i o n   d e c l a r a t i o n s ?                                                 
    9696        //
    97         funcDef                 -> FUNCTION type funcName LROUND parameterList? RROUND blockStmt TERMINATOR?;                           
     97        funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR?;                             
    9898                                                                               
    9999        returnType              #-> type ;      // Note: Strictly not required.
  • proto/pablo/input/test/pabloS/py2pablo/parabix2_pablo.pablos

    r2796 r2804  
    269269            var stream<1> u8error3 = (u8.xF0_scope & u8.x80_x8F);
    270270            var stream<1> u8error4 = (u8.xF4_scope & u8.x90_xBF);
    271             //u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
    272             u8_error = (u8_error | (((u8error1 | u8error2) | u8error3) | u8error4));
     271            u8_error |= (((u8error1 | u8error2) | u8error3) | u8error4);
    273272            var stream<1> EF_BF_pending = pablo.Advance((u8.xEF_scope & u8.xBF));
    274273            u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF));
     
    355354
    356355function void Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     356    var stream<1> EqExpected = 0;
     357    var stream<1> AttListEnd = 0;
    357358    var stream<1> DQuoteDelim = (lex.DQuote | lex.LAngle);
    358359    var stream<1> SQuoteDelim = (lex.SQuote | lex.LAngle);
    359360    var stream<1> AttListDelim = (lex.Slash | lex.RAngle);
    360    
    361     var stream<1> EqExpected = 0;
    362     var stream<1> AttListEnd = 0;
    363    
    364361    tag_Callouts.ElemName_starts = (marker.LAngle_scope & (~ lex.Slash));
    365362    tag_Callouts.EndTag_marks = (marker.LAngle_scope & lex.Slash);
     
    478475    check_streams.att_refs = (tag_Callouts.AttVal_spans & marker.Ref_opener);
    479476}
    480 
    481477/*
    482478function void Main(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, struct Xml_char xml_char, struct Scope1 scope1, struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Masks masks, struct Xml_names xml_names, struct Check_streams check_streams) {
     
    487483    Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams);
    488484    Do_check_streams(marker, tag_Callouts, check_streams);
    489 }
    490 */
     485}*/
  • proto/pablo/notes

    r2787 r2804  
    11211210. Semantic analyzer. Add Scatter logging.   
    113113
    114 11. Clone AST or not.
     11411. Clone AST or not. Clone.
    115115
    11611611. X2Lang design decision. enum/assert etc...
     
    11811812. do_block()/do_final_block() code generation implementation.
    119119
     120        i.e. How do we represent/output both do_block and do_final_block function/code?
     121
    120122        We attach nodes to the Pablo AST to produce do_block() versus do_final_block() code.
    121123
     
    123125
    124126->
    125 
    126127
    127128        Case do_final_block()
     
    133134        (a) Parse source file twice to produce two separate AST.
    134135        (b) Clone complete AST. Apply AST transformation passes to both ASTs.
    135         (c) Add both body and final block bodies to a single AST.
     136        (c) Add both body and final block bodies to a single AST. We accomplish this through
     137            the addition/introduce of both PabloS and PabloB grammars and translate
     138            from PabloS to PabloB.
    136139       
    137140        An additional decision remains as to which point in Pablo AST transformation we clone ASTs.
     141
     142        Design choice taken (c): Translate from PabloS to PabloB.
    138143
    13914413. Carry mode (ci/co) and do_block/do_final_block are independent concepts.
     
    195200AdvanceThenScanTo(M,S)          --> AdvanceThenScanThru(M,~(S &~ EOF_mask))
    196201
    197 
    198202inFile(E) --> S & EOF_mask  --> assert_0(inFile(E))
     203
     204i.e. look at only bits within the file extent
     205
    199206i.e. tests only bits within the file the extent and then test none of this set of bits is marked
    200207
    201 atEOF(E)  --> S &~ EOF_mask --> assert_0(atEOF(E)) 
     208atEOF(E)  --> S &~ EOF_mask --> assert_0(atEOF(E))
     209
     210i.e. look at only bits beyond the EOF
     211 
    202212i.e. tests no bit beyond the file extents is marked
    203213
     
    226236        S
    227237}
     238
     23916. PabloB grammar design issue (together with Carry InfoSet design)
     240
     241How do we add stream function level declaration / initialization code to the output?
     242
     243Options:
     244
     245(a) Add explicit carry info set information to the PabloB function definition representation.
     246
     247    No, this would burden the programmer at the PabloB level.
     248    The idea is the we remove carry counting ... from the developer
     249    but still we need carry count / advn carry count information
     250    for code output.
     251   
     252(b) Hold carry info set information in a symbol table external
     253        to both PabloB. Query this data structure during code generation.
     254   
     255(a) and (b) are similar in that both options remove explicit carry counting from the programmer.
     256
     257We currently translate PabloS to PabloB and PabloS code is used to populate the information
     258contained in the symbol table used by PabloB.
     259
     260We could populate similar symbol table information based on PabloB code alone.
     261
     262More investigation is required here.
     263
     26417. Limitations of a macro driven carry handling approach.
     265
     266Fill in this section ...
     267
     26818. PabloB needs both bitwise OR as well as boolean OR.
     269
     27019. Translate to Dotty for AST diagrams.
     271   
     272
  • proto/pablo/runConfigurations/pabloJ.launch

    r2796 r2804  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="applicationGenerator.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pabloS/py2pablo/parabix2_pablo.pablos"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${workspace_loc}/pablo/input/test/pabloS/statements/while/while3.pablos"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pablo"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pablo/runConfigurations/testPabloSAST.launch

    r2765 r2804  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloS.grammar.TestPabloSAST"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pabloS"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pablo/input/test/pabloS/statements/while"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pablo"/>
    1313</launchConfiguration>
  • proto/pablo/src/applicationGenerator/ApplicationGenerator.java

    r2796 r2804  
    8181                pabloSXFormer.setFinalBlockMode(false);
    8282                pabloS.ast.ASTNode decoratedTree = pabloSXFormer.xForm();
    83 
    84                 //System.exit(0);
    8583               
    8684                // Optimized AST transformation
  • proto/pablo/src/applicationGenerator/PabloJ.java

    r2788 r2804  
    3535               
    3636                try {
     37                       
    3738                        CommandLineParser parser = new PosixParser();
    3839                        CommandLine cli = parser.parse(options, args); 
     
    4041                        ApplicationGenerator applicationGenerator = new ApplicationGenerator(applicationConfig);
    4142                        applicationGenerator.generate();
     43                       
    4244                } catch (Exception e) {
    4345                       
    44                         e.printStackTrace();
     46                        e.printStackTrace();                   
     47                        CompilerOptions.exitWithUsageMessage(options);
    4548                       
    46                         CompilerOptions.exitWithUsageMessage(options);
    4749                }       
    4850        }
  • proto/pablo/src/applicationGenerator/templates/CPP/pablo_definitions.template

    r2796 r2804  
    11// ###@warningComment ###
    22//
    3 // (c) 2012 Robert D. Cameron, Ken Herdy
     3// (c) 2012, 2013 Robert D. Cameron, Ken Herdy
    44// All rights reserved.
    55// Licensed to International Characters, Inc. under Academic Free License 3.0
  • proto/pablo/src/compiler/ast/pabloS/Accessors.java

    r2796 r2804  
    182182        // WhileStmtNode helpers
    183183        ////////////////////////////////////////////////////////////////////////////           
    184         public static ASTNode whileCondition(WhileStmtNode node) {
    185                 return node.child(0);
    186         }       
    187                
     184        public static ASTNode whileTest(WhileStmtNode node) {
     185                return node.child(0);
     186        }       
     187               
     188        public static ASTNode whileBlockStmt(WhileStmtNode node) {
     189                return node.child(1);
     190        }
     191       
    188192        ////////////////////////////////////////////////////////////////////////////
    189193        // FuncDefinitionNode helpers
     
    228232        return (BlockStmtNode) child;
    229233        }       
    230        
    231         ////////////////////////////////////////////////////////////////////////////
    232         // WhileStmt helpers
    233         ////////////////////////////////////////////////////////////////////////////
    234         public static ASTNode whileTest(WhileStmtNode node) {
    235                 return node.child(0);
    236         }
    237        
     234               
    238235        ////////////////////////////////////////////////////////////////////////////
    239236        // FuncCallNode helpers
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2796 r2804  
    216216                return new BlockStmtNode(token);
    217217        }
     218
     219        public static IfStmtNode makeIfStmtNode(Token tokenLocation, ASTNode expression, BlockStmtNode ifBlockStmt, BlockStmtNode elseBlockStmt) {
     220                IfStmtNode ifStmtNode = makeIfStmtNode(tokenLocation, expression, ifBlockStmt);
     221                ifStmtNode.appendChild(elseBlockStmt);
     222                return ifStmtNode;
     223        }       
    218224       
    219225        public static IfStmtNode makeIfStmtNode(Token tokenLocation, ASTNode expression, BlockStmtNode blockStmt) {
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2796 r2804  
    7474        }
    7575       
     76        @SuppressWarnings("static-access")
    7677        public CodeStore visitLeave(KernelDefNode node, List<CodeStore> childResults) {
    7778                CodeStore code = new CodeStore();
     
    8283               
    8384                CarryInfoSetSymbol carryInfoSet = (CarryInfoSetSymbol) symbolTable.get(kernelName);
    84                
    8585               
    8686                code.addFormattedLine("struct %s ", kernelName);
     
    9696                String formatString = new String();
    9797               
    98                 formatString = carrySetBuiltins2CPP.getCode(CarrySetBuiltins.CARRYINIT);
     98                // TODO -       Kludgy approach. See 'notes'.
     99                formatString = carrySetBuiltins2CPP.CARRYSETDECLAREFORMATSTRING;
    99100                formatString += ";";
    100                 code.addFormattedLine(formatString, carryInfoSet.getCarryCount(), carryInfoSet.getAdvanceNCount());
     101                code.addFormattedLine(formatString, carryInfoSet.getCarryCount(), carryInfoSet.getAdvanceNCount(), carrySetBuiltins2CPP.CARRYQIDENTIFIER);
    101102               
    102103                code.dedentedLine("};");
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins.java

    r2775 r2804  
    22
    33public enum CarrySetBuiltins {
    4         CARRYINIT(2),                           // carry set object constructor
     4        LOCALCARRYDECLARE(2),                           
    55        CARRYTEST(2),
    66        GETCARRYIN(1),
     
    1010        CARRYFLIP(2),
    1111        CARRYDEQUEUEENQUEUE(2),
    12         VALUEOF(1); 
     12        VALUEOF(1);
    1313                       
    1414        private final int argCount;
    15 
    16 //      public static String CarryQ_TYPE = "CarryQ";
    17         public static String CarryQ_IDENTIFIER = "carryQ";
    1815               
    1916        CarrySetBuiltins(int argCount ) {
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins2CPP.java

    r2796 r2804  
    55
    66public class CarrySetBuiltins2CPP extends CarrySetBuiltins2Lang {
    7 
     7       
    88        private static Map<CarrySetBuiltins, String> carry2CPPCode;
    99       
    1010    static {
     11   
     12        CARRYSETDECLAREFORMATSTRING = "CarryArray<%s,%s> %s";
    1113       
    1214        carry2CPPCode = new HashMap<CarrySetBuiltins, String>();
    1315       
    14         carry2CPPCode.put(CarrySetBuiltins.CARRYINIT, "CarryArray<%s,%s> carryQ");
     16        carry2CPPCode.put(CarrySetBuiltins.LOCALCARRYDECLARE, "LocalCarryDeclare");
    1517        carry2CPPCode.put(CarrySetBuiltins.CARRYTEST,"PabloJCarryTest");
    1618        carry2CPPCode.put(CarrySetBuiltins.GETCARRYIN,"get_carry_in");
     
    2729                }
    2830        }
     31       
    2932    }
    3033   
     
    3437       
    3538}
     39
     40// 1.
  • proto/pablo/src/compiler/lang/carry/CarrySetBuiltins2Lang.java

    r2775 r2804  
    33public abstract class CarrySetBuiltins2Lang {
    44        public abstract String getCode(CarrySetBuiltins op);
     5       
     6        public static String CARRYQIDENTIFIER = "carryQ";
     7        public static String LOCALCARRYQIDENTIFIER = "subcarryQ";
     8        public static String CARRYSETDECLAREFORMATSTRING = null;
     9
    510}
  • proto/pablo/src/compiler/transformer/PabloSTransformer.java

    r2796 r2804  
    8282            advanceCombiner.XForm();
    8383
    84             CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getCarrySet2Lang());
    85                 carryQIntro.XForm();           
     84            CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
     85                carryQIntro.XForm(finalBlockMode);             
    8686           
    8787                // Dependency on CarryIntroXFormer to count PabloS builtins that produce carry values.
    88                 Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
    89                 pablo2CarryXFormer.XForm(finalBlockMode);                           
     88                //Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
     89                //pablo2CarryXFormer.XForm(finalBlockMode);                         
    9090                                   
    9191                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
  • proto/pablo/src/compiler/transformer/visitors/Bitwise2IDISAXFormer.java

    r2796 r2804  
    151151//              return whileNode
    152152                public void visitLeave(WhileStmtNode node) {
    153                         ASTNode whileTest = Accessors.whileCondition(node);                     
     153                        ASTNode whileTest = Accessors.whileTest(node);                 
    154154                                                                                                                               
    155155                        FuncCallNode FuncCallNode = Generators.makeFuncCallNode(
  • proto/pablo/src/compiler/transformer/visitors/CarryIntroXFormer.java

    r2775 r2804  
    11package compiler.transformer.visitors;
     2
     3import java.util.ArrayList;
     4import java.util.List;
    25
    36import pabloS.ast.*;
     
    912import compiler.lang.carry.CarrySetBuiltins;
    1013import compiler.lang.carry.CarrySetBuiltins2Lang;
     14import compiler.lang.idisa.SIMD;
     15import compiler.lang.pabloS.Builtins;
     16import compiler.lang.pabloS.Builtins2Lang;
    1117import compiler.lang.pabloS.BuiltinsUtil;
    1218
    13 // TODO - Add while type to switch on/off carry in mode. Carry in is an internal to this visitor.
     19/*
     20 * Translates carry dependent PabloS language features to PabloB. The translation process
     21 * parameterized on 'carry' mode and 'final-block' mode.
     22 *
     23 * Target language independent Carry Set builtins calls are appended to the PabloB
     24 * AST in the translation of PabloS 'if' and PabloS 'while' statements translated in
     25 * 'carry-in' mode.
     26 *
     27 * By default, carry-in and carry-out mode are enabled
     28 * for translation of PabloS language constructs
     29 * to PabloB constructs.
     30 *
     31 * For example,
     32 *
     33 * PabloS if statements translate to PabloB syntax as follows.
     34 *
     35 * 'carry-in' - enabled
     36 *
     37 * if (E) { S* } => if (E | CarryTest(base,count)) { S* }
     38 *
     39 * 'carry-in' - disabled
     40 *
     41 * if (E) { S* } => if (E) { S* }
     42 *
     43 * Carry-in mode is enable in the initial iteration of while loops.
     44 * Carry-in mode is disable for the translation of subsequent while loop iterations.
     45 *
     46 * PabloS while statements translate to PabloB syntax as follows.
     47 *
     48 * 'carry-in' - enabled
     49 *
     50 * while (E) { S* } =>
     51 *
     52 * if (E | CarryTest(base, count) )
     53 * {
     54 *              S'*
     55 *              while (E)
     56 *              {
     57 *                      S''*
     58 *                      CarryCombine(base, count)
     59 *              }
     60 * }
     61 *
     62 * wherein, S'
     63 *
     64 * 'carry-in' disabled
     65 *
     66 * Final-block mode.
     67 *
     68 * 'And Complement' EOF_mask
     69 * ...
     70 */
    1471
    1572public class CarryIntroXFormer {
    1673               
    17         private ASTNode ASTTree;
     74        private ASTNode ASTTree;       
     75        private Builtins2Lang builtins2Lang;
    1876        private CarrySetBuiltins2Lang carrySet2Lang;
    19                
    20     public CarryIntroXFormer(ASTNode node, CarrySetBuiltins2Lang carrySet2Lang) {
     77       
     78    public CarryIntroXFormer(ASTNode node, Builtins2Lang builtins2Lang, CarrySetBuiltins2Lang carrySet2Lang) {
    2179        this.ASTTree = node;
     80        this.builtins2Lang = builtins2Lang;
    2281        this.carrySet2Lang = carrySet2Lang;
    23     }
    24 
    25     public void XForm(/*boolean ci , boolean co*/) {
    26                 XFormer visitor = new XFormer(/*ci , co*/);
    27                 ASTTree.accept(visitor);
     82    }   
     83       
     84    public void XForm(boolean finalBlockMode) {
     85                XFormer visitor = new XFormer();
     86                visitor.setFinalBlockMode(finalBlockMode);
     87                ASTTree.accept(visitor);
    2888    }                   
    29        
     89
     90    public void XForm(boolean finalBlockMode, boolean ciMode, String carrySetIdentifier) {
     91                XFormer visitor = new XFormer();
     92                visitor.setFinalBlockMode(finalBlockMode);
     93                visitor.setCiMode(ciMode);
     94                visitor.setCarrySetIdentifier(carrySetIdentifier);
     95                ASTTree.accept(visitor);
     96    }     
     97   
    3098        private class XFormer extends VoidVisitor.Default {
    3199
     
    35103                //private String [] pending64QName = {CarryQ.CarryQ_PACKAGE_NAME, CarryQ.GETPENDING64.cPPCode()};
    36104               
    37                 private boolean isFinalBlock;
    38                
     105                private boolean finalBlockMode;
    39106                private boolean ciMode;
    40107                //private boolean coMode;
    41                                
     108               
     109                private String carrySetIdentifier;
     110               
    42111                private int currentCarry;
    43                 //private int currentAdvN;
     112                private int currentAdvN;
    44113                //private int lastStmtCarries;
    45                
    46                 XFormer(/*boolean ciMode , boolean coMode */) {
    47                         this.ciMode = true;
     114                               
     115                @SuppressWarnings("static-access")
     116                XFormer(/*boolean finalBlockModeboolean ciMode , boolean coMode */) {
     117                       
     118                        this.finalBlockMode = false;                                                   
     119                        this.currentCarry = 0;
     120                        this.currentAdvN = 0;
     121                        //this.lastStmtCarries = 0;
     122                       
     123                        this.ciMode = true;                                                                                                     
    48124                        //this.coMode = coMode;
    49                         this.currentCarry = 0;
    50                         //this.currentAdvN = 0;
    51                         //this.lastStmtCarries = 0;
    52                 }
     125                        this.carrySetIdentifier = carrySet2Lang.CARRYQIDENTIFIER;       
     126                }
     127
     128                protected boolean isCiMode() {
     129                        return ciMode;
     130                }
     131
     132                protected void setCiMode(boolean ciMode) {
     133                        this.ciMode = ciMode;
     134                }
     135
     136                protected String getCarrySetIdentifier() {
     137                        return carrySetIdentifier;
     138                }
     139
     140                protected void setCarrySetIdentifier(String carrySetIdentifier) {
     141                        this.carrySetIdentifier = carrySetIdentifier;
     142                }
     143
     144                protected boolean isFinalBlockMode() {
     145                        return finalBlockMode;
     146                }
     147
     148                protected void setFinalBlockMode(boolean finalBlockMode) {
     149                        this.finalBlockMode = finalBlockMode;
     150                }
     151               
     152                // xFormers
    53153               
    54154                //              def xfrm_fndef(self, fndef):
     
    61161                //      #    fndef.body.insert(0, mkCallStmt('CarryDeclare', [self.carryvar, ast.Num(carry_count)]))
    62162                //          return fndef
     163               
    63164                public void visitEnter(FuncDefNode node) {
    64165                        this.currentCarry = 0;
    65                         //this.currentAdvN = 0;
     166                        this.currentAdvN = 0;
    66167                        //this.lastStmtCarries = 0;
    67168                       
    68169                        int carryCount = (new CarryCounterVisitor(node)).count();
    69                         if(carryCount > 0) {
    70                        
     170                       
     171                        if(carryCount > 0) { 
     172                                                               
    71173                                IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    72174                               
     175                                @SuppressWarnings("static-access")
    73176                                FuncCallNode carryAdjustFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    74                                                 new String [] {CarrySetBuiltins.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySetBuiltins.CARRYQADJUST)},
     177                                                new String [] {carrySet2Lang.CARRYQIDENTIFIER, carrySet2Lang.getCode(CarrySetBuiltins.CARRYQADJUST)},
    75178                                                node.getToken(),
    76179                                                new ASTNode [] {carryCountNode});
     
    78181                                BlockStmtNode blockStmtNode = Accessors.blockStmtNode(node);
    79182                                blockStmtNode.appendChild(carryAdjustFuncCall);
    80                         }
     183                                       
     184                        }                       
     185
    81186                }               
    82187               
     188                public void visitLeave(FuncDefNode node) {
     189                        if(isFinalBlockMode()) {
     190                                ParameterNode EOFMaskParameter = Generators.makeEOFMaskParameter(builtins2Lang, node.getToken());
     191                                Generators.appendParameter(node, EOFMaskParameter);
     192                        }
     193                }               
     194               
     195                //public void visitLeave(FuncCallNode node) {
     196                //      if(BuiltinsUtil.isCarryOne(node)) {
     197                //              this.currentCarry += 1;
     198                //      }                                       
     199                //}
     200               
    83201                public void visitLeave(FuncCallNode node) {
    84                         if(BuiltinsUtil.isCarryOne(node)) {
    85                                 this.currentCarry += 1;
    86                         }                                       
    87                 }
    88                
    89                 //def visit_If(self, ifNode):
    90                 //carry_base = self.current_carry
    91                 //carries = CarryCounter().count(ifNode)
    92                 //assert adv_nCounter().count(ifNode) == 0, "Advance(x,n) within if: illegal\n"
    93                 //self.generic_visit(ifNode)
    94                 //if carries == 0 or self.carryin == "": return ifNode
    95                 //#CARRYSET
    96                 //carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
    97                 //new_test = ast.BoolOp(ast.Or(), [ifNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
    98                 //new_else_part = ifNode.orelse + [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]
    99                 //return ast.If(new_test, ifNode.body, new_else_part)
    100 
    101                 public void visitEnter(IfStmtNode node) { // Current if strategy does not test any_carry() on n bits
     202                               
     203                        ASTNode replacementNode;
     204                       
     205                        ASTNode carryCall;
     206                        IntegerConstantNode currentCarry = Generators.makeIntegerConstantNode(this.currentCarry, node.getToken());
     207                       
     208                        ASTNode advNCall;
     209                        IntegerConstantNode currentAdvN = Generators.makeIntegerConstantNode(this.currentAdvN, node.getToken());
     210
     211                        //                  if self.carryin == "_ci":
     212                        //              carry_args = [mkCall(self.carryvar.id + "." + 'get_carry_in', [ast.Num(self.current_carry)]), ast.Num(self.current_carry)]
     213                        //              adv_n_args = [mkCall(self.carryvar.id + "." + 'get_pending64', [ast.Num(self.current_adv_n)]), ast.Num(self.current_adv_n)]
     214                        //          else:
     215                        //              carry_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_carry)]
     216                        //              adv_n_args = [mkCall('simd<1>::constant<0>', []), ast.Num(self.current_adv_n)]
     217                       
     218                        if(isCiMode()) {
     219                                carryCall = Generators.makeFuncCallNode(
     220                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.GETCARRYIN)},
     221                                                node.getToken(),
     222                                                new ASTNode [] {currentCarry});
     223                               
     224                                advNCall = Generators.makeFuncCallNode(
     225                                                new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.GETPENDING64)},
     226                                                node.getToken(),
     227                                                new ASTNode [] {currentAdvN});
     228                        } else {
     229                                carryCall = Generators.makeIntegerConstantNode(0, node.getToken());
     230                                advNCall = Generators.makeIntegerConstantNode(0, node.getToken());
     231                        }
     232                                               
     233                        //                  if is_BuiltIn_Call(callnode, 'Advance', 1):         
     234                        //                    #CARRYSET
     235                        //                    rtn = self.carryvar.id + "." + "BitBlock_advance_ci_co"
     236                        //                    c = mkCall(rtn, callnode.args + carry_args)
     237                        //                    self.current_carry += 1
     238                        //                    return c
     239                       
     240                        if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE.pabloName(), Builtins.ADVANCE.argCount())) {         
     241                               
     242                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     243                               
     244                                replaceFuncCallNode(node,
     245                                                getCarrySetIdentifier(),
     246                                                builtins2Lang.getCode(Builtins.ADVANCE),
     247                                                arguments,
     248                                                carryCall,
     249                                                currentCarry);
     250                               
     251                                this.currentCarry += 1;
     252                        }
     253       
     254                        //      #CARRYSET
     255                        //      rtn = self.carryvar.id + "." + "BitBlock_scanthru_ci_co"
     256                        //      c = mkCall(rtn, callnode.args + carry_args)
     257                        //      self.current_carry += 1
     258                        //      return c                                                       
     259                       
     260                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTHRU.pabloName(), Builtins.SCANTHRU.argCount())) {                           
     261                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     262                               
     263                                replaceFuncCallNode(node,
     264                                                getCarrySetIdentifier(),
     265                                                builtins2Lang.getCode(Builtins.SCANTHRU),
     266                                                arguments,
     267                                                carryCall,
     268                                                currentCarry);
     269                                this.currentCarry += 1;
     270                        }
     271                               
     272                        //          elif is_BuiltIn_Call(callnode, 'AdvanceThenScanThru', 2):
     273                        //          #CARRYSET
     274                        //          rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
     275                        //          c = mkCall(rtn, callnode.args + carry_args)
     276                        //          self.current_carry += 1
     277                        //          return c                   
     278                       
     279                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTHRU.pabloName(), Builtins.ADVANCETHENSCANTHRU.argCount())) {
     280                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     281                               
     282                                replaceFuncCallNode(node,
     283                                                getCarrySetIdentifier(),
     284                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     285                                                arguments,
     286                                                carryCall,
     287                                                currentCarry);
     288                                this.currentCarry += 1;
     289                        }               
     290       
     291                        //      elif is_BuiltIn_Call(callnode, 'SpanUpTo', 2):
     292                        //      #CARRYSET
     293                        //      rtn = self.carryvar.id + "." + "BitBlock_span_upto"
     294                        //      c = mkCall(rtn, callnode.args + carry_args)
     295                        //      self.current_carry += 1
     296                        //      return c
     297                       
     298                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SPANUPTO.pabloName(), Builtins.SPANUPTO.argCount())) {
     299                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     300                               
     301                                replaceFuncCallNode(node,
     302                                                getCarrySetIdentifier(),
     303                                                builtins2Lang.getCode(Builtins.SPANUPTO),
     304                                                arguments,
     305                                                carryCall,
     306                                                currentCarry);                         
     307                                this.currentCarry += 1;
     308                        }               
     309                       
     310                        //              elif is_BuiltIn_Call(callnode, 'AdvanceThenScanTo', 2):
     311                        //      #CARRYSET
     312                        //      rtn = self.carryvar.id + "." + "BitBlock_advance_then_scanthru"
     313                        //      if self.carryout == "":  scanclass = mkCall('simd_andc', [ast.Name('EOF_mask', ast.Load()), callnode.args[1]])
     314                        //      else: scanclass = mkCall('simd_not', [callnode.args[1]])
     315                        //      c = mkCall(rtn, [callnode.args[0], scanclass] + carry_args)
     316                        //      self.current_carry += 1
     317                        //          return c                   
     318                       
     319                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
     320                                if(isFinalBlockMode()) {
     321                                        ASTNode argNode = Accessors.funcCallArg(node, 1);
     322                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
     323                                        Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);                                   
     324                                }
     325                               
     326                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     327                               
     328                                replaceFuncCallNode(node,
     329                                                getCarrySetIdentifier(),
     330                                                builtins2Lang.getCode(Builtins.ADVANCETHENSCANTHRU),
     331                                                arguments,
     332                                                carryCall,
     333                                                currentCarry);
     334                                this.currentCarry += 1;
     335                        }               
     336                       
     337                        //          elif is_BuiltIn_Call(callnode, 'InclusiveSpan', 2):
     338                        //            #CARRYSET
     339                        //      #      rtn = self.carryvar.id + "." + "BitBlock_span_upto"
     340                        //      #      c = mkCall('simd_or', [mkCall(rtn, callnode.args + carry_args), callnode.args[1]])
     341                        //            rtn = self.carryvar.id + "." + "BitBlock_inclusive_span"
     342                        //            c = mkCall(rtn, callnode.args + carry_args)
     343                        //            self.current_carry += 1
     344                        //            return c
     345       
     346                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INCLUSIVESPAN.pabloName(), Builtins.INCLUSIVESPAN.argCount())) {
     347                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     348                               
     349                                replaceFuncCallNode(node,
     350                                                getCarrySetIdentifier(),
     351                                                builtins2Lang.getCode(Builtins.INCLUSIVESPAN),
     352                                                arguments,
     353                                                carryCall,
     354                                                currentCarry);
     355                                this.currentCarry += 1;
     356                        }                               
     357                       
     358                        //          elif is_BuiltIn_Call(callnode, 'ExclusiveSpan', 2):
     359                        //            #CARRYSET
     360                        //      #      rtn = self.carryvar.id + "." + "BitBlock_span_upto"
     361                        //      #      c = mkCall('simd_andc', [mkCall(rtn, callnode.args + carry_args), callnode.args[0]])
     362                        //            rtn = self.carryvar.id + "." + "BitBlock_exclusive_span"
     363                        //            c = mkCall(rtn, callnode.args + carry_args)
     364                        //            self.current_carry += 1
     365                        //            return c
     366       
     367                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.EXCLUSIVESPAN.pabloName(), Builtins.EXCLUSIVESPAN.argCount())) {
     368                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     369                               
     370                                replaceFuncCallNode(node,
     371                                                getCarrySetIdentifier(),
     372                                                builtins2Lang.getCode(Builtins.EXCLUSIVESPAN),
     373                                                arguments,
     374                                                carryCall,
     375                                                currentCarry);
     376                                this.currentCarry += 1;
     377                        }                                               
     378                       
     379                        //          elif is_BuiltIn_Call(callnode, 'ScanTo', 2):
     380                        //            # Modified Oct. 9, 2011 to directly use BitBlock_scanthru, eliminating duplication
     381                        //            # in having a separate BitBlock_scanto routine.
     382                        //            #CARRYSET
     383                        //            rtn = self.carryvar.id + "." + "BitBlock_scanthru_ci_co"
     384                        //            if self.carryout == "":  scanclass = mkCall('simd_andc', [ast.Name('EOF_mask', ast.Load()), callnode.args[1]])
     385                        //            else: scanclass = mkCall('simd_not', [callnode.args[1]])
     386                        //            c = mkCall(rtn, [callnode.args[0], scanclass] + carry_args)
     387                        //            self.current_carry += 1
     388                        //            return c
     389       
     390                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
     391                                if(isFinalBlockMode()) {
     392                                        ASTNode argNode = Accessors.funcCallArg(node, 1);
     393                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
     394                                        Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);                                   
     395                                }
     396                               
     397                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     398                               
     399                                replaceFuncCallNode(node,
     400                                                getCarrySetIdentifier(),
     401                                                builtins2Lang.getCode(Builtins.SCANTHRU),
     402                                                arguments,
     403                                                carryCall,
     404                                                currentCarry);
     405                                this.currentCarry += 1;
     406                        }                                                               
     407                       
     408                        //          elif is_BuiltIn_Call(callnode, 'ScanToFirst', 1):
     409                        //            #CARRYSET
     410                        //            rtn = self.carryvar.id + "." + "BitBlock_scantofirst"
     411                        //            #if self.carryout == "":  carry_args = [ast.Name('EOF_mask', ast.Load())] + carry_args
     412                        //            c = mkCall(rtn, callnode.args + carry_args)
     413                        //            self.current_carry += 1
     414                        //            return c
     415
     416                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTOFIRST.pabloName(), Builtins.SCANTOFIRST.argCount())) {
     417                        //                      if(finalBlockMode) {
     418                        //                              // TODO - Wrap within simd_andc(scan_class, EOF_mask)
     419                        //                      }
     420                               
     421                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     422                               
     423                                replaceFuncCallNode(node,
     424                                                getCarrySetIdentifier(),
     425                                                builtins2Lang.getCode(Builtins.SCANTOFIRST),
     426                                                arguments,
     427                                                carryCall,
     428                                                currentCarry);
     429                                this.currentCarry += 1;
     430                        }                                                                               
     431       
     432                        //          elif is_BuiltIn_Call(callnode, 'Advance32', 1):     
     433                        //            #CARRYSET
     434                        //            rtn = self.carryvar.id + "." + "BitBlock_advance_n_<32>"
     435                        //            c = mkCall(rtn, callnode.args + adv_n_args)
     436                        //            self.current_adv_n += 1
     437                        //            return c
     438                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCE32.pabloName(), Builtins.ADVANCE32.argCount())) {
     439                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCE32.cPPCode(), carryCall, currentAdvN);
     440                                // TODO ==> Verify implementation.
     441                               
     442                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     443                               
     444                                replaceFuncCallNode(node,
     445                                                getCarrySetIdentifier(),
     446                                                builtins2Lang.getCode(Builtins.ADVANCE32),
     447                                                arguments,
     448                                                advNCall,
     449                                                currentAdvN);
     450                                this.currentAdvN += 1;
     451                        }                       
     452                       
     453                        //          if is_BuiltIn_Call(callnode, 'Advance', 2):         
     454                        //            #CARRYSET
     455                        //            rtn = self.carryvar.id + "." + "BitBlock_advance_n_<%i>" % callnode.args[1].n
     456                        //            c = mkCall(rtn, [callnode.args[0]] + adv_n_args)
     457                        //            self.current_adv_n += 1
     458                        //            return c         
     459                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCEN.pabloName(), Builtins.ADVANCEN.argCount())) {
     460                                //replaceFuncCallNode(node, CarryQ.CarryQ_PACKAGE_NAME, BuiltinOperations.ADVANCEN.cPPCode(), carryCall, currentAdvN);                                 
     461                               
     462                                ASTNode formatValue = Accessors.funcCallArg(node, 1);
     463                                String value = Accessors.integerConstant((IntegerConstantNode)formatValue);
     464                               
     465                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     466                               
     467                                String formattedAdvanceN = String.format(builtins2Lang.getCode(Builtins.ADVANCEN), value);
     468                               
     469                                replaceFuncCallNode(node,
     470                                                getCarrySetIdentifier(),
     471                                                formattedAdvanceN,
     472                                                arguments.subList(0, arguments.size()-1),
     473                                                advNCall,
     474                                                currentAdvN);           
     475                                this.currentAdvN += 1;                 
     476                        }                                       
     477               
     478                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ATEOF.pabloName(), Builtins.ATEOF.argCount())) {
     479                                 
     480                                if(isFinalBlockMode()) {
     481                                        ASTNode argNode = Accessors.funcCallArg(node, 0);
     482                                        replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
     483                                } else {
     484                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
     485                                }
     486                                node.updateSelf(replacementNode);
     487                        }                                       
     488       
     489                        //          elif is_BuiltIn_Call(callnode, 'inFile', 1):
     490                        //            if self.carryout != "": 
     491                        //              # Non final block: inFile(x) = x.
     492                        //              return callnode.args[0]
     493                        //            else: return mkCall('simd_and', [callnode.args[0], ast.Name('EOF_mask', ast.Load())])
     494                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.INFILE.pabloName(), Builtins.INFILE.argCount())) {
     495                               
     496                                if(isFinalBlockMode()) {                                       
     497                                        ASTNode argNode = Accessors.funcCallArg(node, 0);
     498                                        replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(argNode, builtins2Lang);
     499                                } else {
     500                                        replacementNode = Accessors.funcCallArg(node,0);
     501                                }
     502                                node.updateSelf(replacementNode);
     503                        }                       
     504                       
     505                        //                      Deprecated - New bitblock iterators replace StreamScan.
     506                        //                     
     507                        //              elif is_BuiltIn_Call(callnode, 'StreamScan', 2):
     508                        //                      rtn = "StreamScan"           
     509                        //                      c = mkCall(rtn, [ast.Name('(ScanBlock *) &' + callnode.args[0].id, ast.Load()),
     510                        //                                                 ast.Name('sizeof(BitBlock)/sizeof(ScanBlock)', ast.Load()),
     511                        //                                                 ast.Name(callnode.args[1].id, ast.Load())])
     512                        //              return c                                       
     513                        //
     514                        //                      else if (Builtins.isCall(node, Builtins.BUILTIN_PACKAGE_NAME, NoCarry.STREAMSCAN.pabloName(), NoCarry.STREAMSCAN.argCount())) {
     515                        //                              replacementNode = Generators.makeFuncCallNode(NoCarry.STREAMSCAN.cPPCode(), node.getToken());
     516                        //                             
     517                        //                              ASTNode arg0 = Generators.makeIdentifierNode("(ScanBlock *) &" + Accessors.identifierLexeme(Accessors.FuncCallArg(node, 0)), node.getToken());
     518                        //                              ASTNode arg1 = Generators.makeIdentifierNode("sizeof(BitBlock)/sizeof(ScanBlock)", node.getToken());
     519                        //                              ASTNode arg2 = Accessors.FuncCallArg(node, 1);
     520                        //                             
     521                        //                              replacementNode.appendChild(arg0);
     522                        //                              replacementNode.appendChild(arg1);
     523                        //                              replacementNode.appendChild(arg2);
     524                        //                      }
     525                                               
     526                        //                  else:
     527                        //                    #dump_Call(callnode)
     528                        //                    return callnode
     529                        else {
     530                                // do nothing // TODO - allow calls to pass ?
     531                        }
     532                       
     533                }
     534               
     535                //      def visit_If(self, ifNode):
     536                //      carry_base = self.current_carry
     537                //      carries = CarryCounter().count(ifNode)
     538                //      assert adv_nCounter().count(ifNode) == 0, "Advance(x,n) within if: illegal\n"
     539                //      self.generic_visit(ifNode)
     540                //      if carries == 0 or self.carryin == "": return ifNode
     541                //      #CARRYSET
     542                //      carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
     543                //      new_test = ast.BoolOp(ast.Or(), [ifNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
     544                //      new_else_part = ifNode.orelse + [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]
     545                //      return ast.If(new_test, ifNode.body, new_else_part)
     546               
     547                public void visitEnter(IfStmtNode node) { // current PabloS if statement implementation does not support n-bit CarryTest for Advance(x,n)
    102548                        assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) within if: illegal\n";
    103549                       
     
    109555                        }
    110556                       
    111                         if(!this.ciMode) { // while loop body
     557                        if(!this.isCiMode()) { // e.g. not within the context of the 1st iteration of a while loop body
    112558                                return;
    113559                        }
    114                                
    115                         // if test, replace if test
    116                         String lexeme = Lextant.OR.getPrimaryLexeme();
    117                         LextantToken binaryOperatorToken = LextantToken.make(node.getToken().getLocation(), lexeme, Lextant.OR);
    118                        
    119                         ASTNode lhs = Accessors.ifTest(node);
    120560
    121561                        IntegerConstantNode carryBaseNode = Generators.makeIntegerConstantNode(carryBase, node.getToken());
    122562                        IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    123                
     563                       
     564                        BinaryOperatorNode replacementIfTestNode = makeBitwiseOrCarryTest(Accessors.ifTest(node), carryBaseNode, carryCountNode);
     565                       
     566                        node.replaceChild(Accessors.ifTest(node), replacementIfTestNode);
     567                       
     568                        // else part, append CarryDequeueEnqueue call
     569                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
     570                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     571                                        node.getToken(),
     572                                        new ASTNode [] {carryBaseNode, carryCountNode});
     573                       
     574                        if (Accessors.hasElseBlockStmt(node)) {
     575                                Accessors.elseBlockStmt(node).appendChild(carryDequeueEnqueue);
     576                        } else {
     577                                BlockStmtNode blockStmtNode = Generators.makeBlockStmtNode(node.getToken());
     578                                blockStmtNode.appendChild(carryDequeueEnqueue);
     579                                node.appendChild(blockStmtNode);
     580                        }                               
     581                }
     582               
     583                public void visitEnter(WhileStmtNode node) {
     584
     585                        //          if self.carryout == '':
     586                        //            whileNode.test.args[0] = mkCall("simd_and", [whileNode.test.args[0], ast.Name('EOF_mask', ast.Load())])
     587                        //          carry_base = self.current_carry
     588                        //          assert adv_nCounter().count(whileNode) == 0, "Advance(x,n) within while: illegal\n"
     589                        //          carries = CarryCounter().count(whileNode)
     590                        //          #CARRYSET
     591                        //          if carries == 0: return whileNode
     592                        //          carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
     593                        //          local_carryvar = 'sub' + self.carryvar.id
     594                       
     595                        if(isFinalBlockMode()) {
     596                                ASTNode whileConditionNode = Accessors.whileTest(node);
     597                                ASTNode replacementNode = Generators.makeSIMDAndEOFMaskFuncCall(whileConditionNode, builtins2Lang);
     598                                node.replaceChild(whileConditionNode, replacementNode);                                 
     599                        }
     600               
     601                        assert (new AdvanceNCounterVisitor(node).count() == 0): "Advance(x,n) within if: illegal\n";
     602                       
     603                        int carryBase   = this.currentCarry;
     604                        int carryCount  = (new CarryCounterVisitor(node)).count();                     
     605               
     606                        if(carryCount == 0) {
     607                                return;
     608                        }
     609               
     610                        IntegerConstantNode carryBaseNode       = Generators.makeIntegerConstantNode(carryBase, node.getToken());
     611                        IntegerConstantNode carryCountNode      =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
     612                       
     613                        StringConstantNode localCarryName       = Generators.makeStringConstantNode(CarrySetBuiltins2Lang.LOCALCARRYQIDENTIFIER, node.getToken());
     614                       
     615
     616                        //          inner_while = CarryIntro(local_carryvar, '', self.carryout).generic_xfrm(copy.deepcopy(whileNode))
     617                        //          self.generic_visit(whileNode)
     618                        //          local_carry_decl = mkCallStmt('LocalCarryDeclare', [ast.Name(local_carryvar, ast.Load()), ast.Num(carries)])
     619                        //          inner_while.body.insert(0, local_carry_decl)
     620                        //          final_combine =
     621                        //                      mkCallStmt      (ast.Attribute(self.carryvar, 'CarryCombine', ast.Load()),
     622                        //                                                      [ast.Attribute(ast.Name(local_carryvar, ast.Load()),
     623////////////                    //                                                              'cq', ast.Load()),
     624                        //                                                              ast.Num(carry_base),
     625                        //                                                              ast.Num(carries)
     626                        //                                                      ]
     627                        //                                              )
     628                        //          inner_while.body.append(final_combine)                     
     629
     630                        //              translate inner while ciMode disabled and local carry object
     631                        WhileStmtNode innerWhile = node.deepCopy();
     632                        CarryIntroXFormer xFormer = new CarryIntroXFormer(Accessors.whileBlockStmt(innerWhile), builtins2Lang, carrySet2Lang);
     633                        xFormer.XForm(finalBlockMode, false, CarrySetBuiltins2Lang.LOCALCARRYQIDENTIFIER);
     634                       
     635                        FuncCallNode localCarryDeclare = (FuncCallNode) Generators.makeFuncCallNode(
     636                                        carrySet2Lang.getCode(CarrySetBuiltins.LOCALCARRYDECLARE),
     637                                        node.getToken(),
     638                                        new ASTNode [] {localCarryName, carryCountNode});
     639
     640                        Accessors.whileBlockStmt(innerWhile).insertChild(localCarryDeclare);
     641
     642                        FuncCallNode carryCombine = (FuncCallNode) Generators.makeFuncCallNode(
     643                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE),
     644                                        node.getToken(),
     645                                        new ASTNode [] {carryBaseNode, carryCountNode});
     646                       
     647                        Accessors.whileBlockStmt(innerWhile).appendChild(carryCombine);
     648                       
     649                        //
     650                        //          #CARRYSET
     651                        //          if self.carryin == '': new_test = whileNode.test
     652                        //          else: new_test = ast.BoolOp(ast.Or(), [whileNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
     653                        //          else_part = [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]   
     654                        //          return ast.If(new_test, whileNode.body + [inner_while], else_part)
     655                       
     656                       
     657                        // if condition
     658                        ASTNode ifTest = Accessors.whileTest(node).deepCopy();
     659                       
     660                        if(!isCiMode()) {
     661                                ifTest = Accessors.whileTest(node).deepCopy();
     662                        } else {                               
     663                                ifTest = makeBitwiseOrCarryTest(ifTest, carryBaseNode, carryCountNode);
     664                        }
     665                       
     666                        // if body
     667                        BlockStmtNode ifBlockStmtNode = Generators.makeBlockStmtNode(node.getToken());
     668                        ifBlockStmtNode.appendChild(Accessors.whileBlockStmt(node));
     669                        ifBlockStmtNode.appendChild(innerWhile);
     670                       
     671                        FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
     672                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
     673                                        node.getToken(),
     674                                        new ASTNode [] {carryBaseNode, carryCountNode});
     675                       
     676                        // else body                   
     677                        BlockStmtNode elseBlockStmtNode = Generators.makeBlockStmtNode(node.getToken());
     678                        elseBlockStmtNode.appendChild(carryDequeueEnqueue);
     679                       
     680                        IfStmtNode ifStmtNode = Generators.makeIfStmtNode(node.getToken(),
     681                                        ifTest,
     682                                        ifBlockStmtNode,
     683                                        elseBlockStmtNode);
     684                       
     685                        node.updateSelf(ifStmtNode);
     686                }
     687       
     688                // Helpers             
     689                private void replaceFuncCallNode(FuncCallNode node,
     690                                String targetPackage, String targetName,
     691                                List<ASTNode> arguments,
     692                                ASTNode call, IntegerConstantNode carry) {
     693                        FuncCallNode replacementNode;
     694       
     695                        List<ASTNode> args = new ArrayList<ASTNode>();
     696                                                                       
     697                        for(ASTNode arg : arguments) {
     698                                args.add(arg);
     699                        }       
     700                        args.add(call);
     701                        args.add(carry);
     702                       
     703                        replacementNode = Generators.makeFuncCallNode(
     704                                        new String [] {targetPackage, targetName},
     705                                        node.getToken(),
     706                                        args);
     707                       
     708                        node.updateSelf(replacementNode);
     709                }
     710       
     711                private BinaryOperatorNode makeBitwiseOrCarryTest(ASTNode ifTest,
     712                                IntegerConstantNode carryBaseNode,
     713                                IntegerConstantNode carryCountNode) {
     714       
     715                        ASTNode lhs = ifTest;
     716                               
     717                        String lexeme = Lextant.OR.getPrimaryLexeme();
     718                        LextantToken binaryOperatorToken = LextantToken.make(lhs.getToken().getLocation(), lexeme, Lextant.OR);
     719                       
    124720                        FuncCallNode rhs = (FuncCallNode) Generators.makeFuncCallNode(
    125                                         new String [] {CarrySetBuiltins.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySetBuiltins.CARRYTEST)},
    126                                         node.getToken(),
     721                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYTEST)},
     722                                        lhs.getToken(),
    127723                                        new ASTNode [] {carryBaseNode, carryCountNode});
    128724                       
     
    130726                                                                                                                                        rhs,
    131727                                                                                                                                        binaryOperatorToken);
    132                        
    133                         node.replaceChild(Accessors.ifTest(node), replacementIfTestNode);
    134                        
    135                         // else part, append CarryDequeueEnqueue call
    136                         FuncCallNode carryDequeueEnqueue = (FuncCallNode) Generators.makeFuncCallNode(
    137                                         new String [] {CarrySetBuiltins.CarryQ_IDENTIFIER, carrySet2Lang.getCode(CarrySetBuiltins.CARRYDEQUEUEENQUEUE)},
    138                                         node.getToken(),
    139                                         new ASTNode [] {carryBaseNode, carryCountNode});
    140                        
    141                         if (Accessors.hasElseBlockStmt(node)) {
    142                                 Accessors.elseBlockStmt(node).appendChild(carryDequeueEnqueue);
    143                         } else {
    144                                 BlockStmtNode blockStmtNode =
    145                                                 Generators.makeBlockStmtNode(LextantToken.make(node.getToken().getLocation(),
    146                                                                                                                         Lextant.LCURLY.getPrimaryLexeme(),
    147                                                                                                                         Lextant.LCURLY));
    148                                 blockStmtNode.appendChild(carryDequeueEnqueue);
    149                                 node.appendChild(blockStmtNode);
    150                         }
    151                                                
    152                 }
     728                        return replacementIfTestNode;
     729                }       
     730       
    153731        }
    154 }
    155 
    156 //class CarryIntro(ast.NodeXFormer):
    157 
    158 //        def generic_xfrm(self, node):
    159 //          self.current_carry = 0
    160 //          self.current_adv_n = 0
    161 //          carry_count = CarryCounter().count(node)
    162 //          adv_n_count = adv_nCounter().count(node)
    163 //          if carry_count == 0 and adv_n_count == 0: return node
    164 //          self.generic_visit(node)
    165 //          return node
    166 
    167 //def visit_If(self, ifNode):
    168 //carry_base = self.current_carry
    169 //carries = CarryCounter().count(ifNode)
    170 //assert adv_nCounter().count(ifNode) == 0, "Advance(x,n) within if: illegal\n"
    171 //self.generic_visit(ifNode)
    172 //if carries == 0 or self.carryin == "": return ifNode
    173 //#CARRYSET
    174 //carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
    175 //new_test = ast.BoolOp(ast.Or(), [ifNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
    176 //new_else_part = ifNode.orelse + [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]
    177 //return ast.If(new_test, ifNode.body, new_else_part)
    178 
    179 //        def visit_While(self, whileNode):
    180 //          if self.carryout == '':
    181 //            whileNode.test.args[0] = mkCall("simd_and", [whileNode.test.args[0], ast.Name('EOF_mask', ast.Load())])
    182 //          carry_base = self.current_carry
    183 //          assert adv_nCounter().count(whileNode) == 0, "Advance(x,n) within while: illegal\n"
    184 //          carries = CarryCounter().count(whileNode)
    185 //          #CARRYSET
    186 //          if carries == 0: return whileNode
    187 //          carry_arglist = [ast.Num(carry_base), ast.Num(carries)]
    188 //          local_carryvar = 'sub' + self.carryvar.id
    189 //          inner_while = CarryIntro(local_carryvar, '', self.carryout).generic_xfrm(copy.deepcopy(whileNode))
    190 //          self.generic_visit(whileNode)
    191 //          local_carry_decl = mkCallStmt('LocalCarryDeclare', [ast.Name(local_carryvar, ast.Load()), ast.Num(carries)])
    192 //          inner_while.body.insert(0, local_carry_decl)
    193 //          final_combine = mkCallStmt(ast.Attribute(self.carryvar, 'CarryCombine', ast.Load()), [ast.Attribute(ast.Name(local_carryvar, ast.Load()), 'cq', ast.Load()),ast.Num(carry_base), ast.Num(carries)])
    194 //          inner_while.body.append(final_combine)
    195 //          #CARRYSET
    196 //          if self.carryin == '': new_test = whileNode.test
    197 //          else: new_test = ast.BoolOp(ast.Or(), [whileNode.test, mkCall(ast.Attribute(self.carryvar, 'CarryTest', ast.Load()), carry_arglist)])
    198 //          else_part = [mkCallStmt(ast.Attribute(self.carryvar, 'CarryDequeueEnqueue', ast.Load()), carry_arglist)]   
    199 //          return ast.If(new_test, whileNode.body + [inner_while], else_part)
     732}       
  • proto/pablo/src/test/pabloS/PabloSTestHarness.java

    r2775 r2804  
    2828import compiler.transformer.visitors.AugAssignXFormer;
    2929import compiler.transformer.visitors.Bitwise2IDISAXFormer;
    30 import compiler.transformer.visitors.Pablo2CarryXFormer;
     30import compiler.transformer.visitors.CarryIntroXFormer;
    3131import compiler.transformer.visitors.StreamFuncVisitor;
    3232import compiler.transformer.visitors.helpers.AssertCompare;
     
    4646            BITWISE2IDISA("Bitwise2IDISAXFormer", true),
    4747            CARRYCOUNTER("CarryCounterVisitor", true),
    48             PABLO2CARRYQNOTFINALBLOCK("Pablo2CarryQXFormer/NotFinalBlock", true),
    49             PABLO2CARRYQFINALBLOCK("Pablo2CarryQXFormer/FinalBlock", true),
     48            //PABLO2CARRYQNOTFINALBLOCK("Pablo2CarryQXFormer/NotFinalBlock", true),
     49            //PABLO2CARRYQFINALBLOCK("Pablo2CarryQXFormer/FinalBlock", true),
    5050            CARRYINITTOONELIST("CarryInitToOneListVisitor", true),
    51             STREAMFUNCVISITOR("StreamFuncVisitor", true);
    52             //CARRYQINTROXFORMER("",true); // TODO
     51            STREAMFUNCVISITOR("StreamFuncVisitor", true),
     52            CARRYINTROXFORMERNOTFINALBLOCK("CarryIntroXFormer/NotFinalBlock", true),
     53            CARRYINTROXFORMERFINALBLOCK("CarryIntroXFormer/FinalBlock", true);
    5354            //ASSERTZERO("",true); // TODO
    5455           
     
    108109                                                        // TODO
    109110                                                        break;
    110                                                 case PABLO2CARRYQFINALBLOCK:
     111                                                case CARRYINTROXFORMERFINALBLOCK:
    111112                                                        isFinalBlock = true;
    112                                                         pablo2CarryQTest(fileAbsolutePath, isFinalBlock);
     113                                                        carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
    113114                                                        break; 
    114                                                 case PABLO2CARRYQNOTFINALBLOCK:
     115                                                case CARRYINTROXFORMERNOTFINALBLOCK:
    115116                                                        isFinalBlock = false;
    116                                                         pablo2CarryQTest(fileAbsolutePath, isFinalBlock);
     117                                                        carryIntroXFormerTest(fileAbsolutePath, isFinalBlock);
    117118                                                        break;                 
    118119                                                case CARRYINITTOONELIST:
     
    201202         * @throws FileNotFoundException - Final Block
    202203         */
    203         public static void pablo2CarryQTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
     204       
     205        /*
     206         * Deprecated.
     207         */
     208        public static void carryIntroXFormerTest(String fileAbsolutePath, boolean isFinalBlock) throws FileNotFoundException {
    204209                LexicalController lexController = LexicalController.make(fileAbsolutePath);
    205210                ASTNode syntaxTree = Parser.parse(lexController);
     
    213218                        ASTNode value = entry.getValue();                               
    214219                        CarrySetBuiltins2Lang carrySet2CPP = new CarrySetBuiltins2CPP();
    215                         Pablo2CarryXFormer pablo2CarryQ = new Pablo2CarryXFormer(value, builtins2CPP, carrySet2CPP);
     220                        CarryIntroXFormer pablo2CarryQ = new CarryIntroXFormer(value, builtins2CPP, carrySet2CPP);
    216221                        pablo2CarryQ.XForm(isFinalBlock);
    217222                }   
     
    221226               
    222227        }       
     228       
    223229       
    224230//  CarryCounter carryCounter = new CarryCounter(node);
Note: See TracChangeset for help on using the changeset viewer.