Changeset 2816


Ignore:
Timestamp:
Jan 19, 2013, 3:22:41 PM (6 years ago)
Author:
ksherdy
Message:

Milestone - PabloJ passes XML conformance test. CarryXFormer fixes. Test cases updated.

Location:
proto/pablo
Files:
11 edited

Legend:

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

    r2815 r2816  
    55// PabloBlock (block-at-a-time language)
    66//
    7 // COMMENTS -   
     7// Type System
     8//
     9// Primitive Types
     10//
     11// uint8
     12// uint16
     13// uint32
     14// uint64
     15// uint128
     16// uint256
     17// BitBlock - a special type that evaluates uint128 or uint256
     18//            at compile time based on the target architecture
     19// Boolean
     20// String Constant
     21//
     22// Compound Types
     23//
     24// ...
     25//
     26// Comments
    827//
    928//                      PabloB expression evaluate to types ? -> Add type checking support.
    1029//                      Add support for a boolean type.
    11 //
    12 //
    13 // TODO -       
    1430//                      Add support for IDISA operations.
    1531//                      Add support for '+', '-'.
     
    1733//                      Stream constant type.
    1834//                      Map PabloS builtins to PabloB equivalents. Effectively expand PabloS macros to support an optimization pass the
     35//                      Remove stream type from PabloB definition.
     36//                      PabloS stream type maps to PabloB BitBlock type.
     37//                      PabloS stream<2^k> operations map to IDISA supported Pablo operations.
    1938//                      PabloB intermediate language level.
    2039//             
     
    192211                                        ;
    193212                                                                                                                                                                                       
    194         constant                                #->  stringConstant | signedIntegerConstant | streamConstant
    195        
     213        constant                                #->  stringConstant | signedIntegerConstant
     214               
    196215        streamConstant                  -> INTEGER_CONST {@value = @@value;} ;
    197216       
  • proto/pablo/input/grammar/scatter/pabloS.scatter

    r2815 r2816  
    44//
    55// PabloS (unbounded stream language)
     6//
     7// Type System
     8//
     9// Primitive Types
     10//
     11// Stream 2^k type
     12// Integer Constant
     13// String Constant
     14// ..
    615//
    716context main {
     
    121130        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
    122131
    123         funcCallArgList                 -> (expr (COMMA expr)*)? ;     
     132        funcCallArgList                 -> ( expr (COMMA expr)* )? ;   
    124133               
    125134        assignOperator                  -> ASSIGN | AND_ASSIGN | OR_ASSIGN | XOR_ASSIGN ;                               
  • proto/pablo/input/test/visitors/CarryIntroXFormer/FinalBlock/atEOF.pablos

    r2811 r2816  
    44                       
    55        // Translate atEOF(X) calls in non-final blocks to andc(X, EOF_mask)
    6         R = simd_andc(X, EOF_mask);
     6        R = simd_andc(EOF_mask, X);
    77        R = atEOF(X);
    88}
  • proto/pablo/input/test/visitors/CarryIntroXFormer/FinalBlock/pablo2CarryQ.pablos

    r2811 r2816  
    2525        R = pablo.ScanThru(C,X);
    2626
    27         R = carryQ.BitBlock_scanthru_ci_co(C,simd_andc(X, EOF_mask),carryQ.get_carry_in(6),6);
     27        R = carryQ.BitBlock_scanthru_ci_co(C,simd_andc(EOF_mask, X),carryQ.get_carry_in(6),6);
    2828        R = ScanTo(C,X);
    2929       
    30         R = carryQ.BitBlock_scanthru_ci_co(C,simd_andc(X, EOF_mask),carryQ.get_carry_in(7),7); 
     30        R = carryQ.BitBlock_scanthru_ci_co(C,simd_andc(EOF_mask, X),carryQ.get_carry_in(7),7); 
    3131        R = pablo.ScanTo(C,X);
    3232
     
    3737        R = pablo.AdvanceThenScanThru(C,X);
    3838
    39         R = carryQ.BitBlock_advance_then_scanthru(C,simd_andc(X, EOF_mask),carryQ.get_carry_in(10),10);                 
     39        R = carryQ.BitBlock_advance_then_scanthru(C,simd_andc(EOF_mask, X),carryQ.get_carry_in(10),10);                 
    4040        R = AdvanceThenScanTo(C,X);
    4141       
    42         R = carryQ.BitBlock_advance_then_scanthru(C,simd_andc(X, EOF_mask),carryQ.get_carry_in(11),11);
     42        R = carryQ.BitBlock_advance_then_scanthru(C,simd_andc(EOF_mask, X),carryQ.get_carry_in(11),11);
    4343        R = pablo.AdvanceThenScanTo(C,X);
    4444
  • proto/pablo/input/test/visitors/CarryIntroXFormer/NotFinalBlock/pablo2CarryQ.pablos

    r2811 r2816  
    2525        R = pablo.ScanThru(C,X);
    2626
    27         R = carryQ.BitBlock_scanthru_ci_co(C,X,carryQ.get_carry_in(6),6);
     27        R = carryQ.BitBlock_scanthru_ci_co(C,simd_not(X),carryQ.get_carry_in(6),6);
    2828        R = ScanTo(C,X);
    2929       
    30         R = carryQ.BitBlock_scanthru_ci_co(C,X,carryQ.get_carry_in(7),7);       
     30        R = carryQ.BitBlock_scanthru_ci_co(C,simd_not(X),carryQ.get_carry_in(7),7);     
    3131        R = pablo.ScanTo(C,X);
    3232
     
    3737        R = pablo.AdvanceThenScanThru(C,X);
    3838
    39         R = carryQ.BitBlock_advance_then_scanthru(C,X,carryQ.get_carry_in(10),10);                     
     39        R = carryQ.BitBlock_advance_then_scanthru(C,simd_not(X),carryQ.get_carry_in(10),10);                   
    4040        R = AdvanceThenScanTo(C,X);
    4141       
    42         R = carryQ.BitBlock_advance_then_scanthru(C,X,carryQ.get_carry_in(11),11);     
     42        R = carryQ.BitBlock_advance_then_scanthru(C,simd_not(X),carryQ.get_carry_in(11),11);   
    4343        R = pablo.AdvanceThenScanTo(C,X);
    4444
  • proto/pablo/output/cpplang/pablo_definitions.hpp

    r2815 r2816  
    187187        {
    188188               
    189         };
     189        }
    190190         
    191191        IDISA_INLINE void do_block(struct Basis_bits & basis_bits, struct Lex & lex, struct U8 & u8)
     
    536536                        carryQ.CarryDequeueEnqueue(0, 10);
    537537                }
    538                 carryQ.CarryQ_Adjust(10);
    539538        }
    540539       
     
    547546        {
    548547                carryQ.cq[2] = carryQ.carry_flip(carryQ.cq[2]);
    549         };
     548        }
    550549         
    551550        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct CtCDPI_Callouts & ctCDPI_Callouts, struct Check_streams & check_streams)
     
    604603                                }
    605604                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    606                                 PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, PI_closer, carryQ.get_carry_in(7), 7);
     605                                PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(7), 7);
    607606                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    608607                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    615614                        {
    616615                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    617                                 CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, CD_closer, carryQ.get_carry_in(8), 8);
     616                                CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(8), 8);
    618617                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    619618                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    629628                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    630629                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(10), 10), carryQ.get_carry_in(11), 11);
    631                                 Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, DoubleHyphen, carryQ.get_carry_in(12), 12), carryQ.get_carry_in(13), 13);
     630                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carryQ.get_carry_in(12), 12), carryQ.get_carry_in(13), 13);
    632631                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    633632                                {
     
    647646                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    648647                        }
    649                         CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, CtCDPI_opener, carryQ.get_carry_in(15), 15);
     648                        CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(15), 15);
    650649                        while (bitblock::any(CtCDPI_Cursor))
    651650                        {
     
    653652                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    654653                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    655                                 BitBlock CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), 0, 0);
     654                                BitBlock CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    656655                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    657656                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
     
    659658                                {
    660659                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    661                                         PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, 0, 1);
     660                                        PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    662661                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    663                                         BitBlock PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, 0, 2);
     662                                        BitBlock PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    664663                                        BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    665664                                        BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    666                                         PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(subcarryQ.BitBlock_advance_ci_co(PI_noWS, 0, 3), PI_closer)));
     665                                        PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(subcarryQ.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    667666                                        if (bitblock::any(PI_error))
    668667                                        {
     
    670669                                        }
    671670                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    672                                         PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, PI_closer, 0, 4);
     671                                        PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 4);
    673672                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    674673                                        CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    677676                                {
    678677                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    679                                         CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, CD_closer, 0, 5);
     678                                        CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 5);
    680679                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    681680                                        CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    684683                                {
    685684                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    686                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, 0, 6);
     685                                        Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    687686                                        BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    688                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, 0, 7), 0, 8);
    689                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, DoubleHyphen, 0, 9), 0, 10);
     687                                        Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
     688                                        Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    690689                                        if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    691690                                        {
     
    696695                                }
    697696                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    698                                 ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, 0, 11);
     697                                ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    699698                                if (bitblock::any(simd<1>::constant<0>()))
    700699                                {
    701700                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    702701                                }
    703                                 CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, CtCDPI_opener, 0, 12);
     702                                CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 12);
    704703                                carryQ.CarryCombine(subcarryQ.cq, 3, 13);
    705704                        }
     
    771770                                }
    772771                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    773                                 PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(PI_closer, EOF_mask), carryQ.get_carry_in(7), 7);
     772                                PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(7), 7);
    774773                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    775774                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    782781                        {
    783782                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    784                                 CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(CD_closer, EOF_mask), carryQ.get_carry_in(8), 8);
     783                                CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(8), 8);
    785784                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    786785                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    796795                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    797796                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(10), 10), carryQ.get_carry_in(11), 11);
    798                                 Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(DoubleHyphen, EOF_mask), carryQ.get_carry_in(12), 12), carryQ.get_carry_in(13), 13);
     797                                Ct_Cursor = carryQ.BitBlock_advance_ci_co(carryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carryQ.get_carry_in(12), 12), carryQ.get_carry_in(13), 13);
    799798                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    800799                                {
     
    810809                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    811810                        ctCDPI_mask = carryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(14), 14);
    812                         if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    813                         {
    814                                 assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    815                         }
    816                         CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(CtCDPI_opener, EOF_mask), carryQ.get_carry_in(15), 15);
     811                        if (bitblock::any(simd_andc(EOF_mask, ctCDPI_mask)))
     812                        {
     813                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(EOF_mask, ctCDPI_mask));
     814                        }
     815                        CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(15), 15);
    817816                        while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
    818817                        {
     
    820819                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    821820                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    822                                 BitBlock CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), 0, 0);
     821                                BitBlock CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    823822                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    824823                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
     
    826825                                {
    827826                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    828                                         PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, 0, 1);
     827                                        PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    829828                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    830                                         BitBlock PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, 0, 2);
     829                                        BitBlock PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    831830                                        BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    832831                                        BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    833                                         PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(subcarryQ.BitBlock_advance_ci_co(PI_noWS, 0, 3), PI_closer)));
     832                                        PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(subcarryQ.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    834833                                        if (bitblock::any(PI_error))
    835834                                        {
     
    837836                                        }
    838837                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    839                                         PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(PI_closer, EOF_mask), 0, 4);
     838                                        PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 4);
    840839                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    841840                                        CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    844843                                {
    845844                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    846                                         CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(CD_closer, EOF_mask), 0, 5);
     845                                        CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 5);
    847846                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    848847                                        CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    851850                                {
    852851                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    853                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, 0, 6);
     852                                        Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    854853                                        BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    855                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, 0, 7), 0, 8);
    856                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(DoubleHyphen, EOF_mask), 0, 9), 0, 10);
     854                                        Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
     855                                        Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    857856                                        if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    858857                                        {
     
    863862                                }
    864863                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    865                                 ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, 0, 11);
    866                                 if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    867                                 {
    868                                         assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    869                                 }
    870                                 CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(CtCDPI_opener, EOF_mask), 0, 12);
     864                                ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
     865                                if (bitblock::any(simd_andc(EOF_mask, ctCDPI_mask)))
     866                                {
     867                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(EOF_mask, ctCDPI_mask));
     868                                }
     869                                CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
    871870                                carryQ.CarryCombine(subcarryQ.cq, 3, 13);
    872871                        }
     
    880879                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
    881880                marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
    882                 carryQ.CarryQ_Adjust(17);
    883881        }
    884882       
     
    891889        {
    892890               
    893         };
     891        }
    894892         
    895893        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Tag_Callouts & tag_Callouts)
     
    933931                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    934932                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    935                                 BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, DQuoteDelim, carryQ.get_carry_in(5), 5);
    936                                 BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, SQuoteDelim, carryQ.get_carry_in(6), 6);
     933                                BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), 5);
     934                                BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), 6);
    937935                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    938936                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
     
    957955                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    958956                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    959                                         BitBlock AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, 0, 0);
     957                                        BitBlock AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    960958                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    961959                                        if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    962960                                        {
    963                                                 EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, 0, 1);
     961                                                EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    964962                                        }
    965963                                        else
     
    968966                                        }
    969967                                        ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    970                                         BitBlock AttValPos = subcarryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, 0, 2);
     968                                        BitBlock AttValPos = subcarryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    971969                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    972970                                        BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    973971                                        BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    974                                         BitBlock DQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, DQuoteDelim, 0, 3);
    975                                         BitBlock SQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, SQuoteDelim, 0, 4);
     972                                        BitBlock DQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), 3);
     973                                        BitBlock SQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), 4);
    976974                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    977975                                        ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    978                                         BitBlock AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, 0, 5);
     976                                        BitBlock AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    979977                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    980978                                        if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    981979                                        {
    982                                                 AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, 0, 6);
     980                                                AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    983981                                                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    984982                                                AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    10651063                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    10661064                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1067                                 BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(DQuoteDelim, EOF_mask), carryQ.get_carry_in(5), 5);
    1068                                 BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(SQuoteDelim, EOF_mask), carryQ.get_carry_in(6), 6);
     1065                                BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), 5);
     1066                                BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), 6);
    10691067                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    10701068                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
     
    10891087                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    10901088                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1091                                         BitBlock AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, 0, 0);
     1089                                        BitBlock AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    10921090                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    10931091                                        if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    10941092                                        {
    1095                                                 EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, 0, 1);
     1093                                                EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    10961094                                        }
    10971095                                        else
     
    11001098                                        }
    11011099                                        ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1102                                         BitBlock AttValPos = subcarryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, 0, 2);
     1100                                        BitBlock AttValPos = subcarryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    11031101                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    11041102                                        BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    11051103                                        BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1106                                         BitBlock DQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(DQuoteDelim, EOF_mask), 0, 3);
    1107                                         BitBlock SQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(SQuoteDelim, EOF_mask), 0, 4);
     1104                                        BitBlock DQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), 3);
     1105                                        BitBlock SQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), 4);
    11081106                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    11091107                                        ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1110                                         BitBlock AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, 0, 5);
     1108                                        BitBlock AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    11111109                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    11121110                                        if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    11131111                                        {
    1114                                                 AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, 0, 6);
     1112                                                AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    11151113                                                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    11161114                                                AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    11541152                }
    11551153                tag_Callouts.AttVal_spans = carryQ.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), 12);
    1156                 carryQ.CarryQ_Adjust(13);
    11571154        }
    11581155       
     
    11651162        {
    11661163               
    1167         };
     1164        }
    11681165         
    11691166        IDISA_INLINE void do_block(struct Lex & lex, struct Marker & marker, struct Ref_Callouts & ref_Callouts)
     
    12381235                        carryQ.CarryDequeueEnqueue(0, 6);
    12391236                }
    1240                 carryQ.CarryQ_Adjust(6);
    12411237        }
    12421238       
     
    12491245        {
    12501246               
    1251         };
     1247        }
    12521248         
    12531249        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams)
     
    13001296                check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
    13011297                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    1302                 carryQ.CarryQ_Adjust(9);
    13031298        }
    13041299       
     
    13111306        {
    13121307               
    1313         };
     1308        }
    13141309         
    13151310        IDISA_INLINE void do_block(struct Marker & marker, struct Tag_Callouts & tag_Callouts, struct Check_streams & check_streams)
  • proto/pablo/src/compiler/ast/pabloS/Generators.java

    r2809 r2816  
    230230                return ifStmtNode;
    231231        }
     232
     233        ////////////////////////////////////////////////////////////////////////////
     234        // Static factories for specific nodes
     235        //
     236        ////////////////////////////////////////////////////////////////////////////   
    232237       
    233238        public static FuncCallNode makeSIMDAndEOFMaskFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
     
    244249                return Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), node.getToken(), args);
    245250        }       
    246                
     251
     252        public static FuncCallNode makeSIMDEOFMaskAndCNodeFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
     253                List<ASTNode> args = new ArrayList<ASTNode>();
     254                args.add(Generators.makeIdentifierNode(builtins2Lang.getCode(Builtins.EOFMASK), node.getToken()));
     255                args.add(node);
     256                return Generators.makeFuncCallNode(SIMD.ANDC.idisaName(), node.getToken(), args);
     257        }               
     258       
     259        public static FuncCallNode makeSIMDNotFuncCall(ASTNode node, Builtins2Lang builtins2Lang) {
     260                List<ASTNode> args = new ArrayList<ASTNode>();
     261                args.add(node);
     262                return Generators.makeFuncCallNode(SIMD.NOT.idisaName(), node.getToken(), args);
     263        }               
     264       
    247265        public static ParameterNode makeEOFMaskParameter(Builtins2Lang builtins2Lang, Token locationToken) {
    248266               
  • proto/pablo/src/compiler/codeGenerator/visitors/CPPUnparser.java

    r2815 r2816  
    142142                code.addLine("{");
    143143                code.addAll(initBlockCodeStore, 1);
    144                 code.dedentedLine("};");               
     144                code.dedentedLine("}");         
    145145               
    146146                code.addLine(" "); // a blank line
  • proto/pablo/src/compiler/transformer/PabloSTransformer.java

    r2804 r2816  
    8282            advanceCombiner.XForm();
    8383
     84   
     85           
    8486            CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
    8587                carryQIntro.XForm(finalBlockMode);             
    86            
     88
     89                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
     90                bitwiseToIDISA.XForm();                 
    8791                // Dependency on CarryIntroXFormer to count PabloS builtins that produce carry values.
    8892                //Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
    8993                //pablo2CarryXFormer.XForm(finalBlockMode);                         
    90                                    
    91                 Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
    92                 bitwiseToIDISA.XForm();
    93                                                
     94                                                                               
    9495                return decoratedTree;
    9596               
  • proto/pablo/src/compiler/transformer/visitors/Bitwise2IDISAXFormer.java

    r2815 r2816  
    1616        }
    1717       
    18         public ASTNode XForm() { // Order AST tranversal Binary <- Unary <- General
     18        public ASTNode XForm() { // Order AST traversal Binary <- Unary <- General
    1919               
    2020                Bitwise2IDISABinaryOperatorXFormer binOpXformer = new Bitwise2IDISABinaryOperatorXFormer();
  • proto/pablo/src/compiler/transformer/visitors/CarryIntroXFormer.java

    r2815 r2816  
    180180                               
    181181                                BlockStmtNode blockStmtNode = Accessors.blockStmtNode(node);
    182                                 blockStmtNode.appendChild(carryAdjustFuncCall);
    183                                        
    184                         }                      
    185 
     182                                if(!isFinalBlockMode()) {
     183                                        blockStmtNode.appendChild(carryAdjustFuncCall);
     184                                }       
     185                        }               
    186186                }               
    187187               
     
    227227                                                new ASTNode [] {currentAdvN});
    228228                        } else {
    229                                 carryCall = Generators.makeIntegerConstantNode(0, node.getToken());
    230                                
    231                                 advNCall = Generators.makeIntegerConstantNode(0, node.getToken());
     229                                carryCall = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());
     230                                advNCall = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());
    232231                        }
    233232                                               
     
    319318                       
    320319                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.ADVANCETHENSCANTO.pabloName(), Builtins.ADVANCETHENSCANTO.argCount())) {
     320                                ASTNode argNode = Accessors.funcCallArg(node, 1);
    321321                                if(isFinalBlockMode()) {
    322                                         ASTNode argNode = Accessors.funcCallArg(node, 1);
    323                                         replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    324                                         Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);                                   
     322                                        replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);
     323                                } else {
     324                                        replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
    325325                                }
     326                                Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);
    326327                               
    327328                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     
    390391       
    391392                        else if (BuiltinsUtil.isCall(node, BuiltinsUtil.BUILTIN_PACKAGE_NAME, Builtins.SCANTO.pabloName(), Builtins.SCANTO.argCount())) {
     393                               
     394                                ASTNode argNode = Accessors.funcCallArg(node, 1);
    392395                                if(isFinalBlockMode()) {
    393                                         ASTNode argNode = Accessors.funcCallArg(node, 1);
    394                                         replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
    395                                         Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);                                   
     396                                        replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);
     397                                                                               
     398                                } else {
     399                                        replacementNode = Generators.makeSIMDNotFuncCall(argNode, builtins2Lang);
    396400                                }
     401                                Accessors.funcCallArgsListNode(node).replaceChild(argNode, replacementNode);
    397402                               
    398403                                List<ASTNode> arguments = Accessors.funcCallArgsListNode(node).getChildren();
     
    481486                                if(isFinalBlockMode()) {
    482487                                        ASTNode argNode = Accessors.funcCallArg(node, 0);
    483                                         replacementNode = Generators.makeSIMDAndCEOFMaskFuncCall(argNode, builtins2Lang);
     488                                        replacementNode = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argNode, builtins2Lang);
    484489                                } else {
    485490                                        replacementNode = Generators.makeFuncCallNode(SIMD.CONSTANT.idisaConstantName(1, 0), node.getToken());                                 
     
    561566
    562567                        IntegerConstantNode carryBaseNode = Generators.makeIntegerConstantNode(carryBase, node.getToken());
    563                         IntegerConstantNode carryCountNode =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
     568                        IntegerConstantNode carryCountNode = Generators.makeIntegerConstantNode(carryCount, node.getToken());
    564569                       
    565570                        BinaryOperatorNode replacementIfTestNode = makeBitwiseOrCarryTest(Accessors.ifTest(node), carryBaseNode, carryCountNode);
     
    610615               
    611616                        IntegerConstantNode carryBaseNode       = Generators.makeIntegerConstantNode(carryBase, node.getToken());
    612                         IntegerConstantNode carryCountNode      =  Generators.makeIntegerConstantNode(carryCount, node.getToken());
    613                        
    614                         // TODO - Update to Compound Variable
     617                        IntegerConstantNode carryCountNode      = Generators.makeIntegerConstantNode(carryCount, node.getToken());
    615618                       
    616619                        IdentifierNode localCarryId                     
    617                                         = Generators.makeIdentifierNode(CarrySetBuiltins2Lang.LOCALCARRYQNAME, node.getToken());
     620                                                                = Generators.makeIdentifierNode(CarrySetBuiltins2Lang.LOCALCARRYQNAME,
     621                                                                                                                                node.getToken());
     622                       
     623                        CompoundIdentifierNode localCarryQArrayQName   
     624                                                                = Generators.makeCompoundIdentifierNode(
     625                                                                                new String [] {CarrySetBuiltins2Lang.LOCALCARRYQNAME, CarrySetBuiltins2Lang.LOCALCARRYQARRAYNAME},
     626                                                                                node.getToken());
    618627                       
    619628                        CompoundIdentifierNode localCarryQArrayQName =
     
    659668
    660669                        FuncCallNode carryCombine = (FuncCallNode) Generators.makeFuncCallNode(
    661                                         new String [] { CarrySetBuiltins2Lang.CARRYQNAME,
    662                                         carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE)},
     670                                        new String [] {getCarrySetIdentifier(), carrySet2Lang.getCode(CarrySetBuiltins.CARRYCOMBINE)},
    663671                                        node.getToken(),
    664672                                        new ASTNode [] {localCarryQArrayQName, carryBaseNode, carryCountNode});
Note: See TracChangeset for help on using the changeset viewer.