Changeset 3325 for proto/pabloj/trunk


Ignore:
Timestamp:
Jun 18, 2013, 1:11:04 PM (6 years ago)
Author:
ksherdy
Message:

Added support for pablo_blk style calls.

Location:
proto/pabloj/trunk
Files:
2 added
18 edited
1 copied

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/.settings/org.eclipse.core.resources.prefs

    r3254 r3325  
    1 #Sun Jun 02 17:28:23 PDT 2013
    21eclipse.preferences.version=1
    32encoding//input/test/pabloS/proto/parabix2_pablo_r2797.py=utf-8
  • proto/pabloj/trunk/input/test/pabloS/test.pablos

    r3284 r3325  
    292292    stream v = (lex.LAngle | lex.Hyphen);
    293293    stream w = (lex.Hyphen | lex.QMark);
    294     stream v1 = pablo.AdvanceN(v, 1);
    295     stream w1 = pablo.AdvanceN(w, 1);
     294    stream v1 = pablo.AdvanceN(v,1);
     295    stream w1 = pablo.AdvanceN(w,1);
    296296    stream LAngle_scope = (v1 & (~ w1));
    297297    stream PI_opener = (LAngle_scope & lex.QMark);
  • proto/pabloj/trunk/output/cpplang/idisa_definitions.hpp

    r3231 r3325  
    2929BitBlock EOF_mask = simd<1>::constant<1>();
    3030
     31
     32// XMLWF application headers and definitions
     33/*
     34#include <stdio.h>
     35#include <stdlib.h>
     36#include <errno.h>
     37#include <sys/types.h>
     38#include <sys/stat.h>
     39
     40#include <simd-lib/s2p.hpp>
     41#include <simd-lib/buffer.hpp>
     42#include <simd-lib/bitblock_iterator.hpp>
     43#include <simd-lib/perflib/perfsec.h>
     44
     45#include <xmldecl.h>
     46#include <namechars.h>
     47#include <LineColTracker.hpp>
     48#include <XMLTestSuiteError.h>
     49
     50// Define the mappings for pablo.assert_0(strm, errkind) statements which
     51// compile to the the form assert_0_error(errkind, strm)
     52#include <ErrorTracker.h>
     53
     54ErrorTracker error_tracker;
     55#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
     56*/
     57
    3158// namespace pablo
    3259// {
     
    3562        KernelName()
    3663        {
    37                
    3864        }
    3965         
     
    4167        {
    4268                BitBlock a;
    43                 assert_bitblock_align(a);
    44                
    45                 print_register<BitBlock>("a",a);
    4669                BitBlock b;
    47                 assert_bitblock_align(b);
    48                 print_register<BitBlock>("b",b);
    4970                BitBlock c;
    50                 assert_bitblock_align(c);
    51                 print_register<BitBlock>("c",c);
    5271                BitBlock k;
    53                 assert_bitblock_align(k);
    54                 print_register<BitBlock>("k",k);
    5572                BitBlock r;
    56                 assert_bitblock_align(r);
    57                 print_register<BitBlock>("r",r);
     73                bool t;
     74                t = bitblock::any(a);
    5875                r = bitblock::slli<10>(a);
    59                 assert_bitblock_align(r);
    60                 print_register<BitBlock>("r",r);
    6176                bitblock::store_unaligned(a, &b);
    6277                r = bitblock::load_aligned(&b);
    63                 assert_bitblock_align(r);
    64                 print_register<BitBlock>("r",r);
    6578                r = simd_not(a);
    66                 assert_bitblock_align(r);
    67                 print_register<BitBlock>("r",r);
    6879                r = simd_nor(a,b);
    69                 assert_bitblock_align(r);
    70                 print_register<BitBlock>("r",r);
    7180                r = simd<16>::ifh(a,b,c);
    72                 assert_bitblock_align(r);
    73                 print_register<BitBlock>("r",r);
    7481                r = simd<2>::constant<3>();
    75                 assert_bitblock_align(r);
    76                 print_register<BitBlock>("r",r);
    7782                r = simd<8>::slli<1>(a);
    78                 assert_bitblock_align(r);
    79                 print_register<BitBlock>("r",r);
    8083                r = simd<1>::add(a,b);
    81                 assert_bitblock_align(r);
    82                 print_register<BitBlock>("r",r);
    8384                r = simd<2>::sub(a,b);
    84                 assert_bitblock_align(r);
    85                 print_register<BitBlock>("r",r);
    8685                r = simd<4>::mult(a,b);
    87                 assert_bitblock_align(r);
    88                 print_register<BitBlock>("r",r);
    8986                r = simd<8>::eq(a,b);
    90                 assert_bitblock_align(r);
    91                 print_register<BitBlock>("r",r);
    9287                r = simd<16>::gt(a,b);
    93                 assert_bitblock_align(r);
    94                 print_register<BitBlock>("r",r);
    9588                r = simd<32>::ugt(a,b);
    96                 assert_bitblock_align(r);
    97                 print_register<BitBlock>("r",r);
    9889                r = simd<64>::lt(a,b);
    99                 assert_bitblock_align(r);
    100                 print_register<BitBlock>("r",r);
    10190                r = simd<128>::ult(a,b);
    102                 assert_bitblock_align(r);
    103                 print_register<BitBlock>("r",r);
    10491                r = simd<128>::max(a,b);
    105                 assert_bitblock_align(r);
    106                 print_register<BitBlock>("r",r);
    10792                r = simd<1>::umax(a,b);
    108                 assert_bitblock_align(r);
    109                 print_register<BitBlock>("r",r);
    11093                r = simd<2>::min(a,b);
    111                 assert_bitblock_align(r);
    112                 print_register<BitBlock>("r",r);
    11394                r = simd<4>::umin(a,b);
    114                 assert_bitblock_align(r);
    115                 print_register<BitBlock>("r",r);
    11695                r = simd<64>::sll(a,b);
    117                 assert_bitblock_align(r);
    118                 print_register<BitBlock>("r",r);
    11996                r = simd<64>::srl(a,b);
    120                 assert_bitblock_align(r);
    121                 print_register<BitBlock>("r",r);
    12297        }
    12398       
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3260 r3325  
    1919// runtime libraries
    2020#include <simd-lib/bitblock.hpp>
    21 #include <simd-lib/carryQ.hpp>
     21#include <simd-lib/carrySet.hpp>
    2222#include <simd-lib/pabloSupport.hpp>
    2323
     
    191191        {
    192192        }
    193          
     193       
    194194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
    195195        {
    196196                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     197                print_register<BitBlock>("temp1",temp1);
    197198                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     199                print_register<BitBlock>("temp2",temp2);
    198200                BitBlock temp3 = simd_andc(temp2,temp1);
     201                print_register<BitBlock>("temp3",temp3);
    199202                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     203                print_register<BitBlock>("temp4",temp4);
    200204                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     205                print_register<BitBlock>("temp5",temp5);
    201206                BitBlock temp6 = simd_and(temp4,temp5);
     207                print_register<BitBlock>("temp6",temp6);
    202208                lex.RefStart = simd_and(temp3,temp6);
     209                print_register<BitBlock>("lex.RefStart",lex.RefStart);
    203210                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     211                print_register<BitBlock>("temp7",temp7);
    204212                BitBlock temp8 = simd_andc(temp7,temp1);
     213                print_register<BitBlock>("temp8",temp8);
    205214                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     215                print_register<BitBlock>("temp9",temp9);
    206216                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     217                print_register<BitBlock>("temp10",temp10);
    207218                BitBlock temp11 = simd_and(temp9,temp10);
     219                print_register<BitBlock>("temp11",temp11);
    208220                lex.Semicolon = simd_and(temp8,temp11);
     221                print_register<BitBlock>("lex.Semicolon",lex.Semicolon);
    209222                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     223                print_register<BitBlock>("temp12",temp12);
    210224                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     225                print_register<BitBlock>("temp13",temp13);
    211226                BitBlock temp14 = simd_andc(temp12,temp13);
     227                print_register<BitBlock>("temp14",temp14);
    212228                lex.LAngle = simd_and(temp8,temp14);
     229                print_register<BitBlock>("lex.LAngle",lex.LAngle);
    213230                BitBlock temp15 = simd_and(temp12,temp5);
     231                print_register<BitBlock>("temp15",temp15);
    214232                lex.RAngle = simd_and(temp8,temp15);
     233                print_register<BitBlock>("lex.RAngle",lex.RAngle);
    215234                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     235                print_register<BitBlock>("temp16",temp16);
    216236                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     237                print_register<BitBlock>("temp17",temp17);
    217238                BitBlock temp18 = simd_and(temp16,temp17);
     239                print_register<BitBlock>("temp18",temp18);
    218240                lex.LBracket = simd_and(temp18,temp11);
     241                print_register<BitBlock>("lex.LBracket",lex.LBracket);
    219242                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     243                print_register<BitBlock>("temp19",temp19);
    220244                BitBlock temp20 = simd_and(temp12,temp19);
     245                print_register<BitBlock>("temp20",temp20);
    221246                lex.RBracket = simd_and(temp18,temp20);
     247                print_register<BitBlock>("lex.RBracket",lex.RBracket);
    222248                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     249                print_register<BitBlock>("temp21",temp21);
    223250                BitBlock temp22 = simd_andc(temp19,temp21);
     251                print_register<BitBlock>("temp22",temp22);
    224252                lex.Exclam = simd_and(temp3,temp22);
     253                print_register<BitBlock>("lex.Exclam",lex.Exclam);
    225254                BitBlock temp23 = simd_and(temp12,temp10);
     255                print_register<BitBlock>("temp23",temp23);
    226256                lex.QMark = simd_and(temp8,temp23);
     257                print_register<BitBlock>("lex.QMark",lex.QMark);
    227258                lex.Hyphen = simd_and(temp3,temp20);
     259                print_register<BitBlock>("lex.Hyphen",lex.Hyphen);
    228260                lex.Equals = simd_and(temp8,temp20);
     261                print_register<BitBlock>("lex.Equals",lex.Equals);
    229262                BitBlock temp24 = simd_and(temp4,temp10);
     263                print_register<BitBlock>("temp24",temp24);
    230264                lex.SQuote = simd_and(temp3,temp24);
     265                print_register<BitBlock>("lex.SQuote",lex.SQuote);
    231266                BitBlock temp25 = simd_andc(temp5,temp21);
     267                print_register<BitBlock>("temp25",temp25);
    232268                lex.DQuote = simd_and(temp3,temp25);
     269                print_register<BitBlock>("lex.DQuote",lex.DQuote);
    233270                lex.Slash = simd_and(temp3,temp23);
     271                print_register<BitBlock>("lex.Slash",lex.Slash);
    234272                BitBlock temp26 = simd_andc(temp10,temp21);
     273                print_register<BitBlock>("temp26",temp26);
    235274                lex.Hash = simd_and(temp3,temp26);
     275                print_register<BitBlock>("lex.Hash",lex.Hash);
    236276                BitBlock temp27 = simd_and(temp16,temp7);
     277                print_register<BitBlock>("temp27",temp27);
    237278                BitBlock temp28 = simd_andc(temp9,temp13);
     279                print_register<BitBlock>("temp28",temp28);
    238280                lex.x = simd_and(temp27,temp28);
     281                print_register<BitBlock>("lex.x",lex.x);
    239282                BitBlock temp29 = simd_and(temp9,temp5);
     283                print_register<BitBlock>("temp29",temp29);
    240284                lex.Colon = simd_and(temp8,temp29);
     285                print_register<BitBlock>("lex.Colon",lex.Colon);
    241286                BitBlock temp30 = simd_and(temp18,temp23);
     287                print_register<BitBlock>("temp30",temp30);
    242288                BitBlock temp31 = simd_or(temp30,lex.Colon);
     289                print_register<BitBlock>("temp31",temp31);
    243290                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     291                print_register<BitBlock>("temp32",temp32);
    244292                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     293                print_register<BitBlock>("temp33",temp33);
    245294                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     295                print_register<BitBlock>("temp34",temp34);
    246296                BitBlock temp35 = simd_not(temp34);
     297                print_register<BitBlock>("temp35",temp35);
    247298                BitBlock temp36 = simd_or(temp21,temp13);
     299                print_register<BitBlock>("temp36",temp36);
    248300                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     301                print_register<BitBlock>("temp37",temp37);
    249302                BitBlock temp38 = simd_and(temp32,temp37);
     303                print_register<BitBlock>("temp38",temp38);
    250304                BitBlock temp39 = simd_or(temp31,temp38);
     305                print_register<BitBlock>("temp39",temp39);
    251306                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     307                print_register<BitBlock>("temp40",temp40);
    252308                BitBlock temp41 = simd_and(temp40,temp37);
     309                print_register<BitBlock>("temp41",temp41);
    253310                lex.ASCII_name_start = simd_or(temp39,temp41);
     311                print_register<BitBlock>("lex.ASCII_name_start",lex.ASCII_name_start);
    254312                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     313                print_register<BitBlock>("temp42",temp42);
    255314                BitBlock temp43 = simd_and(temp3,temp15);
     315                print_register<BitBlock>("temp43",temp43);
    256316                BitBlock temp44 = simd_or(temp42,temp43);
     317                print_register<BitBlock>("temp44",temp44);
    257318                BitBlock temp45 = simd_andc(temp8,temp34);
     319                print_register<BitBlock>("temp45",temp45);
    258320                BitBlock temp46 = simd_or(temp44,temp45);
     321                print_register<BitBlock>("temp46",temp46);
    259322                BitBlock temp47 = simd_or(temp46,temp38);
     323                print_register<BitBlock>("temp47",temp47);
    260324                lex.ASCII_name_char = simd_or(temp47,temp41);
     325                print_register<BitBlock>("lex.ASCII_name_char",lex.ASCII_name_char);
    261326                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
     327                print_register<BitBlock>("lex.NameScan",lex.NameScan);
    262328                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     329                print_register<BitBlock>("temp48",temp48);
    263330                BitBlock x00_x1F = simd_not(temp48);
     331                print_register<BitBlock>("x00_x1F",x00_x1F);
    264332                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     333                print_register<BitBlock>("temp49",temp49);
    265334                BitBlock temp50 = simd_or(temp1,temp49);
     335                print_register<BitBlock>("temp50",temp50);
    266336                lex.CR = simd_andc(temp20,temp50);
     337                print_register<BitBlock>("lex.CR",lex.CR);
    267338                lex.LF = simd_andc(temp29,temp50);
     339                print_register<BitBlock>("lex.LF",lex.LF);
    268340                BitBlock temp51 = simd_and(temp9,temp19);
     341                print_register<BitBlock>("temp51",temp51);
    269342                lex.HT = simd_andc(temp51,temp50);
     343                print_register<BitBlock>("lex.HT",lex.HT);
    270344                lex.SP = simd_andc(temp3,temp36);
     345                print_register<BitBlock>("lex.SP",lex.SP);
    271346                BitBlock temp52 = simd_or(temp20,temp29);
     347                print_register<BitBlock>("temp52",temp52);
    272348                BitBlock temp53 = simd_or(temp52,temp51);
     349                print_register<BitBlock>("temp53",temp53);
    273350                BitBlock temp54 = simd_andc(temp53,temp50);
     351                print_register<BitBlock>("temp54",temp54);
    274352                lex.WS = simd_or(temp54,lex.SP);
     353                print_register<BitBlock>("lex.WS",lex.WS);
    275354                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     355                print_register<BitBlock>("temp55",temp55);
    276356                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
     357                print_register<BitBlock>("temp56",temp56);
    277358                lex.Digit = simd_andc(temp8,temp56);
     359                print_register<BitBlock>("lex.Digit",lex.Digit);
    278360                BitBlock temp57 = simd_andc(temp16,temp49);
     361                print_register<BitBlock>("temp57",temp57);
    279362                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     363                print_register<BitBlock>("temp58",temp58);
    280364                BitBlock temp59 = simd_not(temp10);
     365                print_register<BitBlock>("temp59",temp59);
    281366                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     367                print_register<BitBlock>("temp60",temp60);
    282368                BitBlock temp61 = simd_and(temp58,temp60);
     369                print_register<BitBlock>("temp61",temp61);
    283370                BitBlock temp62 = simd_or(lex.Digit,temp61);
     371                print_register<BitBlock>("temp62",temp62);
    284372                BitBlock temp63 = simd_and(temp16,temp2);
     373                print_register<BitBlock>("temp63",temp63);
    285374                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     375                print_register<BitBlock>("temp64",temp64);
    286376                BitBlock temp65 = simd_and(temp64,temp60);
     377                print_register<BitBlock>("temp65",temp65);
    287378                lex.Hex = simd_or(temp62,temp65);
     379                print_register<BitBlock>("lex.Hex",lex.Hex);
    288380                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
     381                print_register<BitBlock>("lex_error",lex_error);
    289382                if (bitblock::any(lex_error))
    290383                {
     
    292385                }
    293386                u8.unibyte = simd_not(basis_bits.bit_0);
     387                print_register<BitBlock>("u8.unibyte",u8.unibyte);
    294388                u8.suffix = simd<1>::constant<0>();
     389                print_register<BitBlock>("u8.suffix",u8.suffix);
    295390                BitBlock u8_error = simd<1>::constant<0>();
     391                print_register<BitBlock>("u8_error",u8_error);
    296392                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     393                print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    297394                BitBlock u8anyscope = simd<1>::constant<0>();
    298                 if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
     395                print_register<BitBlock>("u8anyscope",u8anyscope);
     396                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
    299397                {
    300398                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
     399                        print_register<BitBlock>("u8.prefix",u8.prefix);
    301400                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
     401                        print_register<BitBlock>("u8.prefix2",u8.prefix2);
    302402                        u8.prefix3 = simd_and(u8.prefix,temp2);
     403                        print_register<BitBlock>("u8.prefix3",u8.prefix3);
    303404                        u8.prefix4 = simd_and(u8.prefix,temp7);
     405                        print_register<BitBlock>("u8.prefix4",u8.prefix4);
    304406                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
     407                        print_register<BitBlock>("u8.suffix",u8.suffix);
    305408                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
     409                        print_register<BitBlock>("temp66",temp66);
    306410                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     411                        print_register<BitBlock>("temp67",temp67);
    307412                        BitBlock temp68 = simd_andc(temp66,temp67);
     413                        print_register<BitBlock>("temp68",temp68);
    308414                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     415                        print_register<BitBlock>("temp69",temp69);
    309416                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     417                        print_register<BitBlock>("temp70",temp70);
    310418                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
     419                        print_register<BitBlock>("temp71",temp71);
    311420                        u8.badprefix = simd_or(temp68,temp71);
     421                        print_register<BitBlock>("u8.badprefix",u8.badprefix);
    312422                        u8_error = u8.badprefix;
    313                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
     423                        print_register<BitBlock>("u8_error",u8_error);
     424                        BitBlock __temp__0;
     425                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),__temp__0));
     426                        u8.scope22 = __temp__0;
     427                        print_register<BitBlock>("u8.scope22",u8.scope22);
    314428                        u8anyscope = u8.scope22;
    315                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
     429                        print_register<BitBlock>("u8anyscope",u8anyscope);
     430                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    316431                        {
    317432                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     433                                print_register<BitBlock>("xE0",xE0);
    318434                                BitBlock xED = simd_and(u8.prefix3,temp20);
     435                                print_register<BitBlock>("xED",xED);
    319436                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     437                                print_register<BitBlock>("xF0",xF0);
    320438                                BitBlock temp72 = simd_andc(temp4,temp13);
     439                                print_register<BitBlock>("temp72",temp72);
    321440                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
     441                                print_register<BitBlock>("xF4",xF4);
    322442                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
     443                                print_register<BitBlock>("u8.xA0_xBF",u8.xA0_xBF);
    323444                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
     445                                print_register<BitBlock>("u8.x80_x9F",u8.x80_x9F);
    324446                                u8.x90_xBF = simd_and(u8.suffix,temp49);
     447                                print_register<BitBlock>("u8.x90_xBF",u8.x90_xBF);
    325448                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
     449                                print_register<BitBlock>("u8.x80_x8F",u8.x80_x8F);
    326450                                BitBlock xEF = simd_and(u8.prefix3,temp23);
     451                                print_register<BitBlock>("xEF",xEF);
    327452                                BitBlock temp73 = simd_and(u8.suffix,temp7);
     453                                print_register<BitBlock>("temp73",temp73);
    328454                                u8.xBF = simd_and(temp73,temp23);
     455                                print_register<BitBlock>("u8.xBF",u8.xBF);
    329456                                u8.xBE = simd_and(temp73,temp15);
    330                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
    331                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
    332                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
    333                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
    334                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
    335                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
    336                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
     457                                print_register<BitBlock>("u8.xBE",u8.xBE);
     458                                BitBlock __temp__1;
     459                                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),__temp__1));
     460                                u8.scope32 = __temp__1;
     461                                print_register<BitBlock>("u8.scope32",u8.scope32);
     462                                BitBlock __temp__2;
     463                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),__temp__2));
     464                                u8.scope33 = __temp__2;
     465                                print_register<BitBlock>("u8.scope33",u8.scope33);
     466                                BitBlock __temp__3;
     467                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),__temp__3));
     468                                u8.scope42 = __temp__3;
     469                                print_register<BitBlock>("u8.scope42",u8.scope42);
     470                                BitBlock __temp__4;
     471                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),__temp__4));
     472                                u8.scope43 = __temp__4;
     473                                print_register<BitBlock>("u8.scope43",u8.scope43);
     474                                BitBlock __temp__5;
     475                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),__temp__5));
     476                                u8.scope44 = __temp__5;
     477                                print_register<BitBlock>("u8.scope44",u8.scope44);
     478                                BitBlock __temp__6;
     479                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),__temp__6));
     480                                BitBlock E0_F0_scope = __temp__6;
     481                                print_register<BitBlock>("E0_F0_scope",E0_F0_scope);
     482                                BitBlock __temp__7;
     483                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),__temp__7));
     484                                BitBlock ED_F4_scope = __temp__7;
     485                                print_register<BitBlock>("ED_F4_scope",ED_F4_scope);
    337486                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
     487                                print_register<BitBlock>("u8.xE0_scope",u8.xE0_scope);
    338488                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
     489                                print_register<BitBlock>("u8.xED_scope",u8.xED_scope);
    339490                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
     491                                print_register<BitBlock>("u8.xF0_scope",u8.xF0_scope);
    340492                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    341                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
     493                                print_register<BitBlock>("u8.xF4_scope",u8.xF4_scope);
     494                                BitBlock __temp__8;
     495                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),__temp__8));
     496                                u8.xEF_scope = __temp__8;
     497                                print_register<BitBlock>("u8.xEF_scope",u8.xEF_scope);
    342498                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     499                                print_register<BitBlock>("u8lastscope",u8lastscope);
    343500                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
     501                                print_register<BitBlock>("u8anyscope",u8anyscope);
    344502                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     503                                print_register<BitBlock>("u8error1",u8error1);
    345504                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     505                                print_register<BitBlock>("u8error2",u8error2);
    346506                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     507                                print_register<BitBlock>("u8error3",u8error3);
    347508                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
     509                                print_register<BitBlock>("u8error4",u8error4);
    348510                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    349                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
     511                                print_register<BitBlock>("u8_error",u8_error);
     512                                BitBlock __temp__9;
     513                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),__temp__9));
     514                                BitBlock EF_BF_pending = __temp__9;
     515                                print_register<BitBlock>("EF_BF_pending",EF_BF_pending);
    350516                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
     517                                print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    351518                        }
    352519                        else
    353520                        {
    354                                 carry_set_0.CarryDequeueEnqueue(1,9);
     521                                carry_set_0.carryDequeueEnqueue(1,9);
    355522                        }
    356523                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
     524                        print_register<BitBlock>("u8mismatch",u8mismatch);
    357525                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    358526                        {
     
    362530                else
    363531                {
    364                         carry_set_0.CarryDequeueEnqueue(0,10);
    365                 }
    366                 carry_set_0.CarryAdjust(10);
     532                        carry_set_0.carryDequeueEnqueue(0,10);
     533                }
     534                carry_set_0.carryAdjust(10);
    367535        }
    368536       
     
    370538        {
    371539                BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     540                print_register<BitBlock>("temp1",temp1);
    372541                BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     542                print_register<BitBlock>("temp2",temp2);
    373543                BitBlock temp3 = simd_andc(temp2,temp1);
     544                print_register<BitBlock>("temp3",temp3);
    374545                BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     546                print_register<BitBlock>("temp4",temp4);
    375547                BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     548                print_register<BitBlock>("temp5",temp5);
    376549                BitBlock temp6 = simd_and(temp4,temp5);
     550                print_register<BitBlock>("temp6",temp6);
    377551                lex.RefStart = simd_and(temp3,temp6);
     552                print_register<BitBlock>("lex.RefStart",lex.RefStart);
    378553                BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     554                print_register<BitBlock>("temp7",temp7);
    379555                BitBlock temp8 = simd_andc(temp7,temp1);
     556                print_register<BitBlock>("temp8",temp8);
    380557                BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     558                print_register<BitBlock>("temp9",temp9);
    381559                BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     560                print_register<BitBlock>("temp10",temp10);
    382561                BitBlock temp11 = simd_and(temp9,temp10);
     562                print_register<BitBlock>("temp11",temp11);
    383563                lex.Semicolon = simd_and(temp8,temp11);
     564                print_register<BitBlock>("lex.Semicolon",lex.Semicolon);
    384565                BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     566                print_register<BitBlock>("temp12",temp12);
    385567                BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     568                print_register<BitBlock>("temp13",temp13);
    386569                BitBlock temp14 = simd_andc(temp12,temp13);
     570                print_register<BitBlock>("temp14",temp14);
    387571                lex.LAngle = simd_and(temp8,temp14);
     572                print_register<BitBlock>("lex.LAngle",lex.LAngle);
    388573                BitBlock temp15 = simd_and(temp12,temp5);
     574                print_register<BitBlock>("temp15",temp15);
    389575                lex.RAngle = simd_and(temp8,temp15);
     576                print_register<BitBlock>("lex.RAngle",lex.RAngle);
    390577                BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     578                print_register<BitBlock>("temp16",temp16);
    391579                BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     580                print_register<BitBlock>("temp17",temp17);
    392581                BitBlock temp18 = simd_and(temp16,temp17);
     582                print_register<BitBlock>("temp18",temp18);
    393583                lex.LBracket = simd_and(temp18,temp11);
     584                print_register<BitBlock>("lex.LBracket",lex.LBracket);
    394585                BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     586                print_register<BitBlock>("temp19",temp19);
    395587                BitBlock temp20 = simd_and(temp12,temp19);
     588                print_register<BitBlock>("temp20",temp20);
    396589                lex.RBracket = simd_and(temp18,temp20);
     590                print_register<BitBlock>("lex.RBracket",lex.RBracket);
    397591                BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     592                print_register<BitBlock>("temp21",temp21);
    398593                BitBlock temp22 = simd_andc(temp19,temp21);
     594                print_register<BitBlock>("temp22",temp22);
    399595                lex.Exclam = simd_and(temp3,temp22);
     596                print_register<BitBlock>("lex.Exclam",lex.Exclam);
    400597                BitBlock temp23 = simd_and(temp12,temp10);
     598                print_register<BitBlock>("temp23",temp23);
    401599                lex.QMark = simd_and(temp8,temp23);
     600                print_register<BitBlock>("lex.QMark",lex.QMark);
    402601                lex.Hyphen = simd_and(temp3,temp20);
     602                print_register<BitBlock>("lex.Hyphen",lex.Hyphen);
    403603                lex.Equals = simd_and(temp8,temp20);
     604                print_register<BitBlock>("lex.Equals",lex.Equals);
    404605                BitBlock temp24 = simd_and(temp4,temp10);
     606                print_register<BitBlock>("temp24",temp24);
    405607                lex.SQuote = simd_and(temp3,temp24);
     608                print_register<BitBlock>("lex.SQuote",lex.SQuote);
    406609                BitBlock temp25 = simd_andc(temp5,temp21);
     610                print_register<BitBlock>("temp25",temp25);
    407611                lex.DQuote = simd_and(temp3,temp25);
     612                print_register<BitBlock>("lex.DQuote",lex.DQuote);
    408613                lex.Slash = simd_and(temp3,temp23);
     614                print_register<BitBlock>("lex.Slash",lex.Slash);
    409615                BitBlock temp26 = simd_andc(temp10,temp21);
     616                print_register<BitBlock>("temp26",temp26);
    410617                lex.Hash = simd_and(temp3,temp26);
     618                print_register<BitBlock>("lex.Hash",lex.Hash);
    411619                BitBlock temp27 = simd_and(temp16,temp7);
     620                print_register<BitBlock>("temp27",temp27);
    412621                BitBlock temp28 = simd_andc(temp9,temp13);
     622                print_register<BitBlock>("temp28",temp28);
    413623                lex.x = simd_and(temp27,temp28);
     624                print_register<BitBlock>("lex.x",lex.x);
    414625                BitBlock temp29 = simd_and(temp9,temp5);
     626                print_register<BitBlock>("temp29",temp29);
    415627                lex.Colon = simd_and(temp8,temp29);
     628                print_register<BitBlock>("lex.Colon",lex.Colon);
    416629                BitBlock temp30 = simd_and(temp18,temp23);
     630                print_register<BitBlock>("temp30",temp30);
    417631                BitBlock temp31 = simd_or(temp30,lex.Colon);
     632                print_register<BitBlock>("temp31",temp31);
    418633                BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     634                print_register<BitBlock>("temp32",temp32);
    419635                BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     636                print_register<BitBlock>("temp33",temp33);
    420637                BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     638                print_register<BitBlock>("temp34",temp34);
    421639                BitBlock temp35 = simd_not(temp34);
     640                print_register<BitBlock>("temp35",temp35);
    422641                BitBlock temp36 = simd_or(temp21,temp13);
     642                print_register<BitBlock>("temp36",temp36);
    423643                BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     644                print_register<BitBlock>("temp37",temp37);
    424645                BitBlock temp38 = simd_and(temp32,temp37);
     646                print_register<BitBlock>("temp38",temp38);
    425647                BitBlock temp39 = simd_or(temp31,temp38);
     648                print_register<BitBlock>("temp39",temp39);
    426649                BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     650                print_register<BitBlock>("temp40",temp40);
    427651                BitBlock temp41 = simd_and(temp40,temp37);
     652                print_register<BitBlock>("temp41",temp41);
    428653                lex.ASCII_name_start = simd_or(temp39,temp41);
     654                print_register<BitBlock>("lex.ASCII_name_start",lex.ASCII_name_start);
    429655                BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     656                print_register<BitBlock>("temp42",temp42);
    430657                BitBlock temp43 = simd_and(temp3,temp15);
     658                print_register<BitBlock>("temp43",temp43);
    431659                BitBlock temp44 = simd_or(temp42,temp43);
     660                print_register<BitBlock>("temp44",temp44);
    432661                BitBlock temp45 = simd_andc(temp8,temp34);
     662                print_register<BitBlock>("temp45",temp45);
    433663                BitBlock temp46 = simd_or(temp44,temp45);
     664                print_register<BitBlock>("temp46",temp46);
    434665                BitBlock temp47 = simd_or(temp46,temp38);
     666                print_register<BitBlock>("temp47",temp47);
    435667                lex.ASCII_name_char = simd_or(temp47,temp41);
     668                print_register<BitBlock>("lex.ASCII_name_char",lex.ASCII_name_char);
    436669                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
     670                print_register<BitBlock>("lex.NameScan",lex.NameScan);
    437671                BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     672                print_register<BitBlock>("temp48",temp48);
    438673                BitBlock x00_x1F = simd_not(temp48);
     674                print_register<BitBlock>("x00_x1F",x00_x1F);
    439675                BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     676                print_register<BitBlock>("temp49",temp49);
    440677                BitBlock temp50 = simd_or(temp1,temp49);
     678                print_register<BitBlock>("temp50",temp50);
    441679                lex.CR = simd_andc(temp20,temp50);
     680                print_register<BitBlock>("lex.CR",lex.CR);
    442681                lex.LF = simd_andc(temp29,temp50);
     682                print_register<BitBlock>("lex.LF",lex.LF);
    443683                BitBlock temp51 = simd_and(temp9,temp19);
     684                print_register<BitBlock>("temp51",temp51);
    444685                lex.HT = simd_andc(temp51,temp50);
     686                print_register<BitBlock>("lex.HT",lex.HT);
    445687                lex.SP = simd_andc(temp3,temp36);
     688                print_register<BitBlock>("lex.SP",lex.SP);
    446689                BitBlock temp52 = simd_or(temp20,temp29);
     690                print_register<BitBlock>("temp52",temp52);
    447691                BitBlock temp53 = simd_or(temp52,temp51);
     692                print_register<BitBlock>("temp53",temp53);
    448693                BitBlock temp54 = simd_andc(temp53,temp50);
     694                print_register<BitBlock>("temp54",temp54);
    449695                lex.WS = simd_or(temp54,lex.SP);
     696                print_register<BitBlock>("lex.WS",lex.WS);
    450697                BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     698                print_register<BitBlock>("temp55",temp55);
    451699                BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
     700                print_register<BitBlock>("temp56",temp56);
    452701                lex.Digit = simd_andc(temp8,temp56);
     702                print_register<BitBlock>("lex.Digit",lex.Digit);
    453703                BitBlock temp57 = simd_andc(temp16,temp49);
     704                print_register<BitBlock>("temp57",temp57);
    454705                BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     706                print_register<BitBlock>("temp58",temp58);
    455707                BitBlock temp59 = simd_not(temp10);
     708                print_register<BitBlock>("temp59",temp59);
    456709                BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     710                print_register<BitBlock>("temp60",temp60);
    457711                BitBlock temp61 = simd_and(temp58,temp60);
     712                print_register<BitBlock>("temp61",temp61);
    458713                BitBlock temp62 = simd_or(lex.Digit,temp61);
     714                print_register<BitBlock>("temp62",temp62);
    459715                BitBlock temp63 = simd_and(temp16,temp2);
     716                print_register<BitBlock>("temp63",temp63);
    460717                BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     718                print_register<BitBlock>("temp64",temp64);
    461719                BitBlock temp65 = simd_and(temp64,temp60);
     720                print_register<BitBlock>("temp65",temp65);
    462721                lex.Hex = simd_or(temp62,temp65);
     722                print_register<BitBlock>("lex.Hex",lex.Hex);
    463723                BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
     724                print_register<BitBlock>("lex_error",lex_error);
    464725                if (bitblock::any(simd_and(lex_error,EOF_mask)))
    465726                {
     
    467728                }
    468729                u8.unibyte = simd_not(basis_bits.bit_0);
     730                print_register<BitBlock>("u8.unibyte",u8.unibyte);
    469731                u8.suffix = simd<1>::constant<0>();
     732                print_register<BitBlock>("u8.suffix",u8.suffix);
    470733                BitBlock u8_error = simd<1>::constant<0>();
     734                print_register<BitBlock>("u8_error",u8_error);
    471735                BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     736                print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    472737                BitBlock u8anyscope = simd<1>::constant<0>();
    473                 if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.CarryRange(0,10))))
     738                print_register<BitBlock>("u8anyscope",u8anyscope);
     739                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
    474740                {
    475741                        u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
     742                        print_register<BitBlock>("u8.prefix",u8.prefix);
    476743                        u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
     744                        print_register<BitBlock>("u8.prefix2",u8.prefix2);
    477745                        u8.prefix3 = simd_and(u8.prefix,temp2);
     746                        print_register<BitBlock>("u8.prefix3",u8.prefix3);
    478747                        u8.prefix4 = simd_and(u8.prefix,temp7);
     748                        print_register<BitBlock>("u8.prefix4",u8.prefix4);
    479749                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
     750                        print_register<BitBlock>("u8.suffix",u8.suffix);
    480751                        BitBlock temp66 = simd_andc(u8.prefix,temp49);
     752                        print_register<BitBlock>("temp66",temp66);
    481753                        BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     754                        print_register<BitBlock>("temp67",temp67);
    482755                        BitBlock temp68 = simd_andc(temp66,temp67);
     756                        print_register<BitBlock>("temp68",temp68);
    483757                        BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     758                        print_register<BitBlock>("temp69",temp69);
    484759                        BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     760                        print_register<BitBlock>("temp70",temp70);
    485761                        BitBlock temp71 = simd_and(u8.prefix4,temp70);
     762                        print_register<BitBlock>("temp71",temp71);
    486763                        u8.badprefix = simd_or(temp68,temp71);
     764                        print_register<BitBlock>("u8.badprefix",u8.badprefix);
    487765                        u8_error = u8.badprefix;
    488                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2,carry_set_0.GetCarry(0),0);
     766                        print_register<BitBlock>("u8_error",u8_error);
     767                        BitBlock __temp__0;
     768                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),__temp__0));
     769                        u8.scope22 = __temp__0;
     770                        print_register<BitBlock>("u8.scope22",u8.scope22);
    489771                        u8anyscope = u8.scope22;
    490                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.CarryRange(1,9))))
     772                        print_register<BitBlock>("u8anyscope",u8anyscope);
     773                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    491774                        {
    492775                                BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     776                                print_register<BitBlock>("xE0",xE0);
    493777                                BitBlock xED = simd_and(u8.prefix3,temp20);
     778                                print_register<BitBlock>("xED",xED);
    494779                                BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     780                                print_register<BitBlock>("xF0",xF0);
    495781                                BitBlock temp72 = simd_andc(temp4,temp13);
     782                                print_register<BitBlock>("temp72",temp72);
    496783                                BitBlock xF4 = simd_and(u8.prefix4,temp72);
     784                                print_register<BitBlock>("xF4",xF4);
    497785                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
     786                                print_register<BitBlock>("u8.xA0_xBF",u8.xA0_xBF);
    498787                                u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
     788                                print_register<BitBlock>("u8.x80_x9F",u8.x80_x9F);
    499789                                u8.x90_xBF = simd_and(u8.suffix,temp49);
     790                                print_register<BitBlock>("u8.x90_xBF",u8.x90_xBF);
    500791                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
     792                                print_register<BitBlock>("u8.x80_x8F",u8.x80_x8F);
    501793                                BitBlock xEF = simd_and(u8.prefix3,temp23);
     794                                print_register<BitBlock>("xEF",xEF);
    502795                                BitBlock temp73 = simd_and(u8.suffix,temp7);
     796                                print_register<BitBlock>("temp73",temp73);
    503797                                u8.xBF = simd_and(temp73,temp23);
     798                                print_register<BitBlock>("u8.xBF",u8.xBF);
    504799                                u8.xBE = simd_and(temp73,temp15);
    505                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3,carry_set_0.GetCarry(1),1);
    506                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32,carry_set_0.GetCarry(2),2);
    507                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4,carry_set_0.GetCarry(3),3);
    508                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42,carry_set_0.GetCarry(4),4);
    509                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43,carry_set_0.GetCarry(5),5);
    510                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0,xF0),carry_set_0.GetCarry(6),6);
    511                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED,xF4),carry_set_0.GetCarry(7),7);
     800                                print_register<BitBlock>("u8.xBE",u8.xBE);
     801                                BitBlock __temp__1;
     802                                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),__temp__1));
     803                                u8.scope32 = __temp__1;
     804                                print_register<BitBlock>("u8.scope32",u8.scope32);
     805                                BitBlock __temp__2;
     806                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),__temp__2));
     807                                u8.scope33 = __temp__2;
     808                                print_register<BitBlock>("u8.scope33",u8.scope33);
     809                                BitBlock __temp__3;
     810                                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),__temp__3));
     811                                u8.scope42 = __temp__3;
     812                                print_register<BitBlock>("u8.scope42",u8.scope42);
     813                                BitBlock __temp__4;
     814                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),__temp__4));
     815                                u8.scope43 = __temp__4;
     816                                print_register<BitBlock>("u8.scope43",u8.scope43);
     817                                BitBlock __temp__5;
     818                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),__temp__5));
     819                                u8.scope44 = __temp__5;
     820                                print_register<BitBlock>("u8.scope44",u8.scope44);
     821                                BitBlock __temp__6;
     822                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),__temp__6));
     823                                BitBlock E0_F0_scope = __temp__6;
     824                                print_register<BitBlock>("E0_F0_scope",E0_F0_scope);
     825                                BitBlock __temp__7;
     826                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),__temp__7));
     827                                BitBlock ED_F4_scope = __temp__7;
     828                                print_register<BitBlock>("ED_F4_scope",ED_F4_scope);
    512829                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
     830                                print_register<BitBlock>("u8.xE0_scope",u8.xE0_scope);
    513831                                u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
     832                                print_register<BitBlock>("u8.xED_scope",u8.xED_scope);
    514833                                u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
     834                                print_register<BitBlock>("u8.xF0_scope",u8.xF0_scope);
    515835                                u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    516                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF,carry_set_0.GetCarry(8),8);
     836                                print_register<BitBlock>("u8.xF4_scope",u8.xF4_scope);
     837                                BitBlock __temp__8;
     838                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),__temp__8));
     839                                u8.xEF_scope = __temp__8;
     840                                print_register<BitBlock>("u8.xEF_scope",u8.xEF_scope);
    517841                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     842                                print_register<BitBlock>("u8lastscope",u8lastscope);
    518843                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
     844                                print_register<BitBlock>("u8anyscope",u8anyscope);
    519845                                BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     846                                print_register<BitBlock>("u8error1",u8error1);
    520847                                BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     848                                print_register<BitBlock>("u8error2",u8error2);
    521849                                BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     850                                print_register<BitBlock>("u8error3",u8error3);
    522851                                BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
     852                                print_register<BitBlock>("u8error4",u8error4);
    523853                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    524                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.GetCarry(9),9);
     854                                print_register<BitBlock>("u8_error",u8_error);
     855                                BitBlock __temp__9;
     856                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),__temp__9));
     857                                BitBlock EF_BF_pending = __temp__9;
     858                                print_register<BitBlock>("EF_BF_pending",EF_BF_pending);
    525859                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
     860                                print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    526861                        }
    527862                        else
    528863                        {
    529                                 carry_set_0.CarryDequeueEnqueue(1,9);
     864                                carry_set_0.carryDequeueEnqueue(1,9);
    530865                        }
    531866                        BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
     867                        print_register<BitBlock>("u8mismatch",u8mismatch);
    532868                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    533869                        {
     
    537873                else
    538874                {
    539                         carry_set_0.CarryDequeueEnqueue(0,10);
     875                        carry_set_0.carryDequeueEnqueue(0,10);
    540876                }
    541877        }
     
    548884        Parse_CtCDPI()
    549885        {
    550                 carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)),2);
    551                 }
    552                  
    553                 IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
    554                 {
    555                         ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    556                         ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    557                         ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    558                         ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    559                         ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    560                         ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    561                         ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    562                         ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    563                         BitBlock CtCDPI_starts = simd<1>::constant<0>();
    564                         BitBlock CtCDPI_ends = simd<1>::constant<0>();
    565                         BitBlock ctCDPI_mask = simd<1>::constant<0>();
    566                         BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
    567                         BitBlock w = simd_or(lex.Hyphen,lex.QMark);
    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);
    570                         BitBlock LAngle_scope = simd_andc(v1,w1);
    571                         BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
    572                         BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    573                         BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    574                         BitBlock CD_closer = simd<1>::constant<0>();
    575                         BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    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.GetCarry(0),0),lex.RBracket);
    579                                 CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
     886                carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
     887        }
     888       
     889        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
     890        {
     891                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     892                print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
     893                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     894                print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
     895                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     896                print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
     897                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     898                print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
     899                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     900                print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
     901                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     902                print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
     903                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     904                print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
     905                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     906                print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
     907                BitBlock CtCDPI_starts = simd<1>::constant<0>();
     908                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
     909                BitBlock CtCDPI_ends = simd<1>::constant<0>();
     910                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     911                BitBlock ctCDPI_mask = simd<1>::constant<0>();
     912                print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
     913                BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     914                print_register<BitBlock>("v",v);
     915                BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     916                print_register<BitBlock>("w",w);
     917                BitBlock __temp__0;
     918                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),__temp__0));
     919                BitBlock v1 = __temp__0;
     920                print_register<BitBlock>("v1",v1);
     921                BitBlock __temp__1;
     922                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),__temp__1));
     923                BitBlock w1 = __temp__1;
     924                print_register<BitBlock>("w1",w1);
     925                BitBlock LAngle_scope = simd_andc(v1,w1);
     926                print_register<BitBlock>("LAngle_scope",LAngle_scope);
     927                BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     928                print_register<BitBlock>("PI_opener",PI_opener);
     929                BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     930                print_register<BitBlock>("CtCD_opener",CtCD_opener);
     931                BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     932                print_register<BitBlock>("CtCDPI_opener",CtCDPI_opener);
     933                BitBlock CD_closer = simd<1>::constant<0>();
     934                print_register<BitBlock>("CD_closer",CD_closer);
     935                BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     936                print_register<BitBlock>("DoubleHyphen",DoubleHyphen);
     937                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
     938                {
     939                        BitBlock __temp__2;
     940                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),__temp__2));
     941                        BitBlock DoubleRBracket = simd_and(__temp__2,lex.RBracket);
     942                        print_register<BitBlock>("DoubleRBracket",DoubleRBracket);
     943                        BitBlock __temp__3;
     944                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),__temp__3));
     945                        CD_closer = simd_and(__temp__3,lex.RAngle);
     946                        print_register<BitBlock>("CD_closer",CD_closer);
     947                }
     948                else
     949                {
     950                        carry_set_0.carryDequeueEnqueue(0,2);
     951                }
     952                BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     953                print_register<BitBlock>("PI_closer",PI_closer);
     954                BitBlock __temp__4;
     955                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),__temp__4));
     956                BitBlock CtCDPI_Cursor = __temp__4;
     957                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     958                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
     959                {
     960                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     961                        print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
     962                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     963                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
     964                        BitBlock __temp__5;
     965                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),__temp__5));
     966                        BitBlock CD_Ct_Cursor = __temp__5;
     967                        print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
     968                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     969                        print_register<BitBlock>("CD_Cursor",CD_Cursor);
     970                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     971                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     972                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
     973                        {
     974                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     975                                print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
     976                                BitBlock __temp__6;
     977                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),__temp__6));
     978                                PI_Cursor = __temp__6;
     979                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
     980                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     981                                print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
     982                                BitBlock __temp__7;
     983                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),__temp__7));
     984                                BitBlock PI_name_end = __temp__7;
     985                                print_register<BitBlock>("PI_name_end",PI_name_end);
     986                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     987                                print_register<BitBlock>("PI_error",PI_error);
     988                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     989                                print_register<BitBlock>("PI_noWS",PI_noWS);
     990                                BitBlock __temp__8;
     991                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),__temp__8));
     992                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
     993                                print_register<BitBlock>("PI_error",PI_error);
     994                                if (bitblock::any(PI_error))
     995                                {
     996                                        assert_0_error("Error in PI syntax",PI_error);
     997                                }
     998                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     999                                print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
     1000                                BitBlock __temp__9;
     1001                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_0.getCarry(7),__temp__9));
     1002                                PI_Cursor = __temp__9;
     1003                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
     1004                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     1005                                print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
     1006                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     1007                                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    5801008                        }
    5811009                        else
    5821010                        {
    583                                 carry_set_0.CarryDequeueEnqueue(0,2);
    584                         }
    585                         BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    586                         BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
    587                         if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.CarryRange(3,13))))
    588                         {
     1011                                carry_set_0.carryDequeueEnqueue(4,4);
     1012                        }
     1013                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
     1014                        {
     1015                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     1016                                print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
     1017                                BitBlock __temp__10;
     1018                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),__temp__10));
     1019                                CD_Cursor = __temp__10;
     1020                                print_register<BitBlock>("CD_Cursor",CD_Cursor);
     1021                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     1022                                print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
     1023                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     1024                                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     1025                        }
     1026                        else
     1027                        {
     1028                                carry_set_0.carryDequeueEnqueue(8,1);
     1029                        }
     1030                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
     1031                        {
     1032                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     1033                                print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
     1034                                BitBlock __temp__11;
     1035                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),__temp__11));
     1036                                Ct_Cursor = __temp__11;
     1037                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1038                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1039                                print_register<BitBlock>("Ct_error",Ct_error);
     1040                                BitBlock __temp__12;
     1041                                BitBlock __temp__13;
     1042                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),__temp__12));
     1043                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_0.getCarry(11),__temp__13));
     1044                                Ct_Cursor = __temp__13;
     1045                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1046                                BitBlock __temp__14;
     1047                                BitBlock __temp__15;
     1048                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),__temp__14));
     1049                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_0.getCarry(13),__temp__15));
     1050                                Ct_Cursor = __temp__15;
     1051                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1052                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     1053                                {
     1054                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     1055                                }
     1056                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     1057                                print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
     1058                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     1059                                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     1060                        }
     1061                        else
     1062                        {
     1063                                carry_set_0.carryDequeueEnqueue(9,5);
     1064                        }
     1065                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     1066                        print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1067                        BitBlock __temp__16;
     1068                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),__temp__16));
     1069                        ctCDPI_mask = __temp__16;
     1070                        print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
     1071                        if (bitblock::any(simd<1>::constant<0>()))
     1072                        {
     1073                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
     1074                        }
     1075                        BitBlock __temp__17;
     1076                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),__temp__17));
     1077                        CtCDPI_Cursor = __temp__17;
     1078                        print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1079                        while (bitblock::any(CtCDPI_Cursor))
     1080                        {
     1081                                CarryDeclare(carry_set_1,13,0);
    5891082                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     1083                                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    5901084                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    591                                 BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
     1085                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
     1086                                BitBlock __temp__5;
     1087                                carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),__temp__5));
     1088                                BitBlock CD_Ct_Cursor = __temp__5;
     1089                                print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    5921090                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1091                                print_register<BitBlock>("CD_Cursor",CD_Cursor);
    5931092                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    594                                 if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
     1093                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1094                                if (bitblock::any(PI_Cursor))
    5951095                                {
    5961096                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    597                                         PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
     1097                                        print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
     1098                                        BitBlock __temp__6;
     1099                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),__temp__6));
     1100                                        PI_Cursor = __temp__6;
     1101                                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
    5981102                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    599                                         BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
     1103                                        print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
     1104                                        BitBlock __temp__7;
     1105                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),__temp__7));
     1106                                        BitBlock PI_name_end = __temp__7;
     1107                                        print_register<BitBlock>("PI_name_end",PI_name_end);
    6001108                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1109                                        print_register<BitBlock>("PI_error",PI_error);
    6011110                                        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(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
     1111                                        print_register<BitBlock>("PI_noWS",PI_noWS);
     1112                                        BitBlock __temp__8;
     1113                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),__temp__8));
     1114                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
     1115                                        print_register<BitBlock>("PI_error",PI_error);
    6031116                                        if (bitblock::any(PI_error))
    6041117                                        {
     
    6061119                                        }
    6071120                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    608                                         PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),carry_set_0.GetCarry(7),7);
     1121                                        print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
     1122                                        BitBlock __temp__9;
     1123                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),__temp__9));
     1124                                        PI_Cursor = __temp__9;
     1125                                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
    6091126                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     1127                                        print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    6101128                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     1129                                        print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    6111130                                }
    612                                 else
    613                                 {
    614                                         carry_set_0.CarryDequeueEnqueue(4,4);
    615                                 }
    616                                 if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
     1131                                if (bitblock::any(CD_Cursor))
    6171132                                {
    6181133                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    619                                         CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),carry_set_0.GetCarry(8),8);
     1134                                        print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
     1135                                        BitBlock __temp__10;
     1136                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),__temp__10));
     1137                                        CD_Cursor = __temp__10;
     1138                                        print_register<BitBlock>("CD_Cursor",CD_Cursor);
    6201139                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     1140                                        print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    6211141                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     1142                                        print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    6221143                                }
    623                                 else
    624                                 {
    625                                         carry_set_0.CarryDequeueEnqueue(8,1);
    626                                 }
    627                                 if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
     1144                                if (bitblock::any(Ct_Cursor))
    6281145                                {
    6291146                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    630                                         Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
     1147                                        print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
     1148                                        BitBlock __temp__11;
     1149                                        carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),__temp__11));
     1150                                        Ct_Cursor = __temp__11;
     1151                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    6311152                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    632                                         Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(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.GetCarry(12),12),carry_set_0.GetCarry(13),13);
     1153                                        print_register<BitBlock>("Ct_error",Ct_error);
     1154                                        BitBlock __temp__12;
     1155                                        BitBlock __temp__13;
     1156                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),__temp__12));
     1157                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_1.getCarry(8),__temp__13));
     1158                                        Ct_Cursor = __temp__13;
     1159                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1160                                        BitBlock __temp__14;
     1161                                        BitBlock __temp__15;
     1162                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),__temp__14));
     1163                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_1.getCarry(10),__temp__15));
     1164                                        Ct_Cursor = __temp__15;
     1165                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    6341166                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    6351167                                        {
     
    6371169                                        }
    6381170                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     1171                                        print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    6391172                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    640                                 }
    641                                 else
    642                                 {
    643                                         carry_set_0.CarryDequeueEnqueue(9,5);
     1173                                        print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    6441174                                }
    6451175                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    646                                 ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
     1176                                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1177                                BitBlock __temp__16;
     1178                                carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),__temp__16));
     1179                                ctCDPI_mask = __temp__16;
     1180                                print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    6471181                                if (bitblock::any(simd<1>::constant<0>()))
    6481182                                {
    6491183                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
    6501184                                }
    651                                 CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.GetCarry(15),15);
    652                                 while (bitblock::any(CtCDPI_Cursor))
     1185                                BitBlock __temp__17;
     1186                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),__temp__17));
     1187                                CtCDPI_Cursor = __temp__17;
     1188                                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1189                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1190                        }
     1191                }
     1192                else
     1193                {
     1194                        carry_set_0.carryDequeueEnqueue(3,13);
     1195                }
     1196                BitBlock __temp__18;
     1197                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.getCarry(16),__temp__18));
     1198                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),__temp__18),CtCDPI_starts),EOF_mask);
     1199                print_register<BitBlock>("check_streams.misc_mask",check_streams.misc_mask);
     1200                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     1201                print_register<BitBlock>("marker.LAngle_scope",marker.LAngle_scope);
     1202                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     1203                print_register<BitBlock>("marker.Ref_opener",marker.Ref_opener);
     1204                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     1205                print_register<BitBlock>("marker.CD_closer",marker.CD_closer);
     1206                carry_set_0.carryAdjust(17);
     1207        }
     1208       
     1209        void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
     1210        {
     1211                ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
     1212                print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
     1213                ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
     1214                print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
     1215                ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
     1216                print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
     1217                ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
     1218                print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
     1219                ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
     1220                print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
     1221                ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
     1222                print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
     1223                ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
     1224                print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
     1225                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
     1226                print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
     1227                BitBlock CtCDPI_starts = simd<1>::constant<0>();
     1228                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
     1229                BitBlock CtCDPI_ends = simd<1>::constant<0>();
     1230                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     1231                BitBlock ctCDPI_mask = simd<1>::constant<0>();
     1232                print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
     1233                BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     1234                print_register<BitBlock>("v",v);
     1235                BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     1236                print_register<BitBlock>("w",w);
     1237                BitBlock __temp__0;
     1238                carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),__temp__0));
     1239                BitBlock v1 = __temp__0;
     1240                print_register<BitBlock>("v1",v1);
     1241                BitBlock __temp__1;
     1242                carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),__temp__1));
     1243                BitBlock w1 = __temp__1;
     1244                print_register<BitBlock>("w1",w1);
     1245                BitBlock LAngle_scope = simd_andc(v1,w1);
     1246                print_register<BitBlock>("LAngle_scope",LAngle_scope);
     1247                BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     1248                print_register<BitBlock>("PI_opener",PI_opener);
     1249                BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     1250                print_register<BitBlock>("CtCD_opener",CtCD_opener);
     1251                BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     1252                print_register<BitBlock>("CtCDPI_opener",CtCDPI_opener);
     1253                BitBlock CD_closer = simd<1>::constant<0>();
     1254                print_register<BitBlock>("CD_closer",CD_closer);
     1255                BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     1256                print_register<BitBlock>("DoubleHyphen",DoubleHyphen);
     1257                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
     1258                {
     1259                        BitBlock __temp__2;
     1260                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),__temp__2));
     1261                        BitBlock DoubleRBracket = simd_and(__temp__2,lex.RBracket);
     1262                        print_register<BitBlock>("DoubleRBracket",DoubleRBracket);
     1263                        BitBlock __temp__3;
     1264                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),__temp__3));
     1265                        CD_closer = simd_and(__temp__3,lex.RAngle);
     1266                        print_register<BitBlock>("CD_closer",CD_closer);
     1267                }
     1268                else
     1269                {
     1270                        carry_set_0.carryDequeueEnqueue(0,2);
     1271                }
     1272                BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     1273                print_register<BitBlock>("PI_closer",PI_closer);
     1274                BitBlock __temp__4;
     1275                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),__temp__4));
     1276                BitBlock CtCDPI_Cursor = __temp__4;
     1277                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1278                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(3,13))))
     1279                {
     1280                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     1281                        print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
     1282                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     1283                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
     1284                        BitBlock __temp__5;
     1285                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),__temp__5));
     1286                        BitBlock CD_Ct_Cursor = __temp__5;
     1287                        print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
     1288                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1289                        print_register<BitBlock>("CD_Cursor",CD_Cursor);
     1290                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     1291                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1292                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
     1293                        {
     1294                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
     1295                                print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
     1296                                BitBlock __temp__6;
     1297                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),__temp__6));
     1298                                PI_Cursor = __temp__6;
     1299                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
     1300                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
     1301                                print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
     1302                                BitBlock __temp__7;
     1303                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),__temp__7));
     1304                                BitBlock PI_name_end = __temp__7;
     1305                                print_register<BitBlock>("PI_name_end",PI_name_end);
     1306                                BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1307                                print_register<BitBlock>("PI_error",PI_error);
     1308                                BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     1309                                print_register<BitBlock>("PI_noWS",PI_noWS);
     1310                                BitBlock __temp__8;
     1311                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),__temp__8));
     1312                                PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
     1313                                print_register<BitBlock>("PI_error",PI_error);
     1314                                if (bitblock::any(PI_error))
    6531315                                {
    654                                         CarryDeclare(carry_set_1,13,0);
    655                                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    656                                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    657                                         BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
    658                                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    659                                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    660                                         if (bitblock::any(PI_Cursor))
    661                                         {
    662                                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    663                                                 PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
    664                                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    665                                                 BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
    666                                                 BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
    667                                                 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(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
    669                                                 if (bitblock::any(PI_error))
    670                                                 {
    671                                                         assert_0_error("Error in PI syntax",PI_error);
    672                                                 }
    673                                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    674                                                 PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_not(PI_closer),simd<1>::constant<0>(),4);
    675                                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    676                                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    677                                         }
    678                                         if (bitblock::any(CD_Cursor))
    679                                         {
    680                                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    681                                                 CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_not(CD_closer),simd<1>::constant<0>(),5);
    682                                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    683                                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    684                                         }
    685                                         if (bitblock::any(Ct_Cursor))
    686                                         {
    687                                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    688                                                 Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
    689                                                 BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    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);
    692                                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    693                                                 {
    694                                                         assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    695                                                 }
    696                                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    697                                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    698                                         }
    699                                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    700                                         ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
    701                                         if (bitblock::any(simd<1>::constant<0>()))
    702                                         {
    703                                                 assert_0_error("Error in comment, CDATA or processing instruction syntax",simd<1>::constant<0>());
    704                                         }
    705                                         CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_not(CtCDPI_opener),simd<1>::constant<0>(),12);
    706                                         LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1316                                        assert_0_error("Error in PI syntax",PI_error);
    7071317                                }
     1318                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
     1319                                print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
     1320                                BitBlock __temp__9;
     1321                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),__temp__9));
     1322                                PI_Cursor = __temp__9;
     1323                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
     1324                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     1325                                print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
     1326                                CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     1327                                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    7081328                        }
    7091329                        else
    7101330                        {
    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.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
    714                         marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    715                         marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    716                         marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    717                         carry_set_0.CarryAdjust(17);
    718                 }
    719                
    720                 void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
    721                 {
    722                         ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    723                         ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    724                         ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    725                         ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    726                         ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    727                         ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    728                         ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    729                         ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    730                         BitBlock CtCDPI_starts = simd<1>::constant<0>();
    731                         BitBlock CtCDPI_ends = simd<1>::constant<0>();
    732                         BitBlock ctCDPI_mask = simd<1>::constant<0>();
    733                         BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
    734                         BitBlock w = simd_or(lex.Hyphen,lex.QMark);
    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);
    737                         BitBlock LAngle_scope = simd_andc(v1,w1);
    738                         BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
    739                         BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    740                         BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    741                         BitBlock CD_closer = simd<1>::constant<0>();
    742                         BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    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.GetCarry(0),0),lex.RBracket);
    746                                 CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket,carry_set_0.GetCarry(1),1),lex.RAngle);
     1331                                carry_set_0.carryDequeueEnqueue(4,4);
     1332                        }
     1333                        if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
     1334                        {
     1335                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
     1336                                print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
     1337                                BitBlock __temp__10;
     1338                                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),__temp__10));
     1339                                CD_Cursor = __temp__10;
     1340                                print_register<BitBlock>("CD_Cursor",CD_Cursor);
     1341                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     1342                                print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
     1343                                CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     1344                                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    7471345                        }
    7481346                        else
    7491347                        {
    750                                 carry_set_0.CarryDequeueEnqueue(0,2);
    751                         }
    752                         BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    753                         BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener,carry_set_0.GetCarry(2),2);
    754                         if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.CarryRange(3,13))))
    755                         {
     1348                                carry_set_0.carryDequeueEnqueue(8,1);
     1349                        }
     1350                        if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
     1351                        {
     1352                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
     1353                                print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
     1354                                BitBlock __temp__11;
     1355                                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),__temp__11));
     1356                                Ct_Cursor = __temp__11;
     1357                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1358                                BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1359                                print_register<BitBlock>("Ct_error",Ct_error);
     1360                                BitBlock __temp__12;
     1361                                BitBlock __temp__13;
     1362                                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),__temp__12));
     1363                                carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_0.getCarry(11),__temp__13));
     1364                                Ct_Cursor = __temp__13;
     1365                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1366                                BitBlock __temp__14;
     1367                                BitBlock __temp__15;
     1368                                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),__temp__14));
     1369                                carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_0.getCarry(13),__temp__15));
     1370                                Ct_Cursor = __temp__15;
     1371                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1372                                if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
     1373                                {
     1374                                        assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
     1375                                }
     1376                                ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     1377                                print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
     1378                                CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
     1379                                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
     1380                        }
     1381                        else
     1382                        {
     1383                                carry_set_0.carryDequeueEnqueue(9,5);
     1384                        }
     1385                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
     1386                        print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1387                        BitBlock __temp__16;
     1388                        carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),__temp__16));
     1389                        ctCDPI_mask = __temp__16;
     1390                        print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
     1391                        if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
     1392                        {
     1393                                assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
     1394                        }
     1395                        BitBlock __temp__17;
     1396                        carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),__temp__17));
     1397                        CtCDPI_Cursor = __temp__17;
     1398                        print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1399                        while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
     1400                        {
     1401                                CarryDeclare(carry_set_1,13,0);
    7561402                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
     1403                                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    7571404                                BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    758                                 BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.GetCarry(3),3);
     1405                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
     1406                                BitBlock __temp__5;
     1407                                carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),__temp__5));
     1408                                BitBlock CD_Ct_Cursor = __temp__5;
     1409                                print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    7591410                                BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1411                                print_register<BitBlock>("CD_Cursor",CD_Cursor);
    7601412                                BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    761                                 if (bitblock::any(simd_or(PI_Cursor,carry_set_0.CarryRange(4,4))))
     1413                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1414                                if (bitblock::any(PI_Cursor))
    7621415                                {
    7631416                                        ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    764                                         PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor,carry_set_0.GetCarry(4),4);
     1417                                        print_register<BitBlock>("ctCDPI_Callouts.PI_starts",ctCDPI_Callouts.PI_starts);
     1418                                        BitBlock __temp__6;
     1419                                        carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),__temp__6));
     1420                                        PI_Cursor = __temp__6;
     1421                                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
    7651422                                        ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    766                                         BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,carry_set_0.GetCarry(5),5);
     1423                                        print_register<BitBlock>("ctCDPI_Callouts.PI_name_starts",ctCDPI_Callouts.PI_name_starts);
     1424                                        BitBlock __temp__7;
     1425                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),__temp__7));
     1426                                        BitBlock PI_name_end = __temp__7;
     1427                                        print_register<BitBlock>("PI_name_end",PI_name_end);
    7671428                                        BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1429                                        print_register<BitBlock>("PI_error",PI_error);
    7681430                                        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(carry_set_0.BitBlock_advance_ci_co(PI_noWS,carry_set_0.GetCarry(6),6),PI_closer)));
     1431                                        print_register<BitBlock>("PI_noWS",PI_noWS);
     1432                                        BitBlock __temp__8;
     1433                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),__temp__8));
     1434                                        PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(__temp__8,PI_closer)));
     1435                                        print_register<BitBlock>("PI_error",PI_error);
    7701436                                        if (bitblock::any(PI_error))
    7711437                                        {
     
    7731439                                        }
    7741440                                        ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    775                                         PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.GetCarry(7),7);
     1441                                        print_register<BitBlock>("ctCDPI_Callouts.PI_name_ends",ctCDPI_Callouts.PI_name_ends);
     1442                                        BitBlock __temp__9;
     1443                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),__temp__9));
     1444                                        PI_Cursor = __temp__9;
     1445                                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
    7761446                                        ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
     1447                                        print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    7771448                                        CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
     1449                                        print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    7781450                                }
    779                                 else
    780                                 {
    781                                         carry_set_0.CarryDequeueEnqueue(4,4);
    782                                 }
    783                                 if (bitblock::any(simd_or(CD_Cursor,carry_set_0.CarryRange(8,1))))
     1451                                if (bitblock::any(CD_Cursor))
    7841452                                {
    7851453                                        ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    786                                         CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.GetCarry(8),8);
     1454                                        print_register<BitBlock>("ctCDPI_Callouts.CD_starts",ctCDPI_Callouts.CD_starts);
     1455                                        BitBlock __temp__10;
     1456                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),__temp__10));
     1457                                        CD_Cursor = __temp__10;
     1458                                        print_register<BitBlock>("CD_Cursor",CD_Cursor);
    7871459                                        ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
     1460                                        print_register<BitBlock>("ctCDPI_Callouts.CD_ends",ctCDPI_Callouts.CD_ends);
    7881461                                        CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
     1462                                        print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    7891463                                }
    790                                 else
    791                                 {
    792                                         carry_set_0.CarryDequeueEnqueue(8,1);
    793                                 }
    794                                 if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.CarryRange(9,5))))
     1464                                if (bitblock::any(Ct_Cursor))
    7951465                                {
    7961466                                        ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    797                                         Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(9),9);
     1467                                        print_register<BitBlock>("ctCDPI_Callouts.Ct_starts",ctCDPI_Callouts.Ct_starts);
     1468                                        BitBlock __temp__11;
     1469                                        carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),__temp__11));
     1470                                        Ct_Cursor = __temp__11;
     1471                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    7981472                                        BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    799                                         Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor,carry_set_0.GetCarry(10),10),carry_set_0.GetCarry(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.GetCarry(12),12),carry_set_0.GetCarry(13),13);
     1473                                        print_register<BitBlock>("Ct_error",Ct_error);
     1474                                        BitBlock __temp__12;
     1475                                        BitBlock __temp__13;
     1476                                        carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),__temp__12));
     1477                                        carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(__temp__12,carry_set_1.getCarry(8),__temp__13));
     1478                                        Ct_Cursor = __temp__13;
     1479                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
     1480                                        BitBlock __temp__14;
     1481                                        BitBlock __temp__15;
     1482                                        carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),__temp__14));
     1483                                        carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(__temp__14,carry_set_1.getCarry(10),__temp__15));
     1484                                        Ct_Cursor = __temp__15;
     1485                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    8011486                                        if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    8021487                                        {
     
    8041489                                        }
    8051490                                        ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
     1491                                        print_register<BitBlock>("ctCDPI_Callouts.Ct_ends",ctCDPI_Callouts.Ct_ends);
    8061492                                        CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    807                                 }
    808                                 else
    809                                 {
    810                                         carry_set_0.CarryDequeueEnqueue(9,5);
     1493                                        print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    8111494                                }
    8121495                                CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    813                                 ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,carry_set_0.GetCarry(14),14);
     1496                                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1497                                BitBlock __temp__16;
     1498                                carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),__temp__16));
     1499                                ctCDPI_mask = __temp__16;
     1500                                print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    8141501                                if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    8151502                                {
    8161503                                        assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
    8171504                                }
    818                                 CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.GetCarry(15),15);
    819                                 while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    820                                 {
    821                                         CarryDeclare(carry_set_1,13,0);
    822                                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    823                                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    824                                         BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor,PI_Cursor),simd<1>::constant<0>(),0);
    825                                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    826                                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    827                                         if (bitblock::any(PI_Cursor))
    828                                         {
    829                                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    830                                                 PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor,simd<1>::constant<0>(),1);
    831                                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    832                                                 BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor,lex.NameScan,simd<1>::constant<0>(),2);
    833                                                 BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
    834                                                 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(carry_set_1.BitBlock_advance_ci_co(PI_noWS,simd<1>::constant<0>(),3),PI_closer)));
    836                                                 if (bitblock::any(PI_error))
    837                                                 {
    838                                                         assert_0_error("Error in PI syntax",PI_error);
    839                                                 }
    840                                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    841                                                 PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end,simd_andc(EOF_mask,PI_closer),simd<1>::constant<0>(),4);
    842                                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    843                                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    844                                         }
    845                                         if (bitblock::any(CD_Cursor))
    846                                         {
    847                                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    848                                                 CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor,simd_andc(EOF_mask,CD_closer),simd<1>::constant<0>(),5);
    849                                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    850                                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    851                                         }
    852                                         if (bitblock::any(Ct_Cursor))
    853                                         {
    854                                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    855                                                 Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor,simd<1>::constant<0>(),6);
    856                                                 BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    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);
    859                                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    860                                                 {
    861                                                         assert_0_error("Error in comment syntax",simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)));
    862                                                 }
    863                                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    864                                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    865                                         }
    866                                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    867                                         ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts,CtCDPI_ends,simd<1>::constant<0>(),11);
    868                                         if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    869                                         {
    870                                                 assert_0_error("Error in comment, CDATA or processing instruction syntax",simd_andc(ctCDPI_mask,EOF_mask));
    871                                         }
    872                                         CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),simd<1>::constant<0>(),12);
    873                                         LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    874                                 }
    875                         }
    876                         else
    877                         {
    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.GetCarry(16),16)),CtCDPI_starts),EOF_mask);
    881                         marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    882                         marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    883                         marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    884                 }
    885                
    886                 CarryDeclare(carry_set_0,17,2);
    887         };
    888          
     1505                                BitBlock __temp__17;
     1506                                carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),__temp__17));
     1507                                CtCDPI_Cursor = __temp__17;
     1508                                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
     1509                                LocalCarryCombine(carry_set_0,carry_set_1,3,13);
     1510                        }
     1511                }
     1512                else
     1513                {
     1514                        carry_set_0.carryDequeueEnqueue(3,13);
     1515                }
     1516                BitBlock __temp__18;
     1517                carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.getCarry(16),__temp__18));
     1518                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),__temp__18),CtCDPI_starts),EOF_mask);
     1519                print_register<BitBlock>("check_streams.misc_mask",check_streams.misc_mask);
     1520                marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
     1521                print_register<BitBlock>("marker.LAngle_scope",marker.LAngle_scope);
     1522                marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
     1523                print_register<BitBlock>("marker.Ref_opener",marker.Ref_opener);
     1524                marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
     1525                print_register<BitBlock>("marker.CD_closer",marker.CD_closer);
     1526        }
     1527       
     1528        CarryDeclare(carry_set_0,17,2);
     1529};
     1530 
    8891531struct Parse_tags
    8901532{
     
    8921534        {
    8931535        }
    894          
     1536       
    8951537        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
    8961538        {
    8971539                BitBlock EqExpected = simd<1>::constant<0>();
     1540                print_register<BitBlock>("EqExpected",EqExpected);
    8981541                BitBlock AttListEnd = simd<1>::constant<0>();
     1542                print_register<BitBlock>("AttListEnd",AttListEnd);
    8991543                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     1544                print_register<BitBlock>("DQuoteDelim",DQuoteDelim);
    9001545                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     1546                print_register<BitBlock>("SQuoteDelim",SQuoteDelim);
    9011547                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
     1548                print_register<BitBlock>("AttListDelim",AttListDelim);
    9021549                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
     1550                print_register<BitBlock>("tag_Callouts.ElemName_starts",tag_Callouts.ElemName_starts);
    9031551                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    904                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
     1552                print_register<BitBlock>("tag_Callouts.EndTag_marks",tag_Callouts.EndTag_marks);
     1553                BitBlock __temp__0;
     1554                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),__temp__0));
     1555                tag_Callouts.ElemName_ends = __temp__0;
     1556                print_register<BitBlock>("tag_Callouts.ElemName_ends",tag_Callouts.ElemName_ends);
    9051557                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     1558                print_register<BitBlock>("ParseError",ParseError);
    9061559                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     1560                print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    9071561                tag_Callouts.AttName_ends = simd<1>::constant<0>();
     1562                print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    9081563                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
     1564                print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    9091565                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    910                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
    911                 {
    912                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
     1566                print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
     1567                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
     1568                {
     1569                        BitBlock __temp__1;
     1570                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),__temp__1));
     1571                        BitBlock AfterWS = __temp__1;
     1572                        print_register<BitBlock>("AfterWS",AfterWS);
    9131573                        AttListEnd = simd_and(AfterWS,AttListDelim);
     1574                        print_register<BitBlock>("AttListEnd",AttListEnd);
    9141575                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
    915                         if (bitblock::any(simd_or(AttNameStart,carry_set_0.CarryRange(2,7))))
     1576                        print_register<BitBlock>("AttNameStart",AttNameStart);
     1577                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
    9161578                        {
    9171579                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1580                                print_register<BitBlock>("ParseError",ParseError);
    9181581                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    919                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
     1582                                print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
     1583                                BitBlock __temp__2;
     1584                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),__temp__2));
     1585                                BitBlock AttNameFollow = __temp__2;
     1586                                print_register<BitBlock>("AttNameFollow",AttNameFollow);
    9201587                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    921                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
     1588                                print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
     1589                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    9221590                                {
    923                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
     1591                                        BitBlock __temp__3;
     1592                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),__temp__3));
     1593                                        EqExpected = __temp__3;
     1594                                        print_register<BitBlock>("EqExpected",EqExpected);
    9241595                                }
    9251596                                else
    9261597                                {
    9271598                                        EqExpected = AttNameFollow;
    928                                         carry_set_0.CarryDequeueEnqueue(3,1);
     1599                                        print_register<BitBlock>("EqExpected",EqExpected);
     1600                                        carry_set_0.carryDequeueEnqueue(3,1);
    9291601                                }
    9301602                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    931                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
     1603                                print_register<BitBlock>("ParseError",ParseError);
     1604                                BitBlock __temp__4;
     1605                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),__temp__4));
     1606                                BitBlock AttValPos = __temp__4;
     1607                                print_register<BitBlock>("AttValPos",AttValPos);
    9321608                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1609                                print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    9331610                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1611                                print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    9341612                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    935                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.GetCarry(5),5);
    936                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.GetCarry(6),6);
     1613                                print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
     1614                                BitBlock __temp__5;
     1615                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),__temp__5));
     1616                                BitBlock DQuoteAttEnd = __temp__5;
     1617                                print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
     1618                                BitBlock __temp__6;
     1619                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),__temp__6));
     1620                                BitBlock SQuoteAttEnd = __temp__6;
     1621                                print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    9371622                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1623                                print_register<BitBlock>("AttValEnd",AttValEnd);
    9381624                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    939                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
     1625                                print_register<BitBlock>("ParseError",ParseError);
     1626                                BitBlock __temp__7;
     1627                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),__temp__7));
     1628                                BitBlock AttValFollow = __temp__7;
     1629                                print_register<BitBlock>("AttValFollow",AttValFollow);
    9401630                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    941                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
     1631                                print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
     1632                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    9421633                                {
    943                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
     1634                                        BitBlock __temp__8;
     1635                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),__temp__8));
     1636                                        AfterWS = __temp__8;
     1637                                        print_register<BitBlock>("AfterWS",AfterWS);
    9441638                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1639                                        print_register<BitBlock>("AttListEnd",AttListEnd);
    9451640                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     1641                                        print_register<BitBlock>("AttNameStart",AttNameStart);
    9461642                                }
    9471643                                else
    9481644                                {
    9491645                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1646                                        print_register<BitBlock>("AttListEnd",AttListEnd);
    9501647                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    951                                         carry_set_0.CarryDequeueEnqueue(8,1);
     1648                                        print_register<BitBlock>("AttNameStart",AttNameStart);
     1649                                        carry_set_0.carryDequeueEnqueue(8,1);
    9521650                                }
    9531651                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1652                                print_register<BitBlock>("ParseError",ParseError);
    9541653                                while (bitblock::any(AttNameStart))
    9551654                                {
    9561655                                        CarryDeclare(carry_set_1,7,0);
    9571656                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1657                                        print_register<BitBlock>("ParseError",ParseError);
    9581658                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    959                                         BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
     1659                                        print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
     1660                                        BitBlock __temp__2;
     1661                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),__temp__2));
     1662                                        BitBlock AttNameFollow = __temp__2;
     1663                                        print_register<BitBlock>("AttNameFollow",AttNameFollow);
    9601664                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     1665                                        print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    9611666                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    9621667                                        {
    963                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
     1668                                                BitBlock __temp__3;
     1669                                                carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),__temp__3));
     1670                                                EqExpected = __temp__3;
     1671                                                print_register<BitBlock>("EqExpected",EqExpected);
    9641672                                        }
    9651673                                        else
    9661674                                        {
    9671675                                                EqExpected = AttNameFollow;
     1676                                                print_register<BitBlock>("EqExpected",EqExpected);
    9681677                                        }
    9691678                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    970                                         BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
     1679                                        print_register<BitBlock>("ParseError",ParseError);
     1680                                        BitBlock __temp__4;
     1681                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),__temp__4));
     1682                                        BitBlock AttValPos = __temp__4;
     1683                                        print_register<BitBlock>("AttValPos",AttValPos);
    9711684                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1685                                        print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    9721686                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1687                                        print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    9731688                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    974                                         BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_not(DQuoteDelim),simd<1>::constant<0>(),3);
    975                                         BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_not(SQuoteDelim),simd<1>::constant<0>(),4);
     1689                                        print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
     1690                                        BitBlock __temp__5;
     1691                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),__temp__5));
     1692                                        BitBlock DQuoteAttEnd = __temp__5;
     1693                                        print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
     1694                                        BitBlock __temp__6;
     1695                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),__temp__6));
     1696                                        BitBlock SQuoteAttEnd = __temp__6;
     1697                                        print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    9761698                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1699                                        print_register<BitBlock>("AttValEnd",AttValEnd);
    9771700                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    978                                         BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
     1701                                        print_register<BitBlock>("ParseError",ParseError);
     1702                                        BitBlock __temp__7;
     1703                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),__temp__7));
     1704                                        BitBlock AttValFollow = __temp__7;
     1705                                        print_register<BitBlock>("AttValFollow",AttValFollow);
    9791706                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     1707                                        print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    9801708                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    9811709                                        {
    982                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
     1710                                                BitBlock __temp__8;
     1711                                                carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),__temp__8));
     1712                                                AfterWS = __temp__8;
     1713                                                print_register<BitBlock>("AfterWS",AfterWS);
    9831714                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1715                                                print_register<BitBlock>("AttListEnd",AttListEnd);
    9841716                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     1717                                                print_register<BitBlock>("AttNameStart",AttNameStart);
    9851718                                        }
    9861719                                        else
    9871720                                        {
    9881721                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1722                                                print_register<BitBlock>("AttListEnd",AttListEnd);
    9891723                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
     1724                                                print_register<BitBlock>("AttNameStart",AttNameStart);
    9901725                                        }
    9911726                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1727                                        print_register<BitBlock>("ParseError",ParseError);
    9921728                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
    9931729                                }
     
    9951731                        else
    9961732                        {
    997                                 carry_set_0.CarryDequeueEnqueue(2,7);
     1733                                carry_set_0.carryDequeueEnqueue(2,7);
    9981734                        }
    9991735                }
     
    10011737                {
    10021738                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
     1739                        print_register<BitBlock>("AttListEnd",AttListEnd);
    10031740                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1004                         carry_set_0.CarryDequeueEnqueue(1,8);
     1741                        print_register<BitBlock>("ParseError",ParseError);
     1742                        carry_set_0.carryDequeueEnqueue(1,8);
    10051743                }
    10061744                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
    1007                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
     1745                print_register<BitBlock>("STagEnds",STagEnds);
     1746                BitBlock __temp__9;
     1747                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),__temp__9));
     1748                tag_Callouts.EmptyTag_marks = __temp__9;
     1749                print_register<BitBlock>("tag_Callouts.EmptyTag_marks",tag_Callouts.EmptyTag_marks);
    10081750                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    1009                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
    1010                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
    1011                 {
    1012                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
     1751                print_register<BitBlock>("ParseError",ParseError);
     1752                BitBlock __temp__10;
     1753                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),__temp__10));
     1754                BitBlock EndTagEnds = __temp__10;
     1755                print_register<BitBlock>("EndTagEnds",EndTagEnds);
     1756                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
     1757                {
     1758                        BitBlock __temp__11;
     1759                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),__temp__11));
     1760                        EndTagEnds = __temp__11;
     1761                        print_register<BitBlock>("EndTagEnds",EndTagEnds);
    10131762                }
    10141763                else
    10151764                {
    1016                         carry_set_0.CarryDequeueEnqueue(11,1);
     1765                        carry_set_0.carryDequeueEnqueue(11,1);
    10171766                }
    10181767                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     1768                print_register<BitBlock>("ParseError",ParseError);
    10191769                if (bitblock::any(ParseError))
    10201770                {
    10211771                        assert_0_error("Tag parsing error found",ParseError);
    10221772                }
    1023                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
    1024                 carry_set_0.CarryAdjust(13);
     1773                BitBlock __temp__12;
     1774                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),__temp__12));
     1775                tag_Callouts.AttVal_spans = __temp__12;
     1776                print_register<BitBlock>("tag_Callouts.AttVal_spans",tag_Callouts.AttVal_spans);
     1777                carry_set_0.carryAdjust(13);
    10251778        }
    10261779       
     
    10281781        {
    10291782                BitBlock EqExpected = simd<1>::constant<0>();
     1783                print_register<BitBlock>("EqExpected",EqExpected);
    10301784                BitBlock AttListEnd = simd<1>::constant<0>();
     1785                print_register<BitBlock>("AttListEnd",AttListEnd);
    10311786                BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     1787                print_register<BitBlock>("DQuoteDelim",DQuoteDelim);
    10321788                BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     1789                print_register<BitBlock>("SQuoteDelim",SQuoteDelim);
    10331790                BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
     1791                print_register<BitBlock>("AttListDelim",AttListDelim);
    10341792                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
     1793                print_register<BitBlock>("tag_Callouts.ElemName_starts",tag_Callouts.ElemName_starts);
    10351794                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    1036                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.GetCarry(0),0);
     1795                print_register<BitBlock>("tag_Callouts.EndTag_marks",tag_Callouts.EndTag_marks);
     1796                BitBlock __temp__0;
     1797                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),__temp__0));
     1798                tag_Callouts.ElemName_ends = __temp__0;
     1799                print_register<BitBlock>("tag_Callouts.ElemName_ends",tag_Callouts.ElemName_ends);
    10371800                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     1801                print_register<BitBlock>("ParseError",ParseError);
    10381802                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     1803                print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
    10391804                tag_Callouts.AttName_ends = simd<1>::constant<0>();
     1805                print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    10401806                tag_Callouts.AttVal_starts = simd<1>::constant<0>();
     1807                print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    10411808                tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1042                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.CarryRange(1,8))))
    1043                 {
    1044                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.GetCarry(1),1);
     1809                print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
     1810                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
     1811                {
     1812                        BitBlock __temp__1;
     1813                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),__temp__1));
     1814                        BitBlock AfterWS = __temp__1;
     1815                        print_register<BitBlock>("AfterWS",AfterWS);
    10451816                        AttListEnd = simd_and(AfterWS,AttListDelim);
     1817                        print_register<BitBlock>("AttListEnd",AttListEnd);
    10461818                        BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
    1047                         if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.CarryRange(2,7))))
     1819                        print_register<BitBlock>("AttNameStart",AttNameStart);
     1820                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(2,7))))
    10481821                        {
    10491822                                ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1823                                print_register<BitBlock>("ParseError",ParseError);
    10501824                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1051                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,carry_set_0.GetCarry(2),2);
     1825                                print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
     1826                                BitBlock __temp__2;
     1827                                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),__temp__2));
     1828                                BitBlock AttNameFollow = __temp__2;
     1829                                print_register<BitBlock>("AttNameFollow",AttNameFollow);
    10521830                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1053                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.CarryRange(3,1))))
     1831                                print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
     1832                                if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    10541833                                {
    1055                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,carry_set_0.GetCarry(3),3);
     1834                                        BitBlock __temp__3;
     1835                                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),__temp__3));
     1836                                        EqExpected = __temp__3;
     1837                                        print_register<BitBlock>("EqExpected",EqExpected);
    10561838                                }
    10571839                                else
    10581840                                {
    10591841                                        EqExpected = AttNameFollow;
    1060                                         carry_set_0.CarryDequeueEnqueue(3,1);
     1842                                        print_register<BitBlock>("EqExpected",EqExpected);
     1843                                        carry_set_0.carryDequeueEnqueue(3,1);
    10611844                                }
    10621845                                ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1063                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected,lex.WS,carry_set_0.GetCarry(4),4);
     1846                                print_register<BitBlock>("ParseError",ParseError);
     1847                                BitBlock __temp__4;
     1848                                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),__temp__4));
     1849                                BitBlock AttValPos = __temp__4;
     1850                                print_register<BitBlock>("AttValPos",AttValPos);
    10641851                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1852                                print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    10651853                                BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1854                                print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    10661855                                BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1067                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.GetCarry(5),5);
    1068                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.GetCarry(6),6);
     1856                                print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
     1857                                BitBlock __temp__5;
     1858                                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),__temp__5));
     1859                                BitBlock DQuoteAttEnd = __temp__5;
     1860                                print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
     1861                                BitBlock __temp__6;
     1862                                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),__temp__6));
     1863                                BitBlock SQuoteAttEnd = __temp__6;
     1864                                print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    10691865                                BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1866                                print_register<BitBlock>("AttValEnd",AttValEnd);
    10701867                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1071                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd,carry_set_0.GetCarry(7),7);
     1868                                print_register<BitBlock>("ParseError",ParseError);
     1869                                BitBlock __temp__7;
     1870                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),__temp__7));
     1871                                BitBlock AttValFollow = __temp__7;
     1872                                print_register<BitBlock>("AttValFollow",AttValFollow);
    10721873                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1073                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.CarryRange(8,1))))
     1874                                print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
     1875                                if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    10741876                                {
    1075                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,carry_set_0.GetCarry(8),8);
     1877                                        BitBlock __temp__8;
     1878                                        carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),__temp__8));
     1879                                        AfterWS = __temp__8;
     1880                                        print_register<BitBlock>("AfterWS",AfterWS);
    10761881                                        AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1882                                        print_register<BitBlock>("AttListEnd",AttListEnd);
    10771883                                        AttNameStart = simd_andc(AfterWS,AttListDelim);
     1884                                        print_register<BitBlock>("AttNameStart",AttNameStart);
    10781885                                }
    10791886                                else
    10801887                                {
    10811888                                        AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1889                                        print_register<BitBlock>("AttListEnd",AttListEnd);
    10821890                                        AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1083                                         carry_set_0.CarryDequeueEnqueue(8,1);
     1891                                        print_register<BitBlock>("AttNameStart",AttNameStart);
     1892                                        carry_set_0.carryDequeueEnqueue(8,1);
    10841893                                }
    10851894                                ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1895                                print_register<BitBlock>("ParseError",ParseError);
    10861896                                while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
    10871897                                {
    10881898                                        CarryDeclare(carry_set_1,7,0);
    10891899                                        ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
     1900                                        print_register<BitBlock>("ParseError",ParseError);
    10901901                                        tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1091                                         BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart,lex.NameScan,simd<1>::constant<0>(),0);
     1902                                        print_register<BitBlock>("tag_Callouts.AttName_starts",tag_Callouts.AttName_starts);
     1903                                        BitBlock __temp__2;
     1904                                        carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),__temp__2));
     1905                                        BitBlock AttNameFollow = __temp__2;
     1906                                        print_register<BitBlock>("AttNameFollow",AttNameFollow);
    10921907                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     1908                                        print_register<BitBlock>("tag_Callouts.AttName_ends",tag_Callouts.AttName_ends);
    10931909                                        if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    10941910                                        {
    1095                                                 EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow,lex.WS,simd<1>::constant<0>(),1);
     1911                                                BitBlock __temp__3;
     1912                                                carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),__temp__3));
     1913                                                EqExpected = __temp__3;
     1914                                                print_register<BitBlock>("EqExpected",EqExpected);
    10961915                                        }
    10971916                                        else
    10981917                                        {
    10991918                                                EqExpected = AttNameFollow;
     1919                                                print_register<BitBlock>("EqExpected",EqExpected);
    11001920                                        }
    11011921                                        ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1102                                         BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected,lex.WS,simd<1>::constant<0>(),2);
     1922                                        print_register<BitBlock>("ParseError",ParseError);
     1923                                        BitBlock __temp__4;
     1924                                        carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),__temp__4));
     1925                                        BitBlock AttValPos = __temp__4;
     1926                                        print_register<BitBlock>("AttValPos",AttValPos);
    11031927                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
     1928                                        print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    11041929                                        BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1930                                        print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    11051931                                        BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1106                                         BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),simd<1>::constant<0>(),3);
    1107                                         BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),simd<1>::constant<0>(),4);
     1932                                        print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
     1933                                        BitBlock __temp__5;
     1934                                        carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),__temp__5));
     1935                                        BitBlock DQuoteAttEnd = __temp__5;
     1936                                        print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
     1937                                        BitBlock __temp__6;
     1938                                        carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),__temp__6));
     1939                                        BitBlock SQuoteAttEnd = __temp__6;
     1940                                        print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    11081941                                        BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1942                                        print_register<BitBlock>("AttValEnd",AttValEnd);
    11091943                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1110                                         BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd,simd<1>::constant<0>(),5);
     1944                                        print_register<BitBlock>("ParseError",ParseError);
     1945                                        BitBlock __temp__7;
     1946                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),__temp__7));
     1947                                        BitBlock AttValFollow = __temp__7;
     1948                                        print_register<BitBlock>("AttValFollow",AttValFollow);
    11111949                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     1950                                        print_register<BitBlock>("tag_Callouts.AttVal_ends",tag_Callouts.AttVal_ends);
    11121951                                        if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    11131952                                        {
    1114                                                 AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow,lex.WS,simd<1>::constant<0>(),6);
     1953                                                BitBlock __temp__8;
     1954                                                carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),__temp__8));
     1955                                                AfterWS = __temp__8;
     1956                                                print_register<BitBlock>("AfterWS",AfterWS);
    11151957                                                AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
     1958                                                print_register<BitBlock>("AttListEnd",AttListEnd);
    11161959                                                AttNameStart = simd_andc(AfterWS,AttListDelim);
     1960                                                print_register<BitBlock>("AttNameStart",AttNameStart);
    11171961                                        }
    11181962                                        else
    11191963                                        {
    11201964                                                AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
     1965                                                print_register<BitBlock>("AttListEnd",AttListEnd);
    11211966                                                AttNameStart = simd_andc(AttValFollow,AttListDelim);
     1967                                                print_register<BitBlock>("AttNameStart",AttNameStart);
    11221968                                        }
    11231969                                        ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
     1970                                        print_register<BitBlock>("ParseError",ParseError);
    11241971                                        LocalCarryCombine(carry_set_0,carry_set_1,2,7);
    11251972                                }
     
    11271974                        else
    11281975                        {
    1129                                 carry_set_0.CarryDequeueEnqueue(2,7);
     1976                                carry_set_0.carryDequeueEnqueue(2,7);
    11301977                        }
    11311978                }
     
    11331980                {
    11341981                        AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
     1982                        print_register<BitBlock>("AttListEnd",AttListEnd);
    11351983                        ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1136                         carry_set_0.CarryDequeueEnqueue(1,8);
     1984                        print_register<BitBlock>("ParseError",ParseError);
     1985                        carry_set_0.carryDequeueEnqueue(1,8);
    11371986                }
    11381987                BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
    1139                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd,lex.Slash),carry_set_0.GetCarry(9),9);
     1988                print_register<BitBlock>("STagEnds",STagEnds);
     1989                BitBlock __temp__9;
     1990                carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),__temp__9));
     1991                tag_Callouts.EmptyTag_marks = __temp__9;
     1992                print_register<BitBlock>("tag_Callouts.EmptyTag_marks",tag_Callouts.EmptyTag_marks);
    11401993                ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    1141                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.GetCarry(10),10);
    1142                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.CarryRange(11,1))))
    1143                 {
    1144                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds,lex.WS,carry_set_0.GetCarry(11),11);
     1994                print_register<BitBlock>("ParseError",ParseError);
     1995                BitBlock __temp__10;
     1996                carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),__temp__10));
     1997                BitBlock EndTagEnds = __temp__10;
     1998                print_register<BitBlock>("EndTagEnds",EndTagEnds);
     1999                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
     2000                {
     2001                        BitBlock __temp__11;
     2002                        carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),__temp__11));
     2003                        EndTagEnds = __temp__11;
     2004                        print_register<BitBlock>("EndTagEnds",EndTagEnds);
    11452005                }
    11462006                else
    11472007                {
    1148                         carry_set_0.CarryDequeueEnqueue(11,1);
     2008                        carry_set_0.carryDequeueEnqueue(11,1);
    11492009                }
    11502010                ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
     2011                print_register<BitBlock>("ParseError",ParseError);
    11512012                if (bitblock::any(ParseError))
    11522013                {
    11532014                        assert_0_error("Tag parsing error found",ParseError);
    11542015                }
    1155                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.GetCarry(12),12);
     2016                BitBlock __temp__12;
     2017                carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),__temp__12));
     2018                tag_Callouts.AttVal_spans = __temp__12;
     2019                print_register<BitBlock>("tag_Callouts.AttVal_spans",tag_Callouts.AttVal_spans);
    11562020        }
    11572021       
     
    11642028        {
    11652029        }
    1166          
     2030       
    11672031        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
    11682032        {
    11692033                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
     2034                print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
    11702035                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
     2036                print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
    11712037                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
     2038                print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
    11722039                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
     2040                print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
    11732041                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
     2042                print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
    11742043                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
     2044                print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    11752045                BitBlock ref_error = simd<1>::constant<0>();
    1176                 if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
    1177                 {
    1178                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
     2046                print_register<BitBlock>("ref_error",ref_error);
     2047                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
     2048                {
     2049                        BitBlock __temp__0;
     2050                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),__temp__0));
     2051                        BitBlock Ref_scope = __temp__0;
     2052                        print_register<BitBlock>("Ref_scope",Ref_scope);
    11792053                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
     2054                        print_register<BitBlock>("NumRef2",NumRef2);
    11802055                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    1181                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
     2056                        print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
     2057                        BitBlock __temp__1;
     2058                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),__temp__1));
     2059                        BitBlock NumRef3 = __temp__1;
     2060                        print_register<BitBlock>("NumRef3",NumRef3);
    11822061                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
     2062                        print_register<BitBlock>("HexRef3",HexRef3);
    11832063                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    1184                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
    1185                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
    1186                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
    1187                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
     2064                        print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
     2065                        BitBlock __temp__2;
     2066                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),__temp__2));
     2067                        ref_Callouts.HexRef_starts = __temp__2;
     2068                        print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
     2069                        BitBlock __temp__3;
     2070                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),__temp__3));
     2071                        ref_Callouts.GenRef_ends = __temp__3;
     2072                        print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
     2073                        BitBlock __temp__4;
     2074                        carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),__temp__4));
     2075                        ref_Callouts.DecRef_ends = __temp__4;
     2076                        print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
     2077                        BitBlock __temp__5;
     2078                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),__temp__5));
     2079                        ref_Callouts.HexRef_ends = __temp__5;
     2080                        print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    11882081                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     2082                        print_register<BitBlock>("ref_error1",ref_error1);
    11892083                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     2084                        print_register<BitBlock>("ref_error2",ref_error2);
    11902085                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     2086                        print_register<BitBlock>("ref_ends",ref_ends);
    11912087                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
     2088                        print_register<BitBlock>("ref_error3",ref_error3);
    11922089                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    11932090                        {
     
    11972094                else
    11982095                {
    1199                         carry_set_0.CarryDequeueEnqueue(0,6);
    1200                 }
    1201                 carry_set_0.CarryAdjust(6);
     2096                        carry_set_0.carryDequeueEnqueue(0,6);
     2097                }
     2098                carry_set_0.carryAdjust(6);
    12022099        }
    12032100       
     
    12052102        {
    12062103                ref_Callouts.GenRef_starts = simd<1>::constant<0>();
     2104                print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
    12072105                ref_Callouts.GenRef_ends = simd<1>::constant<0>();
     2106                print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
    12082107                ref_Callouts.DecRef_starts = simd<1>::constant<0>();
     2108                print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
    12092109                ref_Callouts.DecRef_ends = simd<1>::constant<0>();
     2110                print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
    12102111                ref_Callouts.HexRef_starts = simd<1>::constant<0>();
     2112                print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
    12112113                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
     2114                print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    12122115                BitBlock ref_error = simd<1>::constant<0>();
    1213                 if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.CarryRange(0,6))))
    1214                 {
    1215                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener,carry_set_0.GetCarry(0),0);
     2116                print_register<BitBlock>("ref_error",ref_error);
     2117                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
     2118                {
     2119                        BitBlock __temp__0;
     2120                        carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),__temp__0));
     2121                        BitBlock Ref_scope = __temp__0;
     2122                        print_register<BitBlock>("Ref_scope",Ref_scope);
    12162123                        BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
     2124                        print_register<BitBlock>("NumRef2",NumRef2);
    12172125                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    1218                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2,carry_set_0.GetCarry(1),1);
     2126                        print_register<BitBlock>("ref_Callouts.GenRef_starts",ref_Callouts.GenRef_starts);
     2127                        BitBlock __temp__1;
     2128                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),__temp__1));
     2129                        BitBlock NumRef3 = __temp__1;
     2130                        print_register<BitBlock>("NumRef3",NumRef3);
    12192131                        BitBlock HexRef3 = simd_and(NumRef3,lex.x);
     2132                        print_register<BitBlock>("HexRef3",HexRef3);
    12202133                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    1221                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3,carry_set_0.GetCarry(2),2);
    1222                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.GetCarry(3),3);
    1223                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.GetCarry(4),4);
    1224                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.GetCarry(5),5);
     2134                        print_register<BitBlock>("ref_Callouts.DecRef_starts",ref_Callouts.DecRef_starts);
     2135                        BitBlock __temp__2;
     2136                        carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),__temp__2));
     2137                        ref_Callouts.HexRef_starts = __temp__2;
     2138                        print_register<BitBlock>("ref_Callouts.HexRef_starts",ref_Callouts.HexRef_starts);
     2139                        BitBlock __temp__3;
     2140                        carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),__temp__3));
     2141                        ref_Callouts.GenRef_ends = __temp__3;
     2142                        print_register<BitBlock>("ref_Callouts.GenRef_ends",ref_Callouts.GenRef_ends);
     2143                        BitBlock __temp__4;
     2144                        carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),__temp__4));
     2145                        ref_Callouts.DecRef_ends = __temp__4;
     2146                        print_register<BitBlock>("ref_Callouts.DecRef_ends",ref_Callouts.DecRef_ends);
     2147                        BitBlock __temp__5;
     2148                        carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),__temp__5));
     2149                        ref_Callouts.HexRef_ends = __temp__5;
     2150                        print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    12252151                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     2152                        print_register<BitBlock>("ref_error1",ref_error1);
    12262153                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     2154                        print_register<BitBlock>("ref_error2",ref_error2);
    12272155                        BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     2156                        print_register<BitBlock>("ref_ends",ref_ends);
    12282157                        BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
     2158                        print_register<BitBlock>("ref_error3",ref_error3);
    12292159                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    12302160                        {
     
    12342164                else
    12352165                {
    1236                         carry_set_0.CarryDequeueEnqueue(0,6);
     2166                        carry_set_0.carryDequeueEnqueue(0,6);
    12372167                }
    12382168        }
     
    12462176        {
    12472177        }
    1248          
     2178       
    12492179        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)
    12502180        {
    1251                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.GetCarry(0),0);
    1252                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);
    1253                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.GetCarry(2),2);
    1254                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.GetCarry(3),3);
     2181                BitBlock __temp__0;
     2182                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),__temp__0));
     2183                BitBlock PI_names = __temp__0;
     2184                print_register<BitBlock>("PI_names",PI_names);
     2185                BitBlock __temp__1;
     2186                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),__temp__1));
     2187                BitBlock GenRefs = __temp__1;
     2188                print_register<BitBlock>("GenRefs",GenRefs);
     2189                BitBlock __temp__2;
     2190                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),__temp__2));
     2191                BitBlock ElemNames = __temp__2;
     2192                print_register<BitBlock>("ElemNames",ElemNames);
     2193                BitBlock __temp__3;
     2194                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),__temp__3));
     2195                BitBlock AttNames = __temp__3;
     2196                print_register<BitBlock>("AttNames",AttNames);
    12552197                BitBlock qname_stream = simd_or(ElemNames,AttNames);
     2198                print_register<BitBlock>("qname_stream",qname_stream);
    12562199                BitBlock ncname_stream = simd_or(PI_names,GenRefs);
     2200                print_register<BitBlock>("ncname_stream",ncname_stream);
    12572201                BitBlock name_stream = simd_or(qname_stream,ncname_stream);
    1258                 BitBlock name_start = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(4),4));
    1259                 BitBlock name_cursor = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(5),5));
     2202                print_register<BitBlock>("name_stream",name_stream);
     2203                BitBlock __temp__4;
     2204                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),__temp__4));
     2205                BitBlock name_start = simd_andc(name_stream,__temp__4);
     2206                print_register<BitBlock>("name_start",name_start);
     2207                BitBlock __temp__5;
     2208                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),__temp__5));
     2209                BitBlock name_cursor = simd_andc(name_stream,__temp__5);
     2210                print_register<BitBlock>("name_cursor",name_cursor);
    12602211                BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
    1261                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(6),6),lex.Colon);
    1262                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep,carry_set_0.GetCarry(7),7);
     2212                print_register<BitBlock>("void_prefix_err",void_prefix_err);
     2213                BitBlock __temp__6;
     2214                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),__temp__6));
     2215                BitBlock namespace_sep = simd_and(__temp__6,lex.Colon);
     2216                print_register<BitBlock>("namespace_sep",namespace_sep);
     2217                BitBlock __temp__7;
     2218                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),__temp__7));
     2219                BitBlock local_part_start = __temp__7;
     2220                print_register<BitBlock>("local_part_start",local_part_start);
    12632221                BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
    1264                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(8),8),lex.Colon);
     2222                print_register<BitBlock>("local_part_err",local_part_err);
     2223                BitBlock __temp__8;
     2224                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),__temp__8));
     2225                BitBlock colon2_err = simd_and(__temp__8,lex.Colon);
     2226                print_register<BitBlock>("colon2_err",colon2_err);
    12652227                BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
     2228                print_register<BitBlock>("ncname_err",ncname_err);
    12662229                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    12672230                {
     
    12692232                }
    12702233                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
     2234                print_register<BitBlock>("check_streams.non_ascii_name_starts",check_streams.non_ascii_name_starts);
    12712235                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
    1272                 carry_set_0.CarryAdjust(9);
     2236                print_register<BitBlock>("check_streams.non_ascii_names",check_streams.non_ascii_names);
     2237                carry_set_0.carryAdjust(9);
    12732238        }
    12742239       
    12752240        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)
    12762241        {
    1277                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.GetCarry(0),0);
    1278                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.GetCarry(1),1);
    1279                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.GetCarry(2),2);
    1280                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.GetCarry(3),3);
     2242                BitBlock __temp__0;
     2243                carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),__temp__0));
     2244                BitBlock PI_names = __temp__0;
     2245                print_register<BitBlock>("PI_names",PI_names);
     2246                BitBlock __temp__1;
     2247                carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),__temp__1));
     2248                BitBlock GenRefs = __temp__1;
     2249                print_register<BitBlock>("GenRefs",GenRefs);
     2250                BitBlock __temp__2;
     2251                carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),__temp__2));
     2252                BitBlock ElemNames = __temp__2;
     2253                print_register<BitBlock>("ElemNames",ElemNames);
     2254                BitBlock __temp__3;
     2255                carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),__temp__3));
     2256                BitBlock AttNames = __temp__3;
     2257                print_register<BitBlock>("AttNames",AttNames);
    12812258                BitBlock qname_stream = simd_or(ElemNames,AttNames);
     2259                print_register<BitBlock>("qname_stream",qname_stream);
    12822260                BitBlock ncname_stream = simd_or(PI_names,GenRefs);
     2261                print_register<BitBlock>("ncname_stream",ncname_stream);
    12832262                BitBlock name_stream = simd_or(qname_stream,ncname_stream);
    1284                 BitBlock name_start = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(4),4));
    1285                 BitBlock name_cursor = simd_andc(name_stream,carry_set_0.BitBlock_advance_ci_co(name_stream,carry_set_0.GetCarry(5),5));
     2263                print_register<BitBlock>("name_stream",name_stream);
     2264                BitBlock __temp__4;
     2265                carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),__temp__4));
     2266                BitBlock name_start = simd_andc(name_stream,__temp__4);
     2267                print_register<BitBlock>("name_start",name_start);
     2268                BitBlock __temp__5;
     2269                carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),__temp__5));
     2270                BitBlock name_cursor = simd_andc(name_stream,__temp__5);
     2271                print_register<BitBlock>("name_cursor",name_cursor);
    12862272                BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
    1287                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(6),6),lex.Colon);
    1288                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep,carry_set_0.GetCarry(7),7);
     2273                print_register<BitBlock>("void_prefix_err",void_prefix_err);
     2274                BitBlock __temp__6;
     2275                carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),__temp__6));
     2276                BitBlock namespace_sep = simd_and(__temp__6,lex.Colon);
     2277                print_register<BitBlock>("namespace_sep",namespace_sep);
     2278                BitBlock __temp__7;
     2279                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),__temp__7));
     2280                BitBlock local_part_start = __temp__7;
     2281                print_register<BitBlock>("local_part_start",local_part_start);
    12892282                BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
    1290                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.GetCarry(8),8),lex.Colon);
     2283                print_register<BitBlock>("local_part_err",local_part_err);
     2284                BitBlock __temp__8;
     2285                carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),__temp__8));
     2286                BitBlock colon2_err = simd_and(__temp__8,lex.Colon);
     2287                print_register<BitBlock>("colon2_err",colon2_err);
    12912288                BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
     2289                print_register<BitBlock>("ncname_err",ncname_err);
    12922290                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    12932291                {
     
    12952293                }
    12962294                check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
     2295                print_register<BitBlock>("check_streams.non_ascii_name_starts",check_streams.non_ascii_name_starts);
    12972296                check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
     2297                print_register<BitBlock>("check_streams.non_ascii_names",check_streams.non_ascii_names);
    12982298        }
    12992299       
     
    13062306        {
    13072307        }
    1308          
     2308       
    13092309        IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
    13102310        {
     
    13142314                }
    13152315                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks,tag_Callouts.ElemName_starts),tag_Callouts.EndTag_marks),tag_Callouts.AttName_starts);
     2316                print_register<BitBlock>("check_streams.tag_marks",check_streams.tag_marks);
    13162317                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
     2318                print_register<BitBlock>("check_streams.name_follows",check_streams.name_follows);
    13172319                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
     2320                print_register<BitBlock>("check_streams.att_refs",check_streams.att_refs);
    13182321        }
    13192322       
     
    13252328                }
    13262329                check_streams.tag_marks = simd_or(simd_or(simd_or(tag_Callouts.EmptyTag_marks,tag_Callouts.ElemName_starts),tag_Callouts.EndTag_marks),tag_Callouts.AttName_starts);
     2330                print_register<BitBlock>("check_streams.tag_marks",check_streams.tag_marks);
    13272331                check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
     2332                print_register<BitBlock>("check_streams.name_follows",check_streams.name_follows);
    13282333                check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
     2334                print_register<BitBlock>("check_streams.att_refs",check_streams.att_refs);
    13292335        }
    13302336       
  • proto/pabloj/trunk/runConfigurations/compilePabloS.launch

    r3230 r3325  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="application.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-s ${project_loc:pabloj}/input/test/pabloS/test.pablos"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-s ${project_loc:pabloj}/input/test/pabloS/test.pablos -d"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pabloj/trunk/src/test/pabloS/PabloSTestHarness.java

    r3262 r3325  
    4545            COMBINE_ADVANCES(CombineAdvances.class, "CombineAdvances"),
    4646            CONVERT_BITWISE_BOOLEAN_TO_IDISA_CALLS(ConvertBitwiseBooleanToIDISACalls.class, "ConvertBitwiseBooleanToIDISACalls"),
    47             EXPAND_AUGMENTED_ASSIGNMENTS(ExpandAugmentedAssignments.class, "ExpandAugmentedAssignments"),           
    48             CARRY_INTRO_XFORMER_FINAL_BLOCK(CarryIntroXFormer.class, "CarryIntroXFormerFinalBlock"),
    49             CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK(CarryIntroXFormer.class,"CarryIntroXFormerNotFinalBlock");
     47            EXPAND_AUGMENTED_ASSIGNMENTS(ExpandAugmentedAssignments.class, "ExpandAugmentedAssignments");           
     48            //CARRY_INTRO_XFORMER_FINAL_BLOCK(CarryIntroXFormer.class, "CarryIntroXFormerFinalBlock"),
     49            //CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK(CarryIntroXFormer.class,"CarryIntroXFormerNotFinalBlock");
    5050                   
    5151            private Class<?> clazz;
     
    8888                                        switch (this) {
    8989                                               
    90                                         case CARRY_INTRO_XFORMER_FINAL_BLOCK:
    91                                                 m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
    92                                                 m.invoke(null, syntaxTree, new PabloSBuiltins2CPP(), new CarrySetBuiltins2CPP(), true);
    93                                                 break;
    94                                         case CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK:
    95                                                 m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
    96                                                 m.invoke(null, syntaxTree
    97                                                                 ,new PabloSBuiltins2CPP()
    98                                                                 ,new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP(), false);
    99                                                 break;
     90//                                      case CARRY_INTRO_XFORMER_FINAL_BLOCK:
     91//                                              m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
     92//                                              m.invoke(null, syntaxTree, new PabloSBuiltins2CPP(), new CarrySetBuiltins2CPP(), true);
     93//                                              break;
     94//                                      case CARRY_INTRO_XFORMER_NOT_FINAL_BLOCK:
     95//                                              m = clazz.getDeclaredMethod(method, ASTNode.class, BuiltinEncoder.class, CarrySetEncoder.class, boolean.class);
     96//                                              m.invoke(null, syntaxTree
     97//                                                              ,new PabloSBuiltins2CPP()
     98//                                                              ,new toolchain.pabloS.lang.carrySet.CarrySetBuiltins2CPP(), false);
     99//                                              break;
    100100                                        default:
    101101                                                m = clazz.getDeclaredMethod(method, ASTNode.class);
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3258 r3325  
    209209    ////////////////////////////////////////////////////////////////////////////
    210210    public static String name(ASTNode node) {
     211       
     212        if(node instanceof FuncCallNode) {
     213            node = funcCallIdentifier((FuncCallNode)node);
     214        }
    211215        assert ((node instanceof IdentifierNode) || (node instanceof CompoundIdentifierNode));
    212216       
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3321 r3325  
    152152            }
    153153
     154            code.addLine("");
     155           
    154156            return code;
    155157        }
  • proto/pabloj/trunk/src/toolchain/pabloB/lang/idisa/IDISABitBlockBuiltins.java

    r3010 r3325  
    22 * IDISA BitBlock builtins.
    33 *
    4  * Add IDISA builtins as needed.
     4 * Added IDISA builtins as needed. This file will *not* live on. This is temporary code.
    55 *
    66 * @author Ken Herdy <ksherdy at sfu dot ca>
     
    1313        ANY("any", 1),
    1414        ALL("all", 1),
     15        SRLI("srli<127>",127),
    1516        POPCOUNT("popcount", 1);
    1617               
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/AddAssignmentPrints.java

    r3264 r3325  
    4545                // other methods
    4646                private void addPrintStatement(ASTNode node, ASTNode lhs) {
     47                   
     48                    if(lhs instanceof FuncCallNode) {
     49                        return;
     50                    }
     51                   
     52                    if(lhs instanceof IdentifierNode) {
     53                        if(lhs.getToken().getLexeme().contains("__")) {
     54                            return;
     55                        }
     56                    }
     57                   
    4758                    FuncCallNode printCall = makePrintCall(node, lhs.deepCopy());       // deepCopy
    4859                        Mutators.insertStatementAfter(node, printCall);                         
     
    5162                private FuncCallNode makePrintCall(ASTNode node, ASTNode argument) {
    5263                        String printBitblockCode = encoder.getCode(PabloBBuiltin.PRINT_BITBLOCK);
     64                       
    5365                        ASTNode label = Generators.makeStringConstantNode(node, Accessors.name(argument));
    54                         return Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, argument);
     66                       
     67                        FuncCallNode call = Generators.makeFuncCallNode(node.getToken(), printBitblockCode, label, argument);
     68                        return call;
    5569                }
    5670        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3312 r3325  
    122122        return false;
    123123    }       
     124
     125        public static ASTNode lhs(LocalVarDeclNode node) {
     126            return node.child(1);
     127        }       
    124128       
    125129        public static ASTNode rhs(LocalVarDeclNode node) {
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3303 r3325  
    4343            localVarDecl.appendChild(type);
    4444            localVarDecl.appendChild(lhs);
     45           
     46           
     47           
    4548            return localVarDecl;
    4649        }
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Mutators.java

    r3294 r3325  
    2626        parent.insertBeforeChild(node, newNode);
    2727    }
    28 
     28   
    2929}
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltin.java

    r3311 r3325  
    55
    66import toolchain.pabloS.lang.signatures.FunctionSignature;
    7 import static toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator.*;
    87import static toolchain.pabloS.lang.signatures.SignatureShorthand.*;
    98import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
     9import static toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator.*;
     10import static toolchain.pabloS.transformer.visitors.carry.CarryBuiltinTranslator.*;
    1011
    1112public enum PabloSBuiltin {
     
    1819    EXCLUSIVE_SPAN(        "ExclusiveSpan",       CarryType.One, CARRY_TRANSLATION,  sig_SS_S() ),
    1920    ADVANCE_THEN_SCAN_THRU("AdvanceThenScanThru", CarryType.One, CARRY_TRANSLATION,  sig_SS_S()  ),
    20     ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION, sig_SS_S()  ), // BuiltinTranslator
    21    
     21    ADVANCE_THEN_SCAN_TO(  "AdvanceThenScanTo",   CarryType.One, ADVANCE_THEN_SCANTO_TRANSLATION,  sig_SS_S()  ), // BuiltinTranslator
    2222    ADVANCE_N(    "AdvanceN",  CarryType.N,    ADVANCEN_TRANSLATION, sig_SI_S() ), // AdvNCounterVisitor   
    23     ADVANCE_32(   "Advance32", CarryType.N,    CARRY_TRANSLATION,    sig_S_S()  ),
    2423
    2524    MASK(         "Mask",      CarryType.None, MASK_TRANSLATION,     sig_II_S() ), // visitors.carry.Counter   
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2C.java

    r3211 r3325  
    1212        pabloS2CCode = new HashMap<PabloSBuiltin, String>();
    1313       
    14         pabloS2CCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
    15         pabloS2CCode.put(PabloSBuiltin.SCAN_TO_FIRST, "BitBlock_scantofirst");
    16         pabloS2CCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
    17         pabloS2CCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
    18         pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, "BitBlock_advance_then_scanthru");
    19         pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, "BitBlock_advance_then_scanto");
    20         pabloS2CCode.put(PabloSBuiltin.SPAN_UP_TO, "BitBlock_span_upto");
    21         pabloS2CCode.put(PabloSBuiltin.INCLUSIVE_SPAN, "BitBlock_inclusive_span");
    22         pabloS2CCode.put(PabloSBuiltin.EXCLUSIVE_SPAN, "BitBlock_exclusive_span");   
    23 
    24         pabloS2CCode.put(PabloSBuiltin.ADVANCE_32, "BitBlock_advance_n_<%s>");
    25         pabloS2CCode.put(PabloSBuiltin.ADVANCE_N, "BitBlock_advance_n_<%s>");
    26 
    27         pabloS2CCode.put(PabloSBuiltin.MASK, "Mask");
    28         pabloS2CCode.put(PabloSBuiltin.AT_EOF, "atEOF");
    29         pabloS2CCode.put(PabloSBuiltin.IN_FILE, "inFile");
    30         pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error"); 
    31         pabloS2CCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    32         pabloS2CCode.put(PabloSBuiltin.NULL_BUILTIN, "null_builtin_error");
     14        pabloS2CCode.put(PabloSBuiltin.ADVANCE,                 "pablo_blk_Advance");
     15        pabloS2CCode.put(PabloSBuiltin.SCAN_TO_FIRST,           "pablo_blk_ScanToFirst");
     16        pabloS2CCode.put(PabloSBuiltin.SCAN_THRU,               "pablo_blk_ScanThru");
     17        pabloS2CCode.put(PabloSBuiltin.SCAN_TO,                 "pablo_blk_ScanTo");
     18        pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU,  "pablo_blk_AdvanceThenScanThru");
     19        pabloS2CCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO,    "pablo_blk_AdvanceThenScanTo");
     20        pabloS2CCode.put(PabloSBuiltin.SPAN_UP_TO,              "pablo_blk_SpanUpTo");
     21        pabloS2CCode.put(PabloSBuiltin.INCLUSIVE_SPAN,          "pablo_blk_InclusiveSpan");
     22        pabloS2CCode.put(PabloSBuiltin.EXCLUSIVE_SPAN,          "pablo_blk_ExclusiveSpan");   
     23        pabloS2CCode.put(PabloSBuiltin.ADVANCE_N,               "pablo_blk_Advance_n_<%s>");
     24        pabloS2CCode.put(PabloSBuiltin.MASK,                    "Mask");
     25        pabloS2CCode.put(PabloSBuiltin.AT_EOF,                  "atEOF");
     26        pabloS2CCode.put(PabloSBuiltin.IN_FILE,                 "inFile");
     27        pabloS2CCode.put(PabloSBuiltin.ASSERT_ZERO,             "assert_0_error");     
     28        pabloS2CCode.put(PabloSBuiltin.EOF_MASK,                "EOF_mask");
     29        pabloS2CCode.put(PabloSBuiltin.NULL_BUILTIN,            "null_builtin_error");
    3330
    3431        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/lang/PabloSBuiltins2CPP.java

    r3211 r3325  
    2323        pabloS2CPPCode = new HashMap<PabloSBuiltin, String>();
    2424       
    25         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE,"BitBlock_advance_ci_co");
    26         pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO_FIRST, "BitBlock_scantofirst");
    27         pabloS2CPPCode.put(PabloSBuiltin.SCAN_THRU, "BitBlock_scanthru_ci_co");
    28         pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO, "BitBlock_scanto_ci_co");
    29         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, "BitBlock_advance_then_scanthru");
    30         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO, "BitBlock_advance_then_scanto");
    31         pabloS2CPPCode.put(PabloSBuiltin.SPAN_UP_TO, "BitBlock_span_upto");
    32         pabloS2CPPCode.put(PabloSBuiltin.INCLUSIVE_SPAN, "BitBlock_inclusive_span");
    33         pabloS2CPPCode.put(PabloSBuiltin.EXCLUSIVE_SPAN, "BitBlock_exclusive_span");   
    34 
    35         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_32, "BitBlock_advance_n_<%s>");
    36         pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_N, "BitBlock_advance_n_<%s>");
    37 
    38         pabloS2CPPCode.put(PabloSBuiltin.MASK, "Mask");
    39         pabloS2CPPCode.put(PabloSBuiltin.AT_EOF, "atEOF");
    40         pabloS2CPPCode.put(PabloSBuiltin.IN_FILE, "inFile");
    41         pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO, "assert_0_error");       
    42         pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK, "EOF_mask");
    43         pabloS2CPPCode.put(PabloSBuiltin.NULL_BUILTIN, "null_builtin_error");
    44        
     25        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE,                   "pablo_blk_Advance");
     26        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO_FIRST,             "pablo_blk_ScanToFirst");
     27        pabloS2CPPCode.put(PabloSBuiltin.SCAN_THRU,                 "pablo_blk_ScanThru");
     28        pabloS2CPPCode.put(PabloSBuiltin.SCAN_TO,                   "pablo_blk_ScanTo");
     29        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU,    "pablo_blk_AdvanceThenScanThru");
     30        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_THEN_SCAN_TO,      "pablo_blk_AdvanceThenScanTo");
     31        pabloS2CPPCode.put(PabloSBuiltin.SPAN_UP_TO,                "pablo_blk_SpanUpTo");
     32        pabloS2CPPCode.put(PabloSBuiltin.INCLUSIVE_SPAN,            "pablo_blk_InclusiveSpan");
     33        pabloS2CPPCode.put(PabloSBuiltin.EXCLUSIVE_SPAN,            "pablo_blk_ExclusiveSpan");   
     34        pabloS2CPPCode.put(PabloSBuiltin.ADVANCE_N,                 "pablo_blk_Advance_n_<%s>");
     35        pabloS2CPPCode.put(PabloSBuiltin.MASK,                      "Mask");
     36        pabloS2CPPCode.put(PabloSBuiltin.AT_EOF,                    "atEOF");
     37        pabloS2CPPCode.put(PabloSBuiltin.IN_FILE,                   "inFile");
     38        pabloS2CPPCode.put(PabloSBuiltin.ASSERT_ZERO,               "assert_0_error"); 
     39        pabloS2CPPCode.put(PabloSBuiltin.EOF_MASK,                  "EOF_mask");
     40        pabloS2CPPCode.put(PabloSBuiltin.NULL_BUILTIN,              "null_builtin_error");
    4541               
    4642        for(PabloSBuiltin builtin : PabloSBuiltin.values()) {
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3309 r3325  
    1111import toolchain.pabloS.lang.carrySet.CarrySetBuiltins;
    1212import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    13 import toolchain.pabloS.transformer.visitors.carry.BuiltinTranslator;
     13import toolchain.pabloS.transformer.visitors.carry.CarryNoneBuiltinTranslator;
    1414
    1515/*
     
    147147        ///////////////////////////////////////////////////////////////////
    148148        // AssignNode
    149                 public void visitLeave(AssignNode node) { // TODO: KS: Factor out duplicate AssignNode/LocalVarDeclNode
     149                public void visitLeave(AssignNode node) {
    150150
    151151                    ASTNode rhs = Accessors.rhs(node);
    152152                    if(BuiltinCallUtil.isCarry(rhs)) {
    153                         FuncCallNode funcCall = (FuncCallNode)rhs;
    154                         PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    155                         Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    156                         BuiltinTranslator translator = builtin.getTranslator();
    157                         translator.translate(builtin, funcCall, counter, context);
     153                        IdentifierNode lhs = (IdentifierNode) Accessors.lhs(node);
     154                       
     155                FuncCallNode funcCall = (FuncCallNode) rhs;
     156               
     157                PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
     158                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
     159                CarryBuiltinTranslator translator = (CarryBuiltinTranslator) builtin.getTranslator();
     160                IdentifierNode returnValue = lhs;
     161                translator.translate(builtin, funcCall, counter, context, returnValue);
     162               
     163                node.replaceChild(lhs, counter.makeGetCarryCall(node,context));
     164                counter.increment();
    158165                    }
    159166                }
     
    166173                ASTNode rhs = Accessors.rhs(node);
    167174                if(BuiltinCallUtil.isCarry(rhs)) {
    168                     FuncCallNode funcCall = (FuncCallNode)rhs;
     175                    IdentifierNode lhs = (IdentifierNode) Accessors.lhs(node);
     176                   
     177                    FuncCallNode funcCall = (FuncCallNode) rhs;
     178                   
    169179                    PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    170180                    Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    171                     BuiltinTranslator translator = builtin.getTranslator();
    172                     translator.translate(builtin, funcCall, counter, context);
     181                    CarryBuiltinTranslator translator = (CarryBuiltinTranslator) builtin.getTranslator();
     182                    IdentifierNode returnValue = lhs;
     183                    translator.translate(builtin, funcCall, counter, context, returnValue);
     184                   
     185                    node.replaceChild(lhs, counter.makeGetCarryCall(node,context));
     186                    counter.increment();
    173187                }
    174188            }
     
    182196                                PabloSBuiltin builtin = BuiltinCallUtil.builtin(node);
    183197                                Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    184                                 BuiltinTranslator translator = builtin.getTranslator();
     198                                CarryNoneBuiltinTranslator translator = (CarryNoneBuiltinTranslator) builtin.getTranslator();
    185199                                translator.translate(builtin, node, counter, context);
    186200                        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryNoneBuiltinTranslator.java

    r3315 r3325  
    11package toolchain.pabloS.transformer.visitors.carry;
    22
    3 import java.util.ArrayList;
    4 import java.util.List;
    5 
    63import pabloS.ast.ASTNode;
    7 import pabloS.ast.AssignNode;
    84import pabloS.ast.FuncCallNode;
    9 import pabloS.ast.IntegerConstantNode;
    105import toolchain.pabloS.ast.Accessors;
    116import toolchain.pabloS.ast.Generators;
    127import toolchain.pabloS.lang.PabloSBuiltin;
    13 import toolchain.pabloS.lang.BuiltinCallUtil;
    148
    159// BuiltinTranslators translate a builtin call from pabloS to pabloB during the
     
    1913// having to instantiate the commands.
    2014
    21 public enum BuiltinTranslator {
    22         CARRY_TRANSLATION {     
    23                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    24                         List<ASTNode> arguments = Accessors.argsList(node);
    25 
    26                         replaceCallWithCarryCall(node,
    27                                         context.getCarrySetIdentifier(),
    28                                         context.getCode(translatedBuiltin),
    29                                         arguments,
    30                                         counter.callOrMask(node, context),
    31                                         counter.valueNode(node));
    32 
    33                         counter.increment();
    34                 }
    35         },
    36 
    37         ADVANCEN_TRANSLATION {
    38                 public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    39                         ASTNode formatValue = Accessors.argument(node, 1);
    40                         String value = Accessors.lexeme(formatValue);
    41 
    42                         List<ASTNode> arguments = Accessors.argsList(node);
    43 
    44                         String templateCode = context.getCode(builtin);
    45                         String formattedAdvanceN = String.format(templateCode, value);
    46 
    47                         replaceCallWithCarryCall(node,
    48                                         context.getCarrySetIdentifier(),
    49                                         formattedAdvanceN,
    50                                         arguments.subList(0, arguments.size()-1),
    51                                         counter.callOrMask(node, context),
    52                                         counter.valueNode(node));
    53                         counter.increment();   
    54                 }
    55         },
     15public enum CarryNoneBuiltinTranslator implements BuiltinTranslator {
    5616
    5717        ATEOF_TRANSLATION {
     
    6323                        }
    6424                        else {                         
    65                                 node.updateSelf(Counter.mask(node));                   
     25                                node.updateSelf(counter.mask(node));                   
    6626                        }
    6727                }
     
    8242        MASK_TRANSLATION {
    8343                public void translate(PabloSBuiltin builtin, FuncCallNode node, Counter counter, Context context) {
    84                         node.updateSelf(Counter.mask(node));
    85                 }
    86         },
    87 
    88         SCANTO_TRANSLATION {
    89                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    90                         scanToTranslate(PabloSBuiltin.SCAN_THRU, node, counter, context);
    91                 }
    92         },
    93 
    94         ADVANCE_THEN_SCANTO_TRANSLATION {
    95                 public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    96                         scanToTranslate(PabloSBuiltin.ADVANCE_THEN_SCAN_THRU, node, counter, context);
     44                        node.updateSelf(counter.mask(node));
    9745                }
    9846        };
    9947
    10048        abstract public void translate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context);
    101 
    102         // helper methods
    103         private static void scanToTranslate(PabloSBuiltin translatedBuiltin, FuncCallNode node, Counter counter, Context context) {
    104                 ASTNode argument = Accessors.argument(node, 1);
    105                 translateArgument(context, argument);
    106                 ASTNode replacement = Generators.makeCompoundIdentifierNode(node,
    107                                 BuiltinCallUtil.BUILTIN_PACKAGE_NAME, translatedBuiltin.pabloSName());
    108 
    109                 node.replaceChild(Accessors.nameNode(node), replacement);
    110                 CARRY_TRANSLATION.translate(translatedBuiltin, node, counter, context);
    111         }       
    112         private static void translateArgument(Context context, ASTNode argument) {
    113                 if(context.isFinalBlockMode()) {
    114                         ASTNode replacement = Generators.makeSIMDEOFMaskAndCNodeFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    115                         argument.updateSelf(replacement);
    116                 }
    117                 else {
    118                         ASTNode replacement = Generators.makeSIMDNotFuncCall(argument.deepCopy(), context.getBuiltinEncoder());
    119                         argument.updateSelf(replacement);                       
    120                 }
    121         }       
    122 
    123 
    124         // Makes CarrySet builtin call.
    125         // e.g. pablo.Advance(X,Y,Z) => carry_set_n.Advance(X,Y,Z,foo,carryInt)
    126 
    127         private static void replaceCallWithCarryCall(FuncCallNode node,
    128                         String carryPackageName, String carryBuiltin,
    129                         List<ASTNode> arguments,
    130                         ASTNode call, IntegerConstantNode carry) {
    131 
    132                 ASTNode [] args = makeCarryCallArgs(arguments, call, carry);
    133 
    134                 FuncCallNode replacementNode = Generators.makeFuncCallNode(
    135                                 node,
    136                                 carryPackageName,
    137                                 carryBuiltin,
    138                                 args);
    139 
    140                 node.updateSelf(replacementNode);
    141         }
    142 
    143 //    // Makes CarrySet builtin call.
    144 //    // e.g. pablo.Advance(X,Y,Z) => Co = pablo_blk(X,Y,Z,Ci,R)  // carry_set_n.Advance(X,Y,Z,foo,carryInt)
    145 //
    146 //    private static void replaceTempAssignWithPabloBlkAssign (
    147 //            AssignNode node,
    148 //            String carryPackageName,                        //  carryPackageName ==> carryPackageName
    149 //            String carryBuiltin,                            //  needed ==> translated to pablo_blk name
    150 //            List<ASTNode> arguments,                        //  needed
    151 //            ASTNode call,                                   //
    152 //            IntegerConstantNode carry)
    153 //        {
    154 //
    155 //        ASTNode [] args = makeCarryCallArgs(arguments, call, carry); // replace for pablo_blk_ and add carryPackageName.getCarry call, also the RV
    156 //
    157 //        FuncCallNode replacementNode = Generators.makeFuncCallNode(
    158 //                node,
    159 //                carryBuiltin,
    160 //                args);
    161 //
    162 //        node.updateSelf(replacementNode);
    163 //    }
    164        
    165         private static ASTNode [] makeCarryCallArgs(List<ASTNode> arguments,
    166                         ASTNode call, IntegerConstantNode carry) {
    167                 List<ASTNode> args = new ArrayList<ASTNode>(arguments);
    168                 args.add(call);
    169                 args.add(carry);
    170                 return args.toArray(new ASTNode [args.size()]);
    171         }               
     49               
    17250}
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/Counter.java

    r3324 r3325  
    3434        public ASTNode callOrMask(Locator locator, Context context) {
    3535                if(context.isCarryInMode()) {
    36                         return call(locator, context);
     36                        return makeGetCarryCall(locator, context);
    3737                }
    3838                else {
     
    4040                }
    4141        }
    42         public ASTNode call(Locator locator, Context context) {
     42        public ASTNode makeGetCarryCall(Locator locator, Context context) {
    4343            return Generators.makeFuncCallNode(
    4444                locator,
     
    4848        }
    4949        public ASTNode mask(Locator locator) {
    50                 IntegerConstantNode zeroConstantNode =  Generators.makeIntegerConstantNode(locator, 0);
    51                 IntegerConstantNode fieldWidthNode =  Generators.makeIntegerConstantNode(locator, 1);
    52                
    53                 return Generators.makeFuncCallNode(locator, BuiltinCallUtil.BUILTIN_PACKAGE_NAME,
    54                                 PabloSBuiltin.MASK.pabloSName(),
    55                                 fieldWidthNode, zeroConstantNode);
     50                return Generators.makeMaskFuncCall(locator, 1, 0);
    5651        }
    5752}
Note: See TracChangeset for help on using the changeset viewer.