Changeset 2967


Ignore:
Timestamp:
Mar 23, 2013, 7:55:13 PM (5 years ago)
Author:
ksherdy
Message:

Code comments and clean up.

Location:
proto/pabloj/trunk
Files:
1 deleted
11 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/docs/notes

    r2932 r2967  
    1 State of PabloJ Compiler
    2 
     1================================================================================
     2PabloJ Compiler Design
     3================================================================================
    34This document describes the state of the PabloJ compiler at Version 0.8.0.
     5Original implementation is modelled on the Pablo Python compiler version 2615.
    46
    57Version 0.8.0
    68
    7 Implements basic carry macro support.
     9Carry macro style support.
    810Validates against XMLWF test suite.
    9 Validates against larger XML files.
    10 
    11 Modelled on Python/Pablo version 2615.
    12 
    13 -----
    14 
    15 Pablo vs. PabloJ Implementation Differences
    16 
    17 (1) Explicit local variable declarations with explicit types.
     11Validates against large XML file set (roads.gml, ...) .
     12
     13================================================================================
     14PabloS Visitors
     15================================================================================
     16
     171. Wrap all PabloS conditional in BitBlock::any() calls.
     18
     19================================================================================
     20Pablo vs. PabloJ
     21================================================================================
     22
     231. PabloJ requires explicit variable declarations
    1824
    1925e.g. bitblock s; s = simd::constant<1>(0);
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r2948 r2967  
    9595   
    9696    //
    97         // f u n c t i o n   d e c l a r a t i o n s ?                                                 
     97        // f u n c t i o n   d e c l a r a t i o n s                                                    
    9898        //
    9999        funcDef                 -> FUNCTION returnType funcName LROUND parameterList? RROUND blockStmt TERMINATOR?;                             
  • proto/pabloj/trunk/input/templates/cpplang/pablo_definitions.template

    r2933 r2967  
    1616#ifndef PABLO_DEFINITIONS_HPP
    1717#define PABLO_DEFINITIONS_HPP
    18 
    19 #define LocalCarryDeclare(name, count)\
    20 CarryArray<count, 0> name;\
    2118
    2219// runtime libraries
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r2959 r2967  
    296296                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
    297297                BitBlock u8anyscope = simd<1>::constant<0>();
    298                 if (bitblock::any(simd_or(basis_bits.bit_0, carryQ.PabloJCarryTest(0, 10))))
     298                if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
    299299                {
    300300                        u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
     
    311311                        u8.badprefix = simd_or(temp68, temp71);
    312312                        u8_error = u8.badprefix;
    313                         u8.scope22 = carryQ.BitBlock_advance_ci_co(u8.prefix2, carryQ.get_carry_in(0), 0);
     313                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
    314314                        u8anyscope = u8.scope22;
    315                         if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carryQ.PabloJCarryTest(1, 9))))
     315                        if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
    316316                        {
    317317                                BitBlock xE0 = simd_andc(u8.prefix3, temp36);
     
    328328                                u8.xBF = simd_and(temp73, temp23);
    329329                                u8.xBE = simd_and(temp73, temp15);
    330                                 u8.scope32 = carryQ.BitBlock_advance_ci_co(u8.prefix3, carryQ.get_carry_in(1), 1);
    331                                 u8.scope33 = carryQ.BitBlock_advance_ci_co(u8.scope32, carryQ.get_carry_in(2), 2);
    332                                 u8.scope42 = carryQ.BitBlock_advance_ci_co(u8.prefix4, carryQ.get_carry_in(3), 3);
    333                                 u8.scope43 = carryQ.BitBlock_advance_ci_co(u8.scope42, carryQ.get_carry_in(4), 4);
    334                                 u8.scope44 = carryQ.BitBlock_advance_ci_co(u8.scope43, carryQ.get_carry_in(5), 5);
    335                                 BitBlock E0_F0_scope = carryQ.BitBlock_advance_ci_co(simd_or(xE0, xF0), carryQ.get_carry_in(6), 6);
    336                                 BitBlock ED_F4_scope = carryQ.BitBlock_advance_ci_co(simd_or(xED, xF4), carryQ.get_carry_in(7), 7);
     330                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
     331                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
     332                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
     333                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
     334                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
     335                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.CarryAt(6), 6);
     336                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.CarryAt(7), 7);
    337337                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    338338                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    339339                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    340340                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    341                                 u8.xEF_scope = carryQ.BitBlock_advance_ci_co(xEF, carryQ.get_carry_in(8), 8);
     341                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    342342                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    343343                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    347347                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    348348                                u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    349                                 BitBlock EF_BF_pending = carryQ.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(9), 9);
     349                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
    350350                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    351351                        }
    352352                        else
    353353                        {
    354                                 carryQ.CarryDequeueEnqueue(1, 9);
     354                                carry_set_0.CarryDequeueEnqueue(1, 9);
    355355                        }
    356356                        BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
     
    362362                else
    363363                {
    364                         carryQ.CarryDequeueEnqueue(0, 10);
    365                 }
    366                 carryQ.CarryQ_Adjust(10);
     364                        carry_set_0.CarryDequeueEnqueue(0, 10);
     365                }
     366                carry_set_0.CarryAdjust(10);
    367367        }
    368368       
     
    471471                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
    472472                BitBlock u8anyscope = simd<1>::constant<0>();
    473                 if (bitblock::any(simd_or(basis_bits.bit_0, carryQ.PabloJCarryTest(0, 10))))
     473                if (bitblock::any(simd_or(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
    474474                {
    475475                        u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
     
    486486                        u8.badprefix = simd_or(temp68, temp71);
    487487                        u8_error = u8.badprefix;
    488                         u8.scope22 = carryQ.BitBlock_advance_ci_co(u8.prefix2, carryQ.get_carry_in(0), 0);
     488                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
    489489                        u8anyscope = u8.scope22;
    490                         if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carryQ.PabloJCarryTest(1, 9))))
     490                        if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
    491491                        {
    492492                                BitBlock xE0 = simd_andc(u8.prefix3, temp36);
     
    503503                                u8.xBF = simd_and(temp73, temp23);
    504504                                u8.xBE = simd_and(temp73, temp15);
    505                                 u8.scope32 = carryQ.BitBlock_advance_ci_co(u8.prefix3, carryQ.get_carry_in(1), 1);
    506                                 u8.scope33 = carryQ.BitBlock_advance_ci_co(u8.scope32, carryQ.get_carry_in(2), 2);
    507                                 u8.scope42 = carryQ.BitBlock_advance_ci_co(u8.prefix4, carryQ.get_carry_in(3), 3);
    508                                 u8.scope43 = carryQ.BitBlock_advance_ci_co(u8.scope42, carryQ.get_carry_in(4), 4);
    509                                 u8.scope44 = carryQ.BitBlock_advance_ci_co(u8.scope43, carryQ.get_carry_in(5), 5);
    510                                 BitBlock E0_F0_scope = carryQ.BitBlock_advance_ci_co(simd_or(xE0, xF0), carryQ.get_carry_in(6), 6);
    511                                 BitBlock ED_F4_scope = carryQ.BitBlock_advance_ci_co(simd_or(xED, xF4), carryQ.get_carry_in(7), 7);
     505                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
     506                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
     507                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
     508                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
     509                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
     510                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.CarryAt(6), 6);
     511                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.CarryAt(7), 7);
    512512                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    513513                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    514514                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    515515                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    516                                 u8.xEF_scope = carryQ.BitBlock_advance_ci_co(xEF, carryQ.get_carry_in(8), 8);
     516                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
    517517                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    518518                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    522522                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    523523                                u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    524                                 BitBlock EF_BF_pending = carryQ.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ.get_carry_in(9), 9);
     524                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
    525525                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    526526                        }
    527527                        else
    528528                        {
    529                                 carryQ.CarryDequeueEnqueue(1, 9);
     529                                carry_set_0.CarryDequeueEnqueue(1, 9);
    530530                        }
    531531                        BitBlock u8mismatch = simd_xor(u8anyscope, u8.suffix);
     
    537537                else
    538538                {
    539                         carryQ.CarryDequeueEnqueue(0, 10);
     539                        carry_set_0.CarryDequeueEnqueue(0, 10);
    540540                }
    541541        }
    542542       
    543         CarryDeclare(carryQ, 10, 0);
     543        CarryDeclare(carry_set_0, 10, 0);
    544544};
    545545 
     
    548548        Parse_CtCDPI()
    549549        {
    550                 carryQ.cq[2] = carryQ.carry_flip(carryQ.cq[2]);
     550                carry_set_0.cq[2] = carry_set_0.CarryFlip(carry_set_0.cq[2]);
    551551        }
    552552         
     
    566566                BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
    567567                BitBlock w = simd_or(lex.Hyphen, lex.QMark);
    568                 BitBlock v1 = carryQ.BitBlock_advance_n_<1>(v, carryQ.get_pending64(0), 0);
    569                 BitBlock w1 = carryQ.BitBlock_advance_n_<1>(w, carryQ.get_pending64(1), 1);
     568                BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
     569                BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    570570                BitBlock LAngle_scope = simd_andc(v1, w1);
    571571                BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
     
    574574                BitBlock CD_closer = simd<1>::constant<0>();
    575575                BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    576                 if (bitblock::any(simd_or(lex.RBracket, carryQ.PabloJCarryTest(0, 2))))
    577                 {
    578                         BitBlock DoubleRBracket = simd_and(carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(0), 0), lex.RBracket);
    579                         CD_closer = simd_and(carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(1), 1), lex.RAngle);
     576                if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
     577                {
     578                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.CarryAt(0), 0), lex.RBracket);
     579                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.CarryAt(1), 1), lex.RAngle);
    580580                }
    581581                else
    582582                {
    583                         carryQ.CarryDequeueEnqueue(0, 2);
     583                        carry_set_0.CarryDequeueEnqueue(0, 2);
    584584                }
    585585                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    586                 BitBlock CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(2), 2);
    587                 if (bitblock::any(simd_or(CtCDPI_Cursor, carryQ.PabloJCarryTest(3, 13))))
     586                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.CarryAt(2), 2);
     587                if (bitblock::any(simd_or(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
    588588                {
    589589                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    590590                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    591                         BitBlock CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(3), 3);
     591                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.CarryAt(3), 3);
    592592                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    593593                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    594                         if (bitblock::any(simd_or(PI_Cursor, carryQ.PabloJCarryTest(4, 4))))
     594                        if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    595595                        {
    596596                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    597                                 PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(4), 4);
     597                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.CarryAt(4), 4);
    598598                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    599                                 BitBlock PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(5), 5);
     599                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.CarryAt(5), 5);
    600600                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    601601                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    602                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carryQ.BitBlock_advance_ci_co(PI_noWS, carryQ.get_carry_in(6), 6), PI_closer)));
     602                                PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.CarryAt(6), 6), PI_closer)));
    603603                                if (bitblock::any(PI_error))
    604604                                {
     
    606606                                }
    607607                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    608                                 PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carryQ.get_carry_in(7), 7);
     608                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carry_set_0.CarryAt(7), 7);
    609609                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    610610                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    612612                        else
    613613                        {
    614                                 carryQ.CarryDequeueEnqueue(4, 4);
    615                         }
    616                         if (bitblock::any(simd_or(CD_Cursor, carryQ.PabloJCarryTest(8, 1))))
     614                                carry_set_0.CarryDequeueEnqueue(4, 4);
     615                        }
     616                        if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    617617                        {
    618618                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    619                                 CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carryQ.get_carry_in(8), 8);
     619                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carry_set_0.CarryAt(8), 8);
    620620                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    621621                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    623623                        else
    624624                        {
    625                                 carryQ.CarryDequeueEnqueue(8, 1);
    626                         }
    627                         if (bitblock::any(simd_or(Ct_Cursor, carryQ.PabloJCarryTest(9, 5))))
     625                                carry_set_0.CarryDequeueEnqueue(8, 1);
     626                        }
     627                        if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    628628                        {
    629629                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    630                                 Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(9), 9);
     630                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(9), 9);
    631631                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    632                                 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);
    633                                 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);
     632                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(10), 10), carry_set_0.CarryAt(11), 11);
     633                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carry_set_0.CarryAt(12), 12), carry_set_0.CarryAt(13), 13);
    634634                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    635635                                {
     
    641641                        else
    642642                        {
    643                                 carryQ.CarryDequeueEnqueue(9, 5);
     643                                carry_set_0.CarryDequeueEnqueue(9, 5);
    644644                        }
    645645                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    646                         ctCDPI_mask = carryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(14), 14);
     646                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.CarryAt(14), 14);
    647647                        if (bitblock::any(simd<1>::constant<0>()))
    648648                        {
    649649                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    650650                        }
    651                         CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carryQ.get_carry_in(15), 15);
     651                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_set_0.CarryAt(15), 15);
    652652                        while (bitblock::any(CtCDPI_Cursor))
    653653                        {
    654                                 CarryDeclare(subcarryQ, 13, 0);
     654                                CarryDeclare(carry_set_1, 13, 0);
    655655                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    656656                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    657                                 BitBlock CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
     657                                BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    658658                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    659659                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
     
    661661                                {
    662662                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    663                                         PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
     663                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    664664                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    665                                         BitBlock PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
     665                                        BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    666666                                        BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    667667                                        BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    668                                         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)));
     668                                        PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    669669                                        if (bitblock::any(PI_error))
    670670                                        {
     
    672672                                        }
    673673                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    674                                         PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 4);
     674                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), simd<1>::constant<0>(), 4);
    675675                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    676676                                        CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    679679                                {
    680680                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    681                                         CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 5);
     681                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), simd<1>::constant<0>(), 5);
    682682                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    683683                                        CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    686686                                {
    687687                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    688                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
     688                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    689689                                        BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    690                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
    691                                         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);
     690                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
     691                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    692692                                        if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    693693                                        {
     
    698698                                }
    699699                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    700                                 ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
     700                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    701701                                if (bitblock::any(simd<1>::constant<0>()))
    702702                                {
    703703                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    704704                                }
    705                                 CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 12);
    706                                 carryQ.CarryCombine(subcarryQ.cq, 3, 13);
     705                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), simd<1>::constant<0>(), 12);
     706                                carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
    707707                        }
    708708                }
    709709                else
    710710                {
    711                         carryQ.CarryDequeueEnqueue(3, 13);
    712                 }
    713                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carryQ.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(16), 16)), CtCDPI_starts), EOF_mask);
     711                        carry_set_0.CarryDequeueEnqueue(3, 13);
     712                }
     713                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.CarryAt(16), 16)), CtCDPI_starts), EOF_mask);
    714714                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    715715                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
    716716                marker.CD_closer = simd_andc(CD_closer, ctCDPI_mask);
    717                 carryQ.CarryQ_Adjust(17);
     717                carry_set_0.CarryAdjust(17);
    718718        }
    719719       
     
    733733                BitBlock v = simd_or(lex.LAngle, lex.Hyphen);
    734734                BitBlock w = simd_or(lex.Hyphen, lex.QMark);
    735                 BitBlock v1 = carryQ.BitBlock_advance_n_<1>(v, carryQ.get_pending64(0), 0);
    736                 BitBlock w1 = carryQ.BitBlock_advance_n_<1>(w, carryQ.get_pending64(1), 1);
     735                BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
     736                BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
    737737                BitBlock LAngle_scope = simd_andc(v1, w1);
    738738                BitBlock PI_opener = simd_and(LAngle_scope, lex.QMark);
     
    741741                BitBlock CD_closer = simd<1>::constant<0>();
    742742                BitBlock DoubleHyphen = simd_and(simd_and(v1, w1), lex.Hyphen);
    743                 if (bitblock::any(simd_or(lex.RBracket, carryQ.PabloJCarryTest(0, 2))))
    744                 {
    745                         BitBlock DoubleRBracket = simd_and(carryQ.BitBlock_advance_ci_co(lex.RBracket, carryQ.get_carry_in(0), 0), lex.RBracket);
    746                         CD_closer = simd_and(carryQ.BitBlock_advance_ci_co(DoubleRBracket, carryQ.get_carry_in(1), 1), lex.RAngle);
     743                if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
     744                {
     745                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.CarryAt(0), 0), lex.RBracket);
     746                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.CarryAt(1), 1), lex.RAngle);
    747747                }
    748748                else
    749749                {
    750                         carryQ.CarryDequeueEnqueue(0, 2);
     750                        carry_set_0.CarryDequeueEnqueue(0, 2);
    751751                }
    752752                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    753                 BitBlock CtCDPI_Cursor = carryQ.BitBlock_scantofirst(CtCDPI_opener, carryQ.get_carry_in(2), 2);
    754                 if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor, EOF_mask), carryQ.PabloJCarryTest(3, 13))))
     753                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.CarryAt(2), 2);
     754                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
    755755                {
    756756                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    757757                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    758                         BitBlock CD_Ct_Cursor = carryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carryQ.get_carry_in(3), 3);
     758                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.CarryAt(3), 3);
    759759                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    760760                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
    761                         if (bitblock::any(simd_or(PI_Cursor, carryQ.PabloJCarryTest(4, 4))))
     761                        if (bitblock::any(simd_or(PI_Cursor, carry_set_0.CarryRange(4, 4))))
    762762                        {
    763763                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    764                                 PI_Cursor = carryQ.BitBlock_advance_ci_co(PI_Cursor, carryQ.get_carry_in(4), 4);
     764                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.CarryAt(4), 4);
    765765                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    766                                 BitBlock PI_name_end = carryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carryQ.get_carry_in(5), 5);
     766                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.CarryAt(5), 5);
    767767                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    768768                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    769                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carryQ.BitBlock_advance_ci_co(PI_noWS, carryQ.get_carry_in(6), 6), PI_closer)));
     769                                PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.CarryAt(6), 6), PI_closer)));
    770770                                if (bitblock::any(PI_error))
    771771                                {
     
    773773                                }
    774774                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    775                                 PI_Cursor = carryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carryQ.get_carry_in(7), 7);
     775                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_set_0.CarryAt(7), 7);
    776776                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    777777                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    779779                        else
    780780                        {
    781                                 carryQ.CarryDequeueEnqueue(4, 4);
    782                         }
    783                         if (bitblock::any(simd_or(CD_Cursor, carryQ.PabloJCarryTest(8, 1))))
     781                                carry_set_0.CarryDequeueEnqueue(4, 4);
     782                        }
     783                        if (bitblock::any(simd_or(CD_Cursor, carry_set_0.CarryRange(8, 1))))
    784784                        {
    785785                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    786                                 CD_Cursor = carryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carryQ.get_carry_in(8), 8);
     786                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_set_0.CarryAt(8), 8);
    787787                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    788788                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    790790                        else
    791791                        {
    792                                 carryQ.CarryDequeueEnqueue(8, 1);
    793                         }
    794                         if (bitblock::any(simd_or(Ct_Cursor, carryQ.PabloJCarryTest(9, 5))))
     792                                carry_set_0.CarryDequeueEnqueue(8, 1);
     793                        }
     794                        if (bitblock::any(simd_or(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
    795795                        {
    796796                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    797                                 Ct_Cursor = carryQ.BitBlock_advance_ci_co(Ct_Cursor, carryQ.get_carry_in(9), 9);
     797                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(9), 9);
    798798                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    799                                 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);
    800                                 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);
     799                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(10), 10), carry_set_0.CarryAt(11), 11);
     800                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_set_0.CarryAt(12), 12), carry_set_0.CarryAt(13), 13);
    801801                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    802802                                {
     
    808808                        else
    809809                        {
    810                                 carryQ.CarryDequeueEnqueue(9, 5);
     810                                carry_set_0.CarryDequeueEnqueue(9, 5);
    811811                        }
    812812                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    813                         ctCDPI_mask = carryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carryQ.get_carry_in(14), 14);
     813                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.CarryAt(14), 14);
    814814                        if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    815815                        {
    816816                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    817817                        }
    818                         CtCDPI_Cursor = carryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carryQ.get_carry_in(15), 15);
     818                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_set_0.CarryAt(15), 15);
    819819                        while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
    820820                        {
    821                                 CarryDeclare(subcarryQ, 13, 0);
     821                                CarryDeclare(carry_set_1, 13, 0);
    822822                                CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    823823                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    824                                 BitBlock CD_Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
     824                                BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), simd<1>::constant<0>(), 0);
    825825                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    826826                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
     
    828828                                {
    829829                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    830                                         PI_Cursor = subcarryQ.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
     830                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd<1>::constant<0>(), 1);
    831831                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    832                                         BitBlock PI_name_end = subcarryQ.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
     832                                        BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd<1>::constant<0>(), 2);
    833833                                        BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    834834                                        BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    835                                         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)));
     835                                        PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd<1>::constant<0>(), 3), PI_closer)));
    836836                                        if (bitblock::any(PI_error))
    837837                                        {
     
    839839                                        }
    840840                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    841                                         PI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 4);
     841                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), simd<1>::constant<0>(), 4);
    842842                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    843843                                        CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    846846                                {
    847847                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    848                                         CD_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 5);
     848                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), simd<1>::constant<0>(), 5);
    849849                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    850850                                        CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    853853                                {
    854854                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    855                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
     855                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 6);
    856856                                        BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    857                                         Ct_Cursor = subcarryQ.BitBlock_advance_ci_co(subcarryQ.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
    858                                         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);
     857                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd<1>::constant<0>(), 7), simd<1>::constant<0>(), 8);
     858                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), simd<1>::constant<0>(), 9), simd<1>::constant<0>(), 10);
    859859                                        if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    860860                                        {
     
    865865                                }
    866866                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    867                                 ctCDPI_mask = subcarryQ.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
     867                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd<1>::constant<0>(), 11);
    868868                                if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    869869                                {
    870870                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    871871                                }
    872                                 CtCDPI_Cursor = subcarryQ.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
    873                                 carryQ.CarryCombine(subcarryQ.cq, 3, 13);
     872                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), simd<1>::constant<0>(), 12);
     873                                carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
    874874                        }
    875875                }
    876876                else
    877877                {
    878                         carryQ.CarryDequeueEnqueue(3, 13);
    879                 }
    880                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carryQ.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carryQ.get_carry_in(16), 16)), CtCDPI_starts), EOF_mask);
     878                        carry_set_0.CarryDequeueEnqueue(3, 13);
     879                }
     880                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.CarryAt(16), 16)), CtCDPI_starts), EOF_mask);
    881881                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    882882                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
     
    884884        }
    885885       
    886         CarryDeclare(carryQ, 17, 2);
     886        CarryDeclare(carry_set_0, 17, 2);
    887887};
    888888 
     
    903903                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    904904                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    905                 tag_Callouts.ElemName_ends = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
     905                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.CarryAt(0), 0);
    906906                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    907907                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    909909                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    910910                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    911                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carryQ.PabloJCarryTest(1, 8))))
    912                 {
    913                         BitBlock AfterWS = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), 1);
     911                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
     912                {
     913                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.CarryAt(1), 1);
    914914                        AttListEnd = simd_and(AfterWS, AttListDelim);
    915915                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
    916                         if (bitblock::any(simd_or(AttNameStart, carryQ.PabloJCarryTest(2, 7))))
     916                        if (bitblock::any(simd_or(AttNameStart, carry_set_0.CarryRange(2, 7))))
    917917                        {
    918918                                ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    919919                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    920                                 BitBlock AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
     920                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.CarryAt(2), 2);
    921921                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    922                                 if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carryQ.PabloJCarryTest(3, 1))))
    923                                 {
    924                                         EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
     922                                if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
     923                                {
     924                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.CarryAt(3), 3);
    925925                                }
    926926                                else
    927927                                {
    928928                                        EqExpected = AttNameFollow;
    929                                         carryQ.CarryDequeueEnqueue(3, 1);
     929                                        carry_set_0.CarryDequeueEnqueue(3, 1);
    930930                                }
    931931                                ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    932                                 BitBlock AttValPos = carryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carryQ.get_carry_in(4), 4);
     932                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.CarryAt(4), 4);
    933933                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    934934                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    935935                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    936                                 BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carryQ.get_carry_in(5), 5);
    937                                 BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carryQ.get_carry_in(6), 6);
     936                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carry_set_0.CarryAt(5), 5);
     937                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carry_set_0.CarryAt(6), 6);
    938938                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    939939                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    940                                 BitBlock AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
     940                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.CarryAt(7), 7);
    941941                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    942                                 if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carryQ.PabloJCarryTest(8, 1))))
    943                                 {
    944                                         AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
     942                                if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
     943                                {
     944                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.CarryAt(8), 8);
    945945                                        AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    946946                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    950950                                        AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    951951                                        AttNameStart = simd_andc(AttValFollow, AttListDelim);
    952                                         carryQ.CarryDequeueEnqueue(8, 1);
     952                                        carry_set_0.CarryDequeueEnqueue(8, 1);
    953953                                }
    954954                                ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    955955                                while (bitblock::any(AttNameStart))
    956956                                {
    957                                         CarryDeclare(subcarryQ, 7, 0);
     957                                        CarryDeclare(carry_set_1, 7, 0);
    958958                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    959959                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    960                                         BitBlock AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
     960                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    961961                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    962962                                        if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    963963                                        {
    964                                                 EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
     964                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    965965                                        }
    966966                                        else
     
    969969                                        }
    970970                                        ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    971                                         BitBlock AttValPos = subcarryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
     971                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    972972                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    973973                                        BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    974974                                        BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    975                                         BitBlock DQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), 3);
    976                                         BitBlock SQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), 4);
     975                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), simd<1>::constant<0>(), 3);
     976                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), simd<1>::constant<0>(), 4);
    977977                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    978978                                        ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    979                                         BitBlock AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
     979                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    980980                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    981981                                        if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    982982                                        {
    983                                                 AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
     983                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    984984                                                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    985985                                                AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    991991                                        }
    992992                                        ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    993                                         carryQ.CarryCombine(subcarryQ.cq, 2, 7);
     993                                        carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
    994994                                }
    995995                        }
    996996                        else
    997997                        {
    998                                 carryQ.CarryDequeueEnqueue(2, 7);
     998                                carry_set_0.CarryDequeueEnqueue(2, 7);
    999999                        }
    10001000                }
     
    10031003                        AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
    10041004                        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
    1005                         carryQ.CarryDequeueEnqueue(1, 8);
     1005                        carry_set_0.CarryDequeueEnqueue(1, 8);
    10061006                }
    10071007                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1008                 tag_Callouts.EmptyTag_marks = carryQ.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), 9);
     1008                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.CarryAt(9), 9);
    10091009                ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1010                 BitBlock EndTagEnds = carryQ.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), 10);
    1011                 if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carryQ.PabloJCarryTest(11, 1))))
    1012                 {
    1013                         EndTagEnds = carryQ.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carryQ.get_carry_in(11), 11);
     1010                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.CarryAt(10), 10);
     1011                if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
     1012                {
     1013                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.CarryAt(11), 11);
    10141014                }
    10151015                else
    10161016                {
    1017                         carryQ.CarryDequeueEnqueue(11, 1);
     1017                        carry_set_0.CarryDequeueEnqueue(11, 1);
    10181018                }
    10191019                ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
     
    10221022                        assert_0_error("Tag parsing error found", ParseError);
    10231023                }
    1024                 tag_Callouts.AttVal_spans = carryQ.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), 12);
    1025                 carryQ.CarryQ_Adjust(13);
     1024                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.CarryAt(12), 12);
     1025                carry_set_0.CarryAdjust(13);
    10261026        }
    10271027       
     
    10351035                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    10361036                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    1037                 tag_Callouts.ElemName_ends = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carryQ.get_carry_in(0), 0);
     1037                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.CarryAt(0), 0);
    10381038                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    10391039                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    10411041                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    10421042                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1043                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carryQ.PabloJCarryTest(1, 8))))
    1044                 {
    1045                         BitBlock AfterWS = carryQ.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carryQ.get_carry_in(1), 1);
     1043                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
     1044                {
     1045                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.CarryAt(1), 1);
    10461046                        AttListEnd = simd_and(AfterWS, AttListDelim);
    10471047                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
    1048                         if (bitblock::any(simd_or(simd_and(AttNameStart, EOF_mask), carryQ.PabloJCarryTest(2, 7))))
     1048                        if (bitblock::any(simd_or(simd_and(AttNameStart, EOF_mask), carry_set_0.CarryRange(2, 7))))
    10491049                        {
    10501050                                ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    10511051                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1052                                 BitBlock AttNameFollow = carryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carryQ.get_carry_in(2), 2);
     1052                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.CarryAt(2), 2);
    10531053                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    1054                                 if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carryQ.PabloJCarryTest(3, 1))))
    1055                                 {
    1056                                         EqExpected = carryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carryQ.get_carry_in(3), 3);
     1054                                if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
     1055                                {
     1056                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.CarryAt(3), 3);
    10571057                                }
    10581058                                else
    10591059                                {
    10601060                                        EqExpected = AttNameFollow;
    1061                                         carryQ.CarryDequeueEnqueue(3, 1);
     1061                                        carry_set_0.CarryDequeueEnqueue(3, 1);
    10621062                                }
    10631063                                ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1064                                 BitBlock AttValPos = carryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carryQ.get_carry_in(4), 4);
     1064                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.CarryAt(4), 4);
    10651065                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    10661066                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    10671067                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1068                                 BitBlock DQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carryQ.get_carry_in(5), 5);
    1069                                 BitBlock SQuoteAttEnd = carryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carryQ.get_carry_in(6), 6);
     1068                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_set_0.CarryAt(5), 5);
     1069                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_set_0.CarryAt(6), 6);
    10701070                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    10711071                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1072                                 BitBlock AttValFollow = carryQ.BitBlock_advance_ci_co(AttValEnd, carryQ.get_carry_in(7), 7);
     1072                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.CarryAt(7), 7);
    10731073                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    1074                                 if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carryQ.PabloJCarryTest(8, 1))))
    1075                                 {
    1076                                         AfterWS = carryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carryQ.get_carry_in(8), 8);
     1074                                if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
     1075                                {
     1076                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.CarryAt(8), 8);
    10771077                                        AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    10781078                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    10821082                                        AttListEnd = simd_or(AttListEnd, simd_and(AttValFollow, AttListDelim));
    10831083                                        AttNameStart = simd_andc(AttValFollow, AttListDelim);
    1084                                         carryQ.CarryDequeueEnqueue(8, 1);
     1084                                        carry_set_0.CarryDequeueEnqueue(8, 1);
    10851085                                }
    10861086                                ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    10871087                                while (bitblock::any(simd_and(AttNameStart, EOF_mask)))
    10881088                                {
    1089                                         CarryDeclare(subcarryQ, 7, 0);
     1089                                        CarryDeclare(carry_set_1, 7, 0);
    10901090                                        ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    10911091                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1092                                         BitBlock AttNameFollow = subcarryQ.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
     1092                                        BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd<1>::constant<0>(), 0);
    10931093                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    10941094                                        if (bitblock::any(simd_and(AttNameFollow, lex.WS)))
    10951095                                        {
    1096                                                 EqExpected = subcarryQ.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
     1096                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd<1>::constant<0>(), 1);
    10971097                                        }
    10981098                                        else
     
    11011101                                        }
    11021102                                        ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1103                                         BitBlock AttValPos = subcarryQ.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
     1103                                        BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd<1>::constant<0>(), 2);
    11041104                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    11051105                                        BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    11061106                                        BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1107                                         BitBlock DQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), 3);
    1108                                         BitBlock SQuoteAttEnd = subcarryQ.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), 4);
     1107                                        BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), simd<1>::constant<0>(), 3);
     1108                                        BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), simd<1>::constant<0>(), 4);
    11091109                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    11101110                                        ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1111                                         BitBlock AttValFollow = subcarryQ.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
     1111                                        BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd<1>::constant<0>(), 5);
    11121112                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    11131113                                        if (bitblock::any(simd_and(AttValFollow, lex.WS)))
    11141114                                        {
    1115                                                 AfterWS = subcarryQ.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
     1115                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd<1>::constant<0>(), 6);
    11161116                                                AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    11171117                                                AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    11231123                                        }
    11241124                                        ParseError = simd_or(ParseError, simd_and(AttValFollow, AttNameStart));
    1125                                         carryQ.CarryCombine(subcarryQ.cq, 2, 7);
     1125                                        carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
    11261126                                }
    11271127                        }
    11281128                        else
    11291129                        {
    1130                                 carryQ.CarryDequeueEnqueue(2, 7);
     1130                                carry_set_0.CarryDequeueEnqueue(2, 7);
    11311131                        }
    11321132                }
     
    11351135                        AttListEnd = simd_and(tag_Callouts.ElemName_ends, AttListDelim);
    11361136                        ParseError = simd_or(ParseError, simd_andc(tag_Callouts.ElemName_ends, AttListDelim));
    1137                         carryQ.CarryDequeueEnqueue(1, 8);
     1137                        carry_set_0.CarryDequeueEnqueue(1, 8);
    11381138                }
    11391139                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1140                 tag_Callouts.EmptyTag_marks = carryQ.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carryQ.get_carry_in(9), 9);
     1140                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.CarryAt(9), 9);
    11411141                ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1142                 BitBlock EndTagEnds = carryQ.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carryQ.get_carry_in(10), 10);
    1143                 if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carryQ.PabloJCarryTest(11, 1))))
    1144                 {
    1145                         EndTagEnds = carryQ.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carryQ.get_carry_in(11), 11);
     1142                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.CarryAt(10), 10);
     1143                if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
     1144                {
     1145                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.CarryAt(11), 11);
    11461146                }
    11471147                else
    11481148                {
    1149                         carryQ.CarryDequeueEnqueue(11, 1);
     1149                        carry_set_0.CarryDequeueEnqueue(11, 1);
    11501150                }
    11511151                ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
     
    11541154                        assert_0_error("Tag parsing error found", ParseError);
    11551155                }
    1156                 tag_Callouts.AttVal_spans = carryQ.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carryQ.get_carry_in(12), 12);
     1156                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.CarryAt(12), 12);
    11571157        }
    11581158       
    1159         CarryDeclare(carryQ, 13, 0);
     1159        CarryDeclare(carry_set_0, 13, 0);
    11601160};
    11611161 
     
    11761176                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    11771177                BitBlock ref_error = simd<1>::constant<0>();
    1178                 if (bitblock::any(simd_or(marker.Ref_opener, carryQ.PabloJCarryTest(0, 6))))
    1179                 {
    1180                         BitBlock Ref_scope = carryQ.BitBlock_advance_ci_co(marker.Ref_opener, carryQ.get_carry_in(0), 0);
     1178                if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
     1179                {
     1180                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    11811181                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    11821182                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1183                         BitBlock NumRef3 = carryQ.BitBlock_advance_ci_co(NumRef2, carryQ.get_carry_in(1), 1);
     1183                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    11841184                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    11851185                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1186                         ref_Callouts.HexRef_starts = carryQ.BitBlock_advance_ci_co(HexRef3, carryQ.get_carry_in(2), 2);
    1187                         ref_Callouts.GenRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), 3);
    1188                         ref_Callouts.DecRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), 4);
    1189                         ref_Callouts.HexRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), 5);
     1186                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     1187                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
     1188                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
     1189                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    11901190                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    11911191                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
     
    11991199                else
    12001200                {
    1201                         carryQ.CarryDequeueEnqueue(0, 6);
    1202                 }
    1203                 carryQ.CarryQ_Adjust(6);
     1201                        carry_set_0.CarryDequeueEnqueue(0, 6);
     1202                }
     1203                carry_set_0.CarryAdjust(6);
    12041204        }
    12051205       
     
    12131213                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    12141214                BitBlock ref_error = simd<1>::constant<0>();
    1215                 if (bitblock::any(simd_or(marker.Ref_opener, carryQ.PabloJCarryTest(0, 6))))
    1216                 {
    1217                         BitBlock Ref_scope = carryQ.BitBlock_advance_ci_co(marker.Ref_opener, carryQ.get_carry_in(0), 0);
     1215                if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
     1216                {
     1217                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
    12181218                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    12191219                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1220                         BitBlock NumRef3 = carryQ.BitBlock_advance_ci_co(NumRef2, carryQ.get_carry_in(1), 1);
     1220                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
    12211221                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    12221222                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1223                         ref_Callouts.HexRef_starts = carryQ.BitBlock_advance_ci_co(HexRef3, carryQ.get_carry_in(2), 2);
    1224                         ref_Callouts.GenRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carryQ.get_carry_in(3), 3);
    1225                         ref_Callouts.DecRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carryQ.get_carry_in(4), 4);
    1226                         ref_Callouts.HexRef_ends = carryQ.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carryQ.get_carry_in(5), 5);
     1223                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
     1224                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
     1225                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
     1226                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
    12271227                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    12281228                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
     
    12361236                else
    12371237                {
    1238                         carryQ.CarryDequeueEnqueue(0, 6);
     1238                        carry_set_0.CarryDequeueEnqueue(0, 6);
    12391239                }
    12401240        }
    12411241       
    1242         CarryDeclare(carryQ, 6, 0);
     1242        CarryDeclare(carry_set_0, 6, 0);
    12431243};
    12441244 
     
    12521252        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)
    12531253        {
    1254                 BitBlock PI_names = carryQ.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), 0);
    1255                 BitBlock GenRefs = carryQ.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), 1);
    1256                 BitBlock ElemNames = carryQ.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), 2);
    1257                 BitBlock AttNames = carryQ.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), 3);
     1254                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     1255                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     1256                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     1257                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    12581258                BitBlock qname_stream = simd_or(ElemNames, AttNames);
    12591259                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    12601260                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1261                 BitBlock name_start = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(4), 4));
    1262                 BitBlock name_cursor = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(5), 5));
     1261                BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     1262                BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    12631263                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1264                 BitBlock namespace_sep = simd_and(carryQ.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), 6), lex.Colon);
    1265                 BitBlock local_part_start = carryQ.BitBlock_advance_ci_co(namespace_sep, carryQ.get_carry_in(7), 7);
     1264                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     1265                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    12661266                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1267                 BitBlock colon2_err = simd_and(carryQ.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), 8), lex.Colon);
     1267                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
    12681268                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    12691269                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     
    12731273                check_streams.non_ascii_name_starts = simd_andc(name_start, lex.ASCII_name_start);
    12741274                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
    1275                 carryQ.CarryQ_Adjust(9);
     1275                carry_set_0.CarryAdjust(9);
    12761276        }
    12771277       
    12781278        void do_final_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, BitBlock & EOF_mask)
    12791279        {
    1280                 BitBlock PI_names = carryQ.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carryQ.get_carry_in(0), 0);
    1281                 BitBlock GenRefs = carryQ.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carryQ.get_carry_in(1), 1);
    1282                 BitBlock ElemNames = carryQ.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carryQ.get_carry_in(2), 2);
    1283                 BitBlock AttNames = carryQ.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carryQ.get_carry_in(3), 3);
     1280                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
     1281                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
     1282                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
     1283                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
    12841284                BitBlock qname_stream = simd_or(ElemNames, AttNames);
    12851285                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    12861286                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1287                 BitBlock name_start = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(4), 4));
    1288                 BitBlock name_cursor = simd_andc(name_stream, carryQ.BitBlock_advance_ci_co(name_stream, carryQ.get_carry_in(5), 5));
     1287                BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
     1288                BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
    12891289                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1290                 BitBlock namespace_sep = simd_and(carryQ.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(6), 6), lex.Colon);
    1291                 BitBlock local_part_start = carryQ.BitBlock_advance_ci_co(namespace_sep, carryQ.get_carry_in(7), 7);
     1290                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
     1291                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
    12921292                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1293                 BitBlock colon2_err = simd_and(carryQ.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carryQ.get_carry_in(8), 8), lex.Colon);
     1293                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
    12941294                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    12951295                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     
    13011301        }
    13021302       
    1303         CarryDeclare(carryQ, 9, 0);
     1303        CarryDeclare(carry_set_0, 9, 0);
    13041304};
    13051305 
     
    13331333        }
    13341334       
    1335         CarryDeclare(carryQ, 0, 0);
     1335        CarryDeclare(carry_set_0, 0, 0);
    13361336};
    13371337 
  • proto/pabloj/trunk/src/applicationGenerator/ApplicationGenerator.java

    r2955 r2967  
    2727import compilers.pabloB.codeGenerator.visitors.CPPUnparser;
    2828import compilers.pabloB.codeGenerator.visitors.Unparser;
    29 import compilers.pabloB.lang.carry.CarryBuiltins2CPP;
    30 import compilers.pabloB.lang.carry.CarryBuiltins2Lang;
     29import compilers.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
     30import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
    3131import compilers.pabloB.symbols.SymbolTable;
    3232import compilers.pabloS.lang.*;
     
    5555                // Transformation configurations to support multiple backends
    5656                Builtins2Lang builtins2Lang             = null;
    57                 CarryBuiltins2Lang carrySet2Lang        = null;
     57                CarrySetBuiltins2Lang carrySet2Lang     = null;
    5858                Unparser unparser                                       = null;
    59                
    6059               
    6160                if(applicationConfiguration.targetLang.contentEquals(Configuration.CLANG)) {
     
    6564                } else { // default C++
    6665                        builtins2Lang = new PabloSBuiltins2CPP();
    67                         carrySet2Lang = new CarryBuiltins2CPP();
     66                        carrySet2Lang = new CarrySetBuiltins2CPP();
    6867                        unparser          = new CPPUnparser(symbolTable);
    6968                }               
     
    8483                // Transform PabloS global functions in non-final block mode
    8584                pabloSXFormer.setFinalBlockMode(false);
    86                 pabloS.ast.ASTNode decoratedTree = pabloSXFormer.xForm();
     85                pabloS.ast.ProgramNode decoratedTree = (pabloS.ast.ProgramNode)pabloSXFormer.xForm();
    8786               
    8887                // Transform PabloS global functions in final block mode
    8988                pabloSXFormer.setFinalBlockMode(true);
    90                 pabloS.ast.ASTNode optDecoratedTree = pabloSXFormer.xForm();
     89                pabloS.ast.ProgramNode optDecoratedTree = (pabloS.ast.ProgramNode)pabloSXFormer.xForm();
    9190               
    9291                // PabloS to PabloB transformation
    9392                PabloS2PabloBXFormer pabloS2PabloBXFormer = new PabloS2PabloBXFormer(symbolTable, carrySet2Lang);
    9493                pabloB.ast.ASTNode pabloBASTTree = pabloS2PabloBXFormer.XForm(decoratedTree, optDecoratedTree);
     94               
     95                // PabloB Semantic Analysis
     96               
     97                // PabloB AST Transforms
    9598               
    9699                // Set up file paths
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/helpers/Labeller.java

    r2952 r2967  
    99
    1010public class Labeller {
    11         private long nextNumber = 1;
     11        private long nextNumber = 0;
    1212        String labelBase = "temp_";
    1313       
  • proto/pabloj/trunk/src/compilers/pabloB/codeGenerator/visitors/CPPUnparser.java

    r2952 r2967  
    4343import compilers.pabloB.codeGenerator.helpers.CodeStore;
    4444import compilers.pabloB.codeGenerator.helpers.UnparserUtil;
    45 import compilers.pabloB.lang.carry.CarryBuiltins2CPP;
    46 import compilers.pabloB.symbols.CarryInfoSetSymbol;
    4745import compilers.pabloB.symbols.SymbolTable;
    4846
    4947public class CPPUnparser extends Unparser {
    5048
    51         private CarryBuiltins2CPP carrySetBuiltins2CPP;
    5249        private String stateIdentifier = null;
    5350       
     
    5653        public CPPUnparser(SymbolTable symbolTable) {
    5754                super.setSymbolTable(symbolTable);
    58                 carrySetBuiltins2CPP = new CarryBuiltins2CPP();
    5955        }
    6056
     
    7975        }
    8076       
    81         @SuppressWarnings("static-access")
    8277        public CodeStore visitLeave(KernelDefNode node, List<CodeStore> childResults) {
    8378                CodeStore code = new CodeStore();
     
    10398                        code.addAll(optFuncDefCodeStore, 0);
    10499                }
    105                
    106                 String formatString = new String();
    107                
    108                 // TODO -       Kludgy. Fix. See 'notes'.
    109                 CarryInfoSetSymbol carryInfoSet = (CarryInfoSetSymbol) symbolTable.get(kernelName);
    110                                
    111                 int carry1Count = carryInfoSet.getCarry1Count();
    112                 int carryNCount = carryInfoSet.getCarryNCount();
    113                
    114                 if( carry1Count > 0 || carryNCount > 0 )
    115                 {
    116                         formatString = carrySetBuiltins2CPP.CARRYSETDECLAREFORMATSTRING;
    117                         formatString += ";";
    118                         code.addFormattedLine(formatString,
    119                                         carry1Count,
    120                                         carryNCount,
    121                                         carrySetBuiltins2CPP.CARRYQNAME);
     100
     101                CodeStore carryDeclareCodeStore;
     102                if(Accessors.hasOptFuncDef(node)) {
     103                        carryDeclareCodeStore = childResults.get(4);
     104                } else {
     105                        carryDeclareCodeStore = childResults.get(3);
     106                }
     107                code.addAll(carryDeclareCodeStore, 0);
    122108                       
    123                 }
    124                
    125109                code.dedentedLine("};");
    126110               
     
    177161                CodeStore code = new CodeStore();
    178162               
    179                 String st = childResults.get(0).getResultVarName();
    180                
    181                 String stateSize = childResults.get(1).getResultVarName();
    182                 CodeStore stateInitListCodeStore = childResults.get(2);
    183 
    184163                /*
    185164                code.addFormattedLine("for(int i=0; i<%s; i++)", stateSize);
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/Transformer.java

    r2955 r2967  
     1/*
     2 * PabloS transformation controller.
     3 *
     4 * @author Ken Herdy  <ksherdy at sfu dot ca>
     5 */
     6
    17package compilers.pabloS.semanticAnalyzer;
    2 
    3 //
    4 // Deep copies AST.
    5 // Decorates AST copy.
    6 // Static interface decorates AST in default mode only.
    7 // TODO - Add a method to sync/set defaults with the configuration object
    8 //
    9 // Use PabloSTransformer instance to set non-defaults.
    10 //
    118
    129import compilers.pabloS.lang.*;
     
    2623       
    2724        private compilers.pabloS.lang.Builtins2Lang builtins2Lang;
    28         private compilers.pabloB.lang.carry.CarryBuiltins2Lang carrySet2Lang;
     25        private compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang carrySet2Lang;
    2926        private boolean finalBlockMode;
    3027       
     
    5148        private void initDefaults() {
    5249                this.setBuiltins2Lang(new PabloSBuiltins2CPP());
    53                 this.setCarrySet2Lang(new compilers.pabloB.lang.carry.CarryBuiltins2CPP());
     50                this.setCarrySet2Lang(new compilers.pabloB.lang.carrySet.CarrySetBuiltins2CPP());
    5451               
    5552                this.setAddDumpStmts(false);
     
    8380            advanceCombiner.XForm();
    8481
    85    
    86            
    8782            CarryIntroXFormer carryQIntro = new CarryIntroXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
    8883                carryQIntro.XForm(finalBlockMode);             
     
    9085                Bitwise2IDISAXFormer bitwiseToIDISA = new Bitwise2IDISAXFormer(decoratedTree);
    9186                bitwiseToIDISA.XForm();                 
    92                 // Dependency on CarryIntroXFormer to count PabloS builtins that produce carry values.
    93                 //Pablo2CarryXFormer pablo2CarryXFormer = new Pablo2CarryXFormer(decoratedTree, getBuiltins2Lang(), getCarrySet2Lang());
    94                 //pablo2CarryXFormer.XForm(finalBlockMode);                         
    95                                                                                
     87
    9688                return decoratedTree;
    9789               
     
    122114        }
    123115
    124         public compilers.pabloB.lang.carry.CarryBuiltins2Lang getCarrySet2Lang() {
     116        public compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang getCarrySet2Lang() {
    125117                return carrySet2Lang;
    126118        }
    127119
    128         public void setCarrySet2Lang(compilers.pabloB.lang.carry.CarryBuiltins2Lang carrySet2Lang) {
     120        public void setCarrySet2Lang(compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang carrySet2Lang) {
    129121                this.carrySet2Lang = carrySet2Lang;
    130122        }
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryCounterVisitor.java

    r2952 r2967  
    1818    }
    1919   
    20     public int count() {
    21         CarryCounter visitor = new CarryCounter();
     20    public int carry1Count() {
     21        Carry1Counter visitor = new Carry1Counter();
    2222        this.ASTree.accept(visitor);
    23         return ((CarryCounter)visitor).carryCount();
     23        return ((Carry1Counter)visitor).count();
    2424    }   
    25        
    26         private class CarryCounter extends VoidVisitor.Default {
    27                 private int carryCount = 0;
    2825
    29                 public int carryCount() {
    30                         return carryCount;
     26    public int carryNCount() {
     27        CarryNCounter visitor = new CarryNCounter();
     28        this.ASTree.accept(visitor);
     29        return ((CarryNCounter)visitor).count();
     30    }   
     31       
     32        private class Carry1Counter extends VoidVisitor.Default {
     33                private int carry1Count         = 0;
     34
     35                public int count() {
     36                        return carry1Count;
     37                }
     38                               
     39                public void visitLeave(FuncCallNode node) {
     40                        if(BuiltinsUtil.isCarryOne(node)) {
     41                            carry1Count += 1;
     42                        }                       
     43                }
     44        }
     45
     46        private class CarryNCounter extends VoidVisitor.Default {
     47                private int carryNCount         = 0;
     48
     49                public int count() {
     50                        return carryNCount;
     51                }
     52                               
     53                public void visitLeave(FuncCallNode node) {
     54                        if(BuiltinsUtil.isCarryN(node)) {
     55                            carryNCount += 1;
     56                        }                       
    3157                }
    3258               
    33                 public void visitLeave(FuncCallNode node) {
    34                         if(BuiltinsUtil.isCarryOne(node)) {
    35                             carryCount += 1;
    36                         }                   
    37                 }
    38                
    39 //              public void visitLeave(BinaryOperatorNode node) {
    40 //                      Token token = node.getToken();
    41 //                      if(token.isLextant(Lextant.MINUS, Lextant.PLUS)) {
    42 //                              this.carryCount++;
    43 //                      }
    44 //              }
    4559        }
     60       
    4661}
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryInfoSetVisitor.java

    r2952 r2967  
     1/*
     2 * Populates PabloB symbol table Kernel state information.
     3 *
     4 * @author Ken Herdy <ksherdy at sfu dot ca>
     5 */
    16package compilers.pabloS.semanticAnalyzer.visitors;
    2 
    3 //
    4 // Populates Symbol Table with carry information set information.
    5 //
    67
    78import java.util.List;
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r2952 r2967  
    1313import  pabloS.logging.ScatterLogger;
    1414
    15 import compilers.pabloB.lang.carry.CarryBuiltins2CPP;
    16 import compilers.pabloB.lang.carry.CarryBuiltins2Lang;
     15import compilers.pabloB.lang.carrySet.CarrySetBuiltins2CPP;
     16import compilers.pabloB.lang.carrySet.CarrySetBuiltins2Lang;
    1717import compilers.pabloS.lang.Builtins;
    1818import compilers.pabloS.lang.Builtins2Lang;
     
    212212                for (Map.Entry<String, ASTNode> entry : streamFuncMap.entrySet()) {     
    213213                        ASTNode value = entry.getValue();                               
    214                         CarryBuiltins2Lang carrySet2CPP = new CarryBuiltins2CPP();
     214                        CarrySetBuiltins2Lang carrySet2CPP = new CarrySetBuiltins2CPP();
    215215                        CarryIntroXFormer pablo2CarryQ = new CarryIntroXFormer(value, builtins2CPP, carrySet2CPP);
    216216                        pablo2CarryQ.XForm(isFinalBlock);
Note: See TracChangeset for help on using the changeset viewer.