Changeset 3330 for proto/pabloj


Ignore:
Timestamp:
Jun 18, 2013, 3:06:50 PM (6 years ago)
Author:
ksherdy
Message:

Added transformer to split local variable decl/inits.

Location:
proto/pabloj/trunk
Files:
3 added
2 deleted
25 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/trunk/output/cpplang/idisa_definitions.hpp

    r3325 r3330  
    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
     
    6363        {
    6464        }
    65          
     65       
    6666        IDISA_INLINE void do_block()
    6767        {
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r3325 r3330  
    194194        IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
    195195        {
    196                 BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     196                BitBlock temp1;
     197                temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
    197198                print_register<BitBlock>("temp1",temp1);
    198                 BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     199                BitBlock temp2;
     200                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
    199201                print_register<BitBlock>("temp2",temp2);
    200                 BitBlock temp3 = simd_andc(temp2,temp1);
     202                BitBlock temp3;
     203                temp3 = simd_andc(temp2,temp1);
    201204                print_register<BitBlock>("temp3",temp3);
    202                 BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     205                BitBlock temp4;
     206                temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
    203207                print_register<BitBlock>("temp4",temp4);
    204                 BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     208                BitBlock temp5;
     209                temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
    205210                print_register<BitBlock>("temp5",temp5);
    206                 BitBlock temp6 = simd_and(temp4,temp5);
     211                BitBlock temp6;
     212                temp6 = simd_and(temp4,temp5);
    207213                print_register<BitBlock>("temp6",temp6);
    208214                lex.RefStart = simd_and(temp3,temp6);
    209215                print_register<BitBlock>("lex.RefStart",lex.RefStart);
    210                 BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     216                BitBlock temp7;
     217                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
    211218                print_register<BitBlock>("temp7",temp7);
    212                 BitBlock temp8 = simd_andc(temp7,temp1);
     219                BitBlock temp8;
     220                temp8 = simd_andc(temp7,temp1);
    213221                print_register<BitBlock>("temp8",temp8);
    214                 BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     222                BitBlock temp9;
     223                temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
    215224                print_register<BitBlock>("temp9",temp9);
    216                 BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     225                BitBlock temp10;
     226                temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
    217227                print_register<BitBlock>("temp10",temp10);
    218                 BitBlock temp11 = simd_and(temp9,temp10);
     228                BitBlock temp11;
     229                temp11 = simd_and(temp9,temp10);
    219230                print_register<BitBlock>("temp11",temp11);
    220231                lex.Semicolon = simd_and(temp8,temp11);
    221232                print_register<BitBlock>("lex.Semicolon",lex.Semicolon);
    222                 BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     233                BitBlock temp12;
     234                temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
    223235                print_register<BitBlock>("temp12",temp12);
    224                 BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     236                BitBlock temp13;
     237                temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
    225238                print_register<BitBlock>("temp13",temp13);
    226                 BitBlock temp14 = simd_andc(temp12,temp13);
     239                BitBlock temp14;
     240                temp14 = simd_andc(temp12,temp13);
    227241                print_register<BitBlock>("temp14",temp14);
    228242                lex.LAngle = simd_and(temp8,temp14);
    229243                print_register<BitBlock>("lex.LAngle",lex.LAngle);
    230                 BitBlock temp15 = simd_and(temp12,temp5);
     244                BitBlock temp15;
     245                temp15 = simd_and(temp12,temp5);
    231246                print_register<BitBlock>("temp15",temp15);
    232247                lex.RAngle = simd_and(temp8,temp15);
    233248                print_register<BitBlock>("lex.RAngle",lex.RAngle);
    234                 BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     249                BitBlock temp16;
     250                temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
    235251                print_register<BitBlock>("temp16",temp16);
    236                 BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     252                BitBlock temp17;
     253                temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
    237254                print_register<BitBlock>("temp17",temp17);
    238                 BitBlock temp18 = simd_and(temp16,temp17);
     255                BitBlock temp18;
     256                temp18 = simd_and(temp16,temp17);
    239257                print_register<BitBlock>("temp18",temp18);
    240258                lex.LBracket = simd_and(temp18,temp11);
    241259                print_register<BitBlock>("lex.LBracket",lex.LBracket);
    242                 BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     260                BitBlock temp19;
     261                temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
    243262                print_register<BitBlock>("temp19",temp19);
    244                 BitBlock temp20 = simd_and(temp12,temp19);
     263                BitBlock temp20;
     264                temp20 = simd_and(temp12,temp19);
    245265                print_register<BitBlock>("temp20",temp20);
    246266                lex.RBracket = simd_and(temp18,temp20);
    247267                print_register<BitBlock>("lex.RBracket",lex.RBracket);
    248                 BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     268                BitBlock temp21;
     269                temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
    249270                print_register<BitBlock>("temp21",temp21);
    250                 BitBlock temp22 = simd_andc(temp19,temp21);
     271                BitBlock temp22;
     272                temp22 = simd_andc(temp19,temp21);
    251273                print_register<BitBlock>("temp22",temp22);
    252274                lex.Exclam = simd_and(temp3,temp22);
    253275                print_register<BitBlock>("lex.Exclam",lex.Exclam);
    254                 BitBlock temp23 = simd_and(temp12,temp10);
     276                BitBlock temp23;
     277                temp23 = simd_and(temp12,temp10);
    255278                print_register<BitBlock>("temp23",temp23);
    256279                lex.QMark = simd_and(temp8,temp23);
     
    260283                lex.Equals = simd_and(temp8,temp20);
    261284                print_register<BitBlock>("lex.Equals",lex.Equals);
    262                 BitBlock temp24 = simd_and(temp4,temp10);
     285                BitBlock temp24;
     286                temp24 = simd_and(temp4,temp10);
    263287                print_register<BitBlock>("temp24",temp24);
    264288                lex.SQuote = simd_and(temp3,temp24);
    265289                print_register<BitBlock>("lex.SQuote",lex.SQuote);
    266                 BitBlock temp25 = simd_andc(temp5,temp21);
     290                BitBlock temp25;
     291                temp25 = simd_andc(temp5,temp21);
    267292                print_register<BitBlock>("temp25",temp25);
    268293                lex.DQuote = simd_and(temp3,temp25);
     
    270295                lex.Slash = simd_and(temp3,temp23);
    271296                print_register<BitBlock>("lex.Slash",lex.Slash);
    272                 BitBlock temp26 = simd_andc(temp10,temp21);
     297                BitBlock temp26;
     298                temp26 = simd_andc(temp10,temp21);
    273299                print_register<BitBlock>("temp26",temp26);
    274300                lex.Hash = simd_and(temp3,temp26);
    275301                print_register<BitBlock>("lex.Hash",lex.Hash);
    276                 BitBlock temp27 = simd_and(temp16,temp7);
     302                BitBlock temp27;
     303                temp27 = simd_and(temp16,temp7);
    277304                print_register<BitBlock>("temp27",temp27);
    278                 BitBlock temp28 = simd_andc(temp9,temp13);
     305                BitBlock temp28;
     306                temp28 = simd_andc(temp9,temp13);
    279307                print_register<BitBlock>("temp28",temp28);
    280308                lex.x = simd_and(temp27,temp28);
    281309                print_register<BitBlock>("lex.x",lex.x);
    282                 BitBlock temp29 = simd_and(temp9,temp5);
     310                BitBlock temp29;
     311                temp29 = simd_and(temp9,temp5);
    283312                print_register<BitBlock>("temp29",temp29);
    284313                lex.Colon = simd_and(temp8,temp29);
    285314                print_register<BitBlock>("lex.Colon",lex.Colon);
    286                 BitBlock temp30 = simd_and(temp18,temp23);
     315                BitBlock temp30;
     316                temp30 = simd_and(temp18,temp23);
    287317                print_register<BitBlock>("temp30",temp30);
    288                 BitBlock temp31 = simd_or(temp30,lex.Colon);
     318                BitBlock temp31;
     319                temp31 = simd_or(temp30,lex.Colon);
    289320                print_register<BitBlock>("temp31",temp31);
    290                 BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     321                BitBlock temp32;
     322                temp32 = simd_andc(temp16,basis_bits.bit_2);
    291323                print_register<BitBlock>("temp32",temp32);
    292                 BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     324                BitBlock temp33;
     325                temp33 = simd_or(basis_bits.bit_5,temp10);
    293326                print_register<BitBlock>("temp33",temp33);
    294                 BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     327                BitBlock temp34;
     328                temp34 = simd_and(basis_bits.bit_4,temp33);
    295329                print_register<BitBlock>("temp34",temp34);
    296                 BitBlock temp35 = simd_not(temp34);
     330                BitBlock temp35;
     331                temp35 = simd_not(temp34);
    297332                print_register<BitBlock>("temp35",temp35);
    298                 BitBlock temp36 = simd_or(temp21,temp13);
     333                BitBlock temp36;
     334                temp36 = simd_or(temp21,temp13);
    299335                print_register<BitBlock>("temp36",temp36);
    300                 BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     336                BitBlock temp37;
     337                temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
    301338                print_register<BitBlock>("temp37",temp37);
    302                 BitBlock temp38 = simd_and(temp32,temp37);
     339                BitBlock temp38;
     340                temp38 = simd_and(temp32,temp37);
    303341                print_register<BitBlock>("temp38",temp38);
    304                 BitBlock temp39 = simd_or(temp31,temp38);
     342                BitBlock temp39;
     343                temp39 = simd_or(temp31,temp38);
    305344                print_register<BitBlock>("temp39",temp39);
    306                 BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     345                BitBlock temp40;
     346                temp40 = simd_and(temp16,basis_bits.bit_2);
    307347                print_register<BitBlock>("temp40",temp40);
    308                 BitBlock temp41 = simd_and(temp40,temp37);
     348                BitBlock temp41;
     349                temp41 = simd_and(temp40,temp37);
    309350                print_register<BitBlock>("temp41",temp41);
    310351                lex.ASCII_name_start = simd_or(temp39,temp41);
    311352                print_register<BitBlock>("lex.ASCII_name_start",lex.ASCII_name_start);
    312                 BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     353                BitBlock temp42;
     354                temp42 = simd_or(temp30,lex.Hyphen);
    313355                print_register<BitBlock>("temp42",temp42);
    314                 BitBlock temp43 = simd_and(temp3,temp15);
     356                BitBlock temp43;
     357                temp43 = simd_and(temp3,temp15);
    315358                print_register<BitBlock>("temp43",temp43);
    316                 BitBlock temp44 = simd_or(temp42,temp43);
     359                BitBlock temp44;
     360                temp44 = simd_or(temp42,temp43);
    317361                print_register<BitBlock>("temp44",temp44);
    318                 BitBlock temp45 = simd_andc(temp8,temp34);
     362                BitBlock temp45;
     363                temp45 = simd_andc(temp8,temp34);
    319364                print_register<BitBlock>("temp45",temp45);
    320                 BitBlock temp46 = simd_or(temp44,temp45);
     365                BitBlock temp46;
     366                temp46 = simd_or(temp44,temp45);
    321367                print_register<BitBlock>("temp46",temp46);
    322                 BitBlock temp47 = simd_or(temp46,temp38);
     368                BitBlock temp47;
     369                temp47 = simd_or(temp46,temp38);
    323370                print_register<BitBlock>("temp47",temp47);
    324371                lex.ASCII_name_char = simd_or(temp47,temp41);
     
    326373                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
    327374                print_register<BitBlock>("lex.NameScan",lex.NameScan);
    328                 BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     375                BitBlock temp48;
     376                temp48 = simd_or(temp1,basis_bits.bit_2);
    329377                print_register<BitBlock>("temp48",temp48);
    330                 BitBlock x00_x1F = simd_not(temp48);
     378                BitBlock x00_x1F;
     379                x00_x1F = simd_not(temp48);
    331380                print_register<BitBlock>("x00_x1F",x00_x1F);
    332                 BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     381                BitBlock temp49;
     382                temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
    333383                print_register<BitBlock>("temp49",temp49);
    334                 BitBlock temp50 = simd_or(temp1,temp49);
     384                BitBlock temp50;
     385                temp50 = simd_or(temp1,temp49);
    335386                print_register<BitBlock>("temp50",temp50);
    336387                lex.CR = simd_andc(temp20,temp50);
     
    338389                lex.LF = simd_andc(temp29,temp50);
    339390                print_register<BitBlock>("lex.LF",lex.LF);
    340                 BitBlock temp51 = simd_and(temp9,temp19);
     391                BitBlock temp51;
     392                temp51 = simd_and(temp9,temp19);
    341393                print_register<BitBlock>("temp51",temp51);
    342394                lex.HT = simd_andc(temp51,temp50);
     
    344396                lex.SP = simd_andc(temp3,temp36);
    345397                print_register<BitBlock>("lex.SP",lex.SP);
    346                 BitBlock temp52 = simd_or(temp20,temp29);
     398                BitBlock temp52;
     399                temp52 = simd_or(temp20,temp29);
    347400                print_register<BitBlock>("temp52",temp52);
    348                 BitBlock temp53 = simd_or(temp52,temp51);
     401                BitBlock temp53;
     402                temp53 = simd_or(temp52,temp51);
    349403                print_register<BitBlock>("temp53",temp53);
    350                 BitBlock temp54 = simd_andc(temp53,temp50);
     404                BitBlock temp54;
     405                temp54 = simd_andc(temp53,temp50);
    351406                print_register<BitBlock>("temp54",temp54);
    352407                lex.WS = simd_or(temp54,lex.SP);
    353408                print_register<BitBlock>("lex.WS",lex.WS);
    354                 BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     409                BitBlock temp55;
     410                temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
    355411                print_register<BitBlock>("temp55",temp55);
    356                 BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
     412                BitBlock temp56;
     413                temp56 = simd_and(basis_bits.bit_4,temp55);
    357414                print_register<BitBlock>("temp56",temp56);
    358415                lex.Digit = simd_andc(temp8,temp56);
    359416                print_register<BitBlock>("lex.Digit",lex.Digit);
    360                 BitBlock temp57 = simd_andc(temp16,temp49);
     417                BitBlock temp57;
     418                temp57 = simd_andc(temp16,temp49);
    361419                print_register<BitBlock>("temp57",temp57);
    362                 BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     420                BitBlock temp58;
     421                temp58 = simd_andc(temp57,basis_bits.bit_4);
    363422                print_register<BitBlock>("temp58",temp58);
    364                 BitBlock temp59 = simd_not(temp10);
     423                BitBlock temp59;
     424                temp59 = simd_not(temp10);
    365425                print_register<BitBlock>("temp59",temp59);
    366                 BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     426                BitBlock temp60;
     427                temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
    367428                print_register<BitBlock>("temp60",temp60);
    368                 BitBlock temp61 = simd_and(temp58,temp60);
     429                BitBlock temp61;
     430                temp61 = simd_and(temp58,temp60);
    369431                print_register<BitBlock>("temp61",temp61);
    370                 BitBlock temp62 = simd_or(lex.Digit,temp61);
     432                BitBlock temp62;
     433                temp62 = simd_or(lex.Digit,temp61);
    371434                print_register<BitBlock>("temp62",temp62);
    372                 BitBlock temp63 = simd_and(temp16,temp2);
     435                BitBlock temp63;
     436                temp63 = simd_and(temp16,temp2);
    373437                print_register<BitBlock>("temp63",temp63);
    374                 BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     438                BitBlock temp64;
     439                temp64 = simd_andc(temp63,basis_bits.bit_4);
    375440                print_register<BitBlock>("temp64",temp64);
    376                 BitBlock temp65 = simd_and(temp64,temp60);
     441                BitBlock temp65;
     442                temp65 = simd_and(temp64,temp60);
    377443                print_register<BitBlock>("temp65",temp65);
    378444                lex.Hex = simd_or(temp62,temp65);
    379445                print_register<BitBlock>("lex.Hex",lex.Hex);
    380                 BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
     446                BitBlock lex_error;
     447                lex_error = simd_andc(x00_x1F,lex.WS);
    381448                print_register<BitBlock>("lex_error",lex_error);
    382449                if (bitblock::any(lex_error))
     
    388455                u8.suffix = simd<1>::constant<0>();
    389456                print_register<BitBlock>("u8.suffix",u8.suffix);
    390                 BitBlock u8_error = simd<1>::constant<0>();
     457                BitBlock u8_error;
     458                u8_error = simd<1>::constant<0>();
    391459                print_register<BitBlock>("u8_error",u8_error);
    392                 BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     460                BitBlock u8_FFFE_FFFF;
     461                u8_FFFE_FFFF = simd<1>::constant<0>();
    393462                print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    394                 BitBlock u8anyscope = simd<1>::constant<0>();
     463                BitBlock u8anyscope;
     464                u8anyscope = simd<1>::constant<0>();
    395465                print_register<BitBlock>("u8anyscope",u8anyscope);
    396466                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
     
    406476                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
    407477                        print_register<BitBlock>("u8.suffix",u8.suffix);
    408                         BitBlock temp66 = simd_andc(u8.prefix,temp49);
     478                        BitBlock temp66;
     479                        temp66 = simd_andc(u8.prefix,temp49);
    409480                        print_register<BitBlock>("temp66",temp66);
    410                         BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     481                        BitBlock temp67;
     482                        temp67 = simd_or(temp21,basis_bits.bit_6);
    411483                        print_register<BitBlock>("temp67",temp67);
    412                         BitBlock temp68 = simd_andc(temp66,temp67);
     484                        BitBlock temp68;
     485                        temp68 = simd_andc(temp66,temp67);
    413486                        print_register<BitBlock>("temp68",temp68);
    414                         BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     487                        BitBlock temp69;
     488                        temp69 = simd_and(basis_bits.bit_5,temp13);
    415489                        print_register<BitBlock>("temp69",temp69);
    416                         BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     490                        BitBlock temp70;
     491                        temp70 = simd_or(basis_bits.bit_4,temp69);
    417492                        print_register<BitBlock>("temp70",temp70);
    418                         BitBlock temp71 = simd_and(u8.prefix4,temp70);
     493                        BitBlock temp71;
     494                        temp71 = simd_and(u8.prefix4,temp70);
    419495                        print_register<BitBlock>("temp71",temp71);
    420496                        u8.badprefix = simd_or(temp68,temp71);
     
    430506                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    431507                        {
    432                                 BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     508                                BitBlock xE0;
     509                                xE0 = simd_andc(u8.prefix3,temp36);
    433510                                print_register<BitBlock>("xE0",xE0);
    434                                 BitBlock xED = simd_and(u8.prefix3,temp20);
     511                                BitBlock xED;
     512                                xED = simd_and(u8.prefix3,temp20);
    435513                                print_register<BitBlock>("xED",xED);
    436                                 BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     514                                BitBlock xF0;
     515                                xF0 = simd_andc(u8.prefix4,temp36);
    437516                                print_register<BitBlock>("xF0",xF0);
    438                                 BitBlock temp72 = simd_andc(temp4,temp13);
     517                                BitBlock temp72;
     518                                temp72 = simd_andc(temp4,temp13);
    439519                                print_register<BitBlock>("temp72",temp72);
    440                                 BitBlock xF4 = simd_and(u8.prefix4,temp72);
     520                                BitBlock xF4;
     521                                xF4 = simd_and(u8.prefix4,temp72);
    441522                                print_register<BitBlock>("xF4",xF4);
    442523                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
     
    448529                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
    449530                                print_register<BitBlock>("u8.x80_x8F",u8.x80_x8F);
    450                                 BitBlock xEF = simd_and(u8.prefix3,temp23);
     531                                BitBlock xEF;
     532                                xEF = simd_and(u8.prefix3,temp23);
    451533                                print_register<BitBlock>("xEF",xEF);
    452                                 BitBlock temp73 = simd_and(u8.suffix,temp7);
     534                                BitBlock temp73;
     535                                temp73 = simd_and(u8.suffix,temp7);
    453536                                print_register<BitBlock>("temp73",temp73);
    454537                                u8.xBF = simd_and(temp73,temp23);
     
    478561                                BitBlock __temp__6;
    479562                                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;
     563                                BitBlock E0_F0_scope;
     564                                E0_F0_scope = __temp__6;
    481565                                print_register<BitBlock>("E0_F0_scope",E0_F0_scope);
    482566                                BitBlock __temp__7;
    483567                                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;
     568                                BitBlock ED_F4_scope;
     569                                ED_F4_scope = __temp__7;
    485570                                print_register<BitBlock>("ED_F4_scope",ED_F4_scope);
    486571                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
     
    496581                                u8.xEF_scope = __temp__8;
    497582                                print_register<BitBlock>("u8.xEF_scope",u8.xEF_scope);
    498                                 BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     583                                BitBlock u8lastscope;
     584                                u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    499585                                print_register<BitBlock>("u8lastscope",u8lastscope);
    500586                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
    501587                                print_register<BitBlock>("u8anyscope",u8anyscope);
    502                                 BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     588                                BitBlock u8error1;
     589                                u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
    503590                                print_register<BitBlock>("u8error1",u8error1);
    504                                 BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     591                                BitBlock u8error2;
     592                                u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
    505593                                print_register<BitBlock>("u8error2",u8error2);
    506                                 BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     594                                BitBlock u8error3;
     595                                u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
    507596                                print_register<BitBlock>("u8error3",u8error3);
    508                                 BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
     597                                BitBlock u8error4;
     598                                u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    509599                                print_register<BitBlock>("u8error4",u8error4);
    510600                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
     
    512602                                BitBlock __temp__9;
    513603                                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;
     604                                BitBlock EF_BF_pending;
     605                                EF_BF_pending = __temp__9;
    515606                                print_register<BitBlock>("EF_BF_pending",EF_BF_pending);
    516607                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
     
    521612                                carry_set_0.carryDequeueEnqueue(1,9);
    522613                        }
    523                         BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
     614                        BitBlock u8mismatch;
     615                        u8mismatch = simd_xor(u8anyscope,u8.suffix);
    524616                        print_register<BitBlock>("u8mismatch",u8mismatch);
    525617                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
     
    537629        void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
    538630        {
    539                 BitBlock temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
     631                BitBlock temp1;
     632                temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
    540633                print_register<BitBlock>("temp1",temp1);
    541                 BitBlock temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
     634                BitBlock temp2;
     635                temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
    542636                print_register<BitBlock>("temp2",temp2);
    543                 BitBlock temp3 = simd_andc(temp2,temp1);
     637                BitBlock temp3;
     638                temp3 = simd_andc(temp2,temp1);
    544639                print_register<BitBlock>("temp3",temp3);
    545                 BitBlock temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
     640                BitBlock temp4;
     641                temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
    546642                print_register<BitBlock>("temp4",temp4);
    547                 BitBlock temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
     643                BitBlock temp5;
     644                temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
    548645                print_register<BitBlock>("temp5",temp5);
    549                 BitBlock temp6 = simd_and(temp4,temp5);
     646                BitBlock temp6;
     647                temp6 = simd_and(temp4,temp5);
    550648                print_register<BitBlock>("temp6",temp6);
    551649                lex.RefStart = simd_and(temp3,temp6);
    552650                print_register<BitBlock>("lex.RefStart",lex.RefStart);
    553                 BitBlock temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
     651                BitBlock temp7;
     652                temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
    554653                print_register<BitBlock>("temp7",temp7);
    555                 BitBlock temp8 = simd_andc(temp7,temp1);
     654                BitBlock temp8;
     655                temp8 = simd_andc(temp7,temp1);
    556656                print_register<BitBlock>("temp8",temp8);
    557                 BitBlock temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
     657                BitBlock temp9;
     658                temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
    558659                print_register<BitBlock>("temp9",temp9);
    559                 BitBlock temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
     660                BitBlock temp10;
     661                temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
    560662                print_register<BitBlock>("temp10",temp10);
    561                 BitBlock temp11 = simd_and(temp9,temp10);
     663                BitBlock temp11;
     664                temp11 = simd_and(temp9,temp10);
    562665                print_register<BitBlock>("temp11",temp11);
    563666                lex.Semicolon = simd_and(temp8,temp11);
    564667                print_register<BitBlock>("lex.Semicolon",lex.Semicolon);
    565                 BitBlock temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
     668                BitBlock temp12;
     669                temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
    566670                print_register<BitBlock>("temp12",temp12);
    567                 BitBlock temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
     671                BitBlock temp13;
     672                temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
    568673                print_register<BitBlock>("temp13",temp13);
    569                 BitBlock temp14 = simd_andc(temp12,temp13);
     674                BitBlock temp14;
     675                temp14 = simd_andc(temp12,temp13);
    570676                print_register<BitBlock>("temp14",temp14);
    571677                lex.LAngle = simd_and(temp8,temp14);
    572678                print_register<BitBlock>("lex.LAngle",lex.LAngle);
    573                 BitBlock temp15 = simd_and(temp12,temp5);
     679                BitBlock temp15;
     680                temp15 = simd_and(temp12,temp5);
    574681                print_register<BitBlock>("temp15",temp15);
    575682                lex.RAngle = simd_and(temp8,temp15);
    576683                print_register<BitBlock>("lex.RAngle",lex.RAngle);
    577                 BitBlock temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
     684                BitBlock temp16;
     685                temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
    578686                print_register<BitBlock>("temp16",temp16);
    579                 BitBlock temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
     687                BitBlock temp17;
     688                temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
    580689                print_register<BitBlock>("temp17",temp17);
    581                 BitBlock temp18 = simd_and(temp16,temp17);
     690                BitBlock temp18;
     691                temp18 = simd_and(temp16,temp17);
    582692                print_register<BitBlock>("temp18",temp18);
    583693                lex.LBracket = simd_and(temp18,temp11);
    584694                print_register<BitBlock>("lex.LBracket",lex.LBracket);
    585                 BitBlock temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
     695                BitBlock temp19;
     696                temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
    586697                print_register<BitBlock>("temp19",temp19);
    587                 BitBlock temp20 = simd_and(temp12,temp19);
     698                BitBlock temp20;
     699                temp20 = simd_and(temp12,temp19);
    588700                print_register<BitBlock>("temp20",temp20);
    589701                lex.RBracket = simd_and(temp18,temp20);
    590702                print_register<BitBlock>("lex.RBracket",lex.RBracket);
    591                 BitBlock temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
     703                BitBlock temp21;
     704                temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
    592705                print_register<BitBlock>("temp21",temp21);
    593                 BitBlock temp22 = simd_andc(temp19,temp21);
     706                BitBlock temp22;
     707                temp22 = simd_andc(temp19,temp21);
    594708                print_register<BitBlock>("temp22",temp22);
    595709                lex.Exclam = simd_and(temp3,temp22);
    596710                print_register<BitBlock>("lex.Exclam",lex.Exclam);
    597                 BitBlock temp23 = simd_and(temp12,temp10);
     711                BitBlock temp23;
     712                temp23 = simd_and(temp12,temp10);
    598713                print_register<BitBlock>("temp23",temp23);
    599714                lex.QMark = simd_and(temp8,temp23);
     
    603718                lex.Equals = simd_and(temp8,temp20);
    604719                print_register<BitBlock>("lex.Equals",lex.Equals);
    605                 BitBlock temp24 = simd_and(temp4,temp10);
     720                BitBlock temp24;
     721                temp24 = simd_and(temp4,temp10);
    606722                print_register<BitBlock>("temp24",temp24);
    607723                lex.SQuote = simd_and(temp3,temp24);
    608724                print_register<BitBlock>("lex.SQuote",lex.SQuote);
    609                 BitBlock temp25 = simd_andc(temp5,temp21);
     725                BitBlock temp25;
     726                temp25 = simd_andc(temp5,temp21);
    610727                print_register<BitBlock>("temp25",temp25);
    611728                lex.DQuote = simd_and(temp3,temp25);
     
    613730                lex.Slash = simd_and(temp3,temp23);
    614731                print_register<BitBlock>("lex.Slash",lex.Slash);
    615                 BitBlock temp26 = simd_andc(temp10,temp21);
     732                BitBlock temp26;
     733                temp26 = simd_andc(temp10,temp21);
    616734                print_register<BitBlock>("temp26",temp26);
    617735                lex.Hash = simd_and(temp3,temp26);
    618736                print_register<BitBlock>("lex.Hash",lex.Hash);
    619                 BitBlock temp27 = simd_and(temp16,temp7);
     737                BitBlock temp27;
     738                temp27 = simd_and(temp16,temp7);
    620739                print_register<BitBlock>("temp27",temp27);
    621                 BitBlock temp28 = simd_andc(temp9,temp13);
     740                BitBlock temp28;
     741                temp28 = simd_andc(temp9,temp13);
    622742                print_register<BitBlock>("temp28",temp28);
    623743                lex.x = simd_and(temp27,temp28);
    624744                print_register<BitBlock>("lex.x",lex.x);
    625                 BitBlock temp29 = simd_and(temp9,temp5);
     745                BitBlock temp29;
     746                temp29 = simd_and(temp9,temp5);
    626747                print_register<BitBlock>("temp29",temp29);
    627748                lex.Colon = simd_and(temp8,temp29);
    628749                print_register<BitBlock>("lex.Colon",lex.Colon);
    629                 BitBlock temp30 = simd_and(temp18,temp23);
     750                BitBlock temp30;
     751                temp30 = simd_and(temp18,temp23);
    630752                print_register<BitBlock>("temp30",temp30);
    631                 BitBlock temp31 = simd_or(temp30,lex.Colon);
     753                BitBlock temp31;
     754                temp31 = simd_or(temp30,lex.Colon);
    632755                print_register<BitBlock>("temp31",temp31);
    633                 BitBlock temp32 = simd_andc(temp16,basis_bits.bit_2);
     756                BitBlock temp32;
     757                temp32 = simd_andc(temp16,basis_bits.bit_2);
    634758                print_register<BitBlock>("temp32",temp32);
    635                 BitBlock temp33 = simd_or(basis_bits.bit_5,temp10);
     759                BitBlock temp33;
     760                temp33 = simd_or(basis_bits.bit_5,temp10);
    636761                print_register<BitBlock>("temp33",temp33);
    637                 BitBlock temp34 = simd_and(basis_bits.bit_4,temp33);
     762                BitBlock temp34;
     763                temp34 = simd_and(basis_bits.bit_4,temp33);
    638764                print_register<BitBlock>("temp34",temp34);
    639                 BitBlock temp35 = simd_not(temp34);
     765                BitBlock temp35;
     766                temp35 = simd_not(temp34);
    640767                print_register<BitBlock>("temp35",temp35);
    641                 BitBlock temp36 = simd_or(temp21,temp13);
     768                BitBlock temp36;
     769                temp36 = simd_or(temp21,temp13);
    642770                print_register<BitBlock>("temp36",temp36);
    643                 BitBlock temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
     771                BitBlock temp37;
     772                temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
    644773                print_register<BitBlock>("temp37",temp37);
    645                 BitBlock temp38 = simd_and(temp32,temp37);
     774                BitBlock temp38;
     775                temp38 = simd_and(temp32,temp37);
    646776                print_register<BitBlock>("temp38",temp38);
    647                 BitBlock temp39 = simd_or(temp31,temp38);
     777                BitBlock temp39;
     778                temp39 = simd_or(temp31,temp38);
    648779                print_register<BitBlock>("temp39",temp39);
    649                 BitBlock temp40 = simd_and(temp16,basis_bits.bit_2);
     780                BitBlock temp40;
     781                temp40 = simd_and(temp16,basis_bits.bit_2);
    650782                print_register<BitBlock>("temp40",temp40);
    651                 BitBlock temp41 = simd_and(temp40,temp37);
     783                BitBlock temp41;
     784                temp41 = simd_and(temp40,temp37);
    652785                print_register<BitBlock>("temp41",temp41);
    653786                lex.ASCII_name_start = simd_or(temp39,temp41);
    654787                print_register<BitBlock>("lex.ASCII_name_start",lex.ASCII_name_start);
    655                 BitBlock temp42 = simd_or(temp30,lex.Hyphen);
     788                BitBlock temp42;
     789                temp42 = simd_or(temp30,lex.Hyphen);
    656790                print_register<BitBlock>("temp42",temp42);
    657                 BitBlock temp43 = simd_and(temp3,temp15);
     791                BitBlock temp43;
     792                temp43 = simd_and(temp3,temp15);
    658793                print_register<BitBlock>("temp43",temp43);
    659                 BitBlock temp44 = simd_or(temp42,temp43);
     794                BitBlock temp44;
     795                temp44 = simd_or(temp42,temp43);
    660796                print_register<BitBlock>("temp44",temp44);
    661                 BitBlock temp45 = simd_andc(temp8,temp34);
     797                BitBlock temp45;
     798                temp45 = simd_andc(temp8,temp34);
    662799                print_register<BitBlock>("temp45",temp45);
    663                 BitBlock temp46 = simd_or(temp44,temp45);
     800                BitBlock temp46;
     801                temp46 = simd_or(temp44,temp45);
    664802                print_register<BitBlock>("temp46",temp46);
    665                 BitBlock temp47 = simd_or(temp46,temp38);
     803                BitBlock temp47;
     804                temp47 = simd_or(temp46,temp38);
    666805                print_register<BitBlock>("temp47",temp47);
    667806                lex.ASCII_name_char = simd_or(temp47,temp41);
     
    669808                lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
    670809                print_register<BitBlock>("lex.NameScan",lex.NameScan);
    671                 BitBlock temp48 = simd_or(temp1,basis_bits.bit_2);
     810                BitBlock temp48;
     811                temp48 = simd_or(temp1,basis_bits.bit_2);
    672812                print_register<BitBlock>("temp48",temp48);
    673                 BitBlock x00_x1F = simd_not(temp48);
     813                BitBlock x00_x1F;
     814                x00_x1F = simd_not(temp48);
    674815                print_register<BitBlock>("x00_x1F",x00_x1F);
    675                 BitBlock temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
     816                BitBlock temp49;
     817                temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
    676818                print_register<BitBlock>("temp49",temp49);
    677                 BitBlock temp50 = simd_or(temp1,temp49);
     819                BitBlock temp50;
     820                temp50 = simd_or(temp1,temp49);
    678821                print_register<BitBlock>("temp50",temp50);
    679822                lex.CR = simd_andc(temp20,temp50);
     
    681824                lex.LF = simd_andc(temp29,temp50);
    682825                print_register<BitBlock>("lex.LF",lex.LF);
    683                 BitBlock temp51 = simd_and(temp9,temp19);
     826                BitBlock temp51;
     827                temp51 = simd_and(temp9,temp19);
    684828                print_register<BitBlock>("temp51",temp51);
    685829                lex.HT = simd_andc(temp51,temp50);
     
    687831                lex.SP = simd_andc(temp3,temp36);
    688832                print_register<BitBlock>("lex.SP",lex.SP);
    689                 BitBlock temp52 = simd_or(temp20,temp29);
     833                BitBlock temp52;
     834                temp52 = simd_or(temp20,temp29);
    690835                print_register<BitBlock>("temp52",temp52);
    691                 BitBlock temp53 = simd_or(temp52,temp51);
     836                BitBlock temp53;
     837                temp53 = simd_or(temp52,temp51);
    692838                print_register<BitBlock>("temp53",temp53);
    693                 BitBlock temp54 = simd_andc(temp53,temp50);
     839                BitBlock temp54;
     840                temp54 = simd_andc(temp53,temp50);
    694841                print_register<BitBlock>("temp54",temp54);
    695842                lex.WS = simd_or(temp54,lex.SP);
    696843                print_register<BitBlock>("lex.WS",lex.WS);
    697                 BitBlock temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
     844                BitBlock temp55;
     845                temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
    698846                print_register<BitBlock>("temp55",temp55);
    699                 BitBlock temp56 = simd_and(basis_bits.bit_4,temp55);
     847                BitBlock temp56;
     848                temp56 = simd_and(basis_bits.bit_4,temp55);
    700849                print_register<BitBlock>("temp56",temp56);
    701850                lex.Digit = simd_andc(temp8,temp56);
    702851                print_register<BitBlock>("lex.Digit",lex.Digit);
    703                 BitBlock temp57 = simd_andc(temp16,temp49);
     852                BitBlock temp57;
     853                temp57 = simd_andc(temp16,temp49);
    704854                print_register<BitBlock>("temp57",temp57);
    705                 BitBlock temp58 = simd_andc(temp57,basis_bits.bit_4);
     855                BitBlock temp58;
     856                temp58 = simd_andc(temp57,basis_bits.bit_4);
    706857                print_register<BitBlock>("temp58",temp58);
    707                 BitBlock temp59 = simd_not(temp10);
     858                BitBlock temp59;
     859                temp59 = simd_not(temp10);
    708860                print_register<BitBlock>("temp59",temp59);
    709                 BitBlock temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
     861                BitBlock temp60;
     862                temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
    710863                print_register<BitBlock>("temp60",temp60);
    711                 BitBlock temp61 = simd_and(temp58,temp60);
     864                BitBlock temp61;
     865                temp61 = simd_and(temp58,temp60);
    712866                print_register<BitBlock>("temp61",temp61);
    713                 BitBlock temp62 = simd_or(lex.Digit,temp61);
     867                BitBlock temp62;
     868                temp62 = simd_or(lex.Digit,temp61);
    714869                print_register<BitBlock>("temp62",temp62);
    715                 BitBlock temp63 = simd_and(temp16,temp2);
     870                BitBlock temp63;
     871                temp63 = simd_and(temp16,temp2);
    716872                print_register<BitBlock>("temp63",temp63);
    717                 BitBlock temp64 = simd_andc(temp63,basis_bits.bit_4);
     873                BitBlock temp64;
     874                temp64 = simd_andc(temp63,basis_bits.bit_4);
    718875                print_register<BitBlock>("temp64",temp64);
    719                 BitBlock temp65 = simd_and(temp64,temp60);
     876                BitBlock temp65;
     877                temp65 = simd_and(temp64,temp60);
    720878                print_register<BitBlock>("temp65",temp65);
    721879                lex.Hex = simd_or(temp62,temp65);
    722880                print_register<BitBlock>("lex.Hex",lex.Hex);
    723                 BitBlock lex_error = simd_andc(x00_x1F,lex.WS);
     881                BitBlock lex_error;
     882                lex_error = simd_andc(x00_x1F,lex.WS);
    724883                print_register<BitBlock>("lex_error",lex_error);
    725884                if (bitblock::any(simd_and(lex_error,EOF_mask)))
     
    731890                u8.suffix = simd<1>::constant<0>();
    732891                print_register<BitBlock>("u8.suffix",u8.suffix);
    733                 BitBlock u8_error = simd<1>::constant<0>();
     892                BitBlock u8_error;
     893                u8_error = simd<1>::constant<0>();
    734894                print_register<BitBlock>("u8_error",u8_error);
    735                 BitBlock u8_FFFE_FFFF = simd<1>::constant<0>();
     895                BitBlock u8_FFFE_FFFF;
     896                u8_FFFE_FFFF = simd<1>::constant<0>();
    736897                print_register<BitBlock>("u8_FFFE_FFFF",u8_FFFE_FFFF);
    737                 BitBlock u8anyscope = simd<1>::constant<0>();
     898                BitBlock u8anyscope;
     899                u8anyscope = simd<1>::constant<0>();
    738900                print_register<BitBlock>("u8anyscope",u8anyscope);
    739901                if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
     
    749911                        u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
    750912                        print_register<BitBlock>("u8.suffix",u8.suffix);
    751                         BitBlock temp66 = simd_andc(u8.prefix,temp49);
     913                        BitBlock temp66;
     914                        temp66 = simd_andc(u8.prefix,temp49);
    752915                        print_register<BitBlock>("temp66",temp66);
    753                         BitBlock temp67 = simd_or(temp21,basis_bits.bit_6);
     916                        BitBlock temp67;
     917                        temp67 = simd_or(temp21,basis_bits.bit_6);
    754918                        print_register<BitBlock>("temp67",temp67);
    755                         BitBlock temp68 = simd_andc(temp66,temp67);
     919                        BitBlock temp68;
     920                        temp68 = simd_andc(temp66,temp67);
    756921                        print_register<BitBlock>("temp68",temp68);
    757                         BitBlock temp69 = simd_and(basis_bits.bit_5,temp13);
     922                        BitBlock temp69;
     923                        temp69 = simd_and(basis_bits.bit_5,temp13);
    758924                        print_register<BitBlock>("temp69",temp69);
    759                         BitBlock temp70 = simd_or(basis_bits.bit_4,temp69);
     925                        BitBlock temp70;
     926                        temp70 = simd_or(basis_bits.bit_4,temp69);
    760927                        print_register<BitBlock>("temp70",temp70);
    761                         BitBlock temp71 = simd_and(u8.prefix4,temp70);
     928                        BitBlock temp71;
     929                        temp71 = simd_and(u8.prefix4,temp70);
    762930                        print_register<BitBlock>("temp71",temp71);
    763931                        u8.badprefix = simd_or(temp68,temp71);
     
    773941                        if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    774942                        {
    775                                 BitBlock xE0 = simd_andc(u8.prefix3,temp36);
     943                                BitBlock xE0;
     944                                xE0 = simd_andc(u8.prefix3,temp36);
    776945                                print_register<BitBlock>("xE0",xE0);
    777                                 BitBlock xED = simd_and(u8.prefix3,temp20);
     946                                BitBlock xED;
     947                                xED = simd_and(u8.prefix3,temp20);
    778948                                print_register<BitBlock>("xED",xED);
    779                                 BitBlock xF0 = simd_andc(u8.prefix4,temp36);
     949                                BitBlock xF0;
     950                                xF0 = simd_andc(u8.prefix4,temp36);
    780951                                print_register<BitBlock>("xF0",xF0);
    781                                 BitBlock temp72 = simd_andc(temp4,temp13);
     952                                BitBlock temp72;
     953                                temp72 = simd_andc(temp4,temp13);
    782954                                print_register<BitBlock>("temp72",temp72);
    783                                 BitBlock xF4 = simd_and(u8.prefix4,temp72);
     955                                BitBlock xF4;
     956                                xF4 = simd_and(u8.prefix4,temp72);
    784957                                print_register<BitBlock>("xF4",xF4);
    785958                                u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
     
    791964                                u8.x80_x8F = simd_andc(u8.suffix,temp49);
    792965                                print_register<BitBlock>("u8.x80_x8F",u8.x80_x8F);
    793                                 BitBlock xEF = simd_and(u8.prefix3,temp23);
     966                                BitBlock xEF;
     967                                xEF = simd_and(u8.prefix3,temp23);
    794968                                print_register<BitBlock>("xEF",xEF);
    795                                 BitBlock temp73 = simd_and(u8.suffix,temp7);
     969                                BitBlock temp73;
     970                                temp73 = simd_and(u8.suffix,temp7);
    796971                                print_register<BitBlock>("temp73",temp73);
    797972                                u8.xBF = simd_and(temp73,temp23);
     
    821996                                BitBlock __temp__6;
    822997                                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;
     998                                BitBlock E0_F0_scope;
     999                                E0_F0_scope = __temp__6;
    8241000                                print_register<BitBlock>("E0_F0_scope",E0_F0_scope);
    8251001                                BitBlock __temp__7;
    8261002                                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;
     1003                                BitBlock ED_F4_scope;
     1004                                ED_F4_scope = __temp__7;
    8281005                                print_register<BitBlock>("ED_F4_scope",ED_F4_scope);
    8291006                                u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
     
    8391016                                u8.xEF_scope = __temp__8;
    8401017                                print_register<BitBlock>("u8.xEF_scope",u8.xEF_scope);
    841                                 BitBlock u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
     1018                                BitBlock u8lastscope;
     1019                                u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    8421020                                print_register<BitBlock>("u8lastscope",u8lastscope);
    8431021                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
    8441022                                print_register<BitBlock>("u8anyscope",u8anyscope);
    845                                 BitBlock u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
     1023                                BitBlock u8error1;
     1024                                u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
    8461025                                print_register<BitBlock>("u8error1",u8error1);
    847                                 BitBlock u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
     1026                                BitBlock u8error2;
     1027                                u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
    8481028                                print_register<BitBlock>("u8error2",u8error2);
    849                                 BitBlock u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
     1029                                BitBlock u8error3;
     1030                                u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
    8501031                                print_register<BitBlock>("u8error3",u8error3);
    851                                 BitBlock u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
     1032                                BitBlock u8error4;
     1033                                u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    8521034                                print_register<BitBlock>("u8error4",u8error4);
    8531035                                u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
     
    8551037                                BitBlock __temp__9;
    8561038                                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;
     1039                                BitBlock EF_BF_pending;
     1040                                EF_BF_pending = __temp__9;
    8581041                                print_register<BitBlock>("EF_BF_pending",EF_BF_pending);
    8591042                                u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
     
    8641047                                carry_set_0.carryDequeueEnqueue(1,9);
    8651048                        }
    866                         BitBlock u8mismatch = simd_xor(u8anyscope,u8.suffix);
     1049                        BitBlock u8mismatch;
     1050                        u8mismatch = simd_xor(u8anyscope,u8.suffix);
    8671051                        print_register<BitBlock>("u8mismatch",u8mismatch);
    8681052                        if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
     
    9051089                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    9061090                print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    907                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
     1091                BitBlock CtCDPI_starts;
     1092                CtCDPI_starts = simd<1>::constant<0>();
    9081093                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    909                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
     1094                BitBlock CtCDPI_ends;
     1095                CtCDPI_ends = simd<1>::constant<0>();
    9101096                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    911                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
     1097                BitBlock ctCDPI_mask;
     1098                ctCDPI_mask = simd<1>::constant<0>();
    9121099                print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    913                 BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     1100                BitBlock v;
     1101                v = simd_or(lex.LAngle,lex.Hyphen);
    9141102                print_register<BitBlock>("v",v);
    915                 BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     1103                BitBlock w;
     1104                w = simd_or(lex.Hyphen,lex.QMark);
    9161105                print_register<BitBlock>("w",w);
    9171106                BitBlock __temp__0;
    9181107                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;
     1108                BitBlock v1;
     1109                v1 = __temp__0;
    9201110                print_register<BitBlock>("v1",v1);
    9211111                BitBlock __temp__1;
    9221112                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;
     1113                BitBlock w1;
     1114                w1 = __temp__1;
    9241115                print_register<BitBlock>("w1",w1);
    925                 BitBlock LAngle_scope = simd_andc(v1,w1);
     1116                BitBlock LAngle_scope;
     1117                LAngle_scope = simd_andc(v1,w1);
    9261118                print_register<BitBlock>("LAngle_scope",LAngle_scope);
    927                 BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     1119                BitBlock PI_opener;
     1120                PI_opener = simd_and(LAngle_scope,lex.QMark);
    9281121                print_register<BitBlock>("PI_opener",PI_opener);
    929                 BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     1122                BitBlock CtCD_opener;
     1123                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    9301124                print_register<BitBlock>("CtCD_opener",CtCD_opener);
    931                 BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     1125                BitBlock CtCDPI_opener;
     1126                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    9321127                print_register<BitBlock>("CtCDPI_opener",CtCDPI_opener);
    933                 BitBlock CD_closer = simd<1>::constant<0>();
     1128                BitBlock CD_closer;
     1129                CD_closer = simd<1>::constant<0>();
    9341130                print_register<BitBlock>("CD_closer",CD_closer);
    935                 BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     1131                BitBlock DoubleHyphen;
     1132                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    9361133                print_register<BitBlock>("DoubleHyphen",DoubleHyphen);
    9371134                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
     
    9391136                        BitBlock __temp__2;
    9401137                        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);
     1138                        BitBlock DoubleRBracket;
     1139                        DoubleRBracket = simd_and(__temp__2,lex.RBracket);
    9421140                        print_register<BitBlock>("DoubleRBracket",DoubleRBracket);
    9431141                        BitBlock __temp__3;
     
    9501148                        carry_set_0.carryDequeueEnqueue(0,2);
    9511149                }
    952                 BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     1150                BitBlock PI_closer;
     1151                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    9531152                print_register<BitBlock>("PI_closer",PI_closer);
    9541153                BitBlock __temp__4;
    9551154                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;
     1155                BitBlock CtCDPI_Cursor;
     1156                CtCDPI_Cursor = __temp__4;
    9571157                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    9581158                if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
     
    9601160                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    9611161                        print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    962                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     1162                        BitBlock PI_Cursor;
     1163                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    9631164                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
    9641165                        BitBlock __temp__5;
    9651166                        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;
     1167                        BitBlock CD_Ct_Cursor;
     1168                        CD_Ct_Cursor = __temp__5;
    9671169                        print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    968                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1170                        BitBlock CD_Cursor;
     1171                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    9691172                        print_register<BitBlock>("CD_Cursor",CD_Cursor);
    970                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     1173                        BitBlock Ct_Cursor;
     1174                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    9711175                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    9721176                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
     
    9821186                                BitBlock __temp__7;
    9831187                                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;
     1188                                BitBlock PI_name_end;
     1189                                PI_name_end = __temp__7;
    9851190                                print_register<BitBlock>("PI_name_end",PI_name_end);
    986                                 BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1191                                BitBlock PI_error;
     1192                                PI_error = simd_and(PI_Cursor,PI_name_end);
    9871193                                print_register<BitBlock>("PI_error",PI_error);
    988                                 BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     1194                                BitBlock PI_noWS;
     1195                                PI_noWS = simd_andc(PI_name_end,lex.WS);
    9891196                                print_register<BitBlock>("PI_noWS",PI_noWS);
    9901197                                BitBlock __temp__8;
     
    10361243                                Ct_Cursor = __temp__11;
    10371244                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1038                                 BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1245                                BitBlock Ct_error;
     1246                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    10391247                                print_register<BitBlock>("Ct_error",Ct_error);
    10401248                                BitBlock __temp__12;
     
    10821290                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    10831291                                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1084                                 BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     1292                                BitBlock PI_Cursor;
     1293                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    10851294                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
    10861295                                BitBlock __temp__5;
    10871296                                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;
     1297                                BitBlock CD_Ct_Cursor;
     1298                                CD_Ct_Cursor = __temp__5;
    10891299                                print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1090                                 BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1300                                BitBlock CD_Cursor;
     1301                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    10911302                                print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1092                                 BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     1303                                BitBlock Ct_Cursor;
     1304                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    10931305                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    10941306                                if (bitblock::any(PI_Cursor))
     
    11041316                                        BitBlock __temp__7;
    11051317                                        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;
     1318                                        BitBlock PI_name_end;
     1319                                        PI_name_end = __temp__7;
    11071320                                        print_register<BitBlock>("PI_name_end",PI_name_end);
    1108                                         BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1321                                        BitBlock PI_error;
     1322                                        PI_error = simd_and(PI_Cursor,PI_name_end);
    11091323                                        print_register<BitBlock>("PI_error",PI_error);
    1110                                         BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     1324                                        BitBlock PI_noWS;
     1325                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
    11111326                                        print_register<BitBlock>("PI_noWS",PI_noWS);
    11121327                                        BitBlock __temp__8;
     
    11501365                                        Ct_Cursor = __temp__11;
    11511366                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1152                                         BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1367                                        BitBlock Ct_error;
     1368                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    11531369                                        print_register<BitBlock>("Ct_error",Ct_error);
    11541370                                        BitBlock __temp__12;
     
    12251441                ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    12261442                print_register<BitBlock>("ctCDPI_Callouts.PI_ends",ctCDPI_Callouts.PI_ends);
    1227                 BitBlock CtCDPI_starts = simd<1>::constant<0>();
     1443                BitBlock CtCDPI_starts;
     1444                CtCDPI_starts = simd<1>::constant<0>();
    12281445                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1229                 BitBlock CtCDPI_ends = simd<1>::constant<0>();
     1446                BitBlock CtCDPI_ends;
     1447                CtCDPI_ends = simd<1>::constant<0>();
    12301448                print_register<BitBlock>("CtCDPI_ends",CtCDPI_ends);
    1231                 BitBlock ctCDPI_mask = simd<1>::constant<0>();
     1449                BitBlock ctCDPI_mask;
     1450                ctCDPI_mask = simd<1>::constant<0>();
    12321451                print_register<BitBlock>("ctCDPI_mask",ctCDPI_mask);
    1233                 BitBlock v = simd_or(lex.LAngle,lex.Hyphen);
     1452                BitBlock v;
     1453                v = simd_or(lex.LAngle,lex.Hyphen);
    12341454                print_register<BitBlock>("v",v);
    1235                 BitBlock w = simd_or(lex.Hyphen,lex.QMark);
     1455                BitBlock w;
     1456                w = simd_or(lex.Hyphen,lex.QMark);
    12361457                print_register<BitBlock>("w",w);
    12371458                BitBlock __temp__0;
    12381459                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;
     1460                BitBlock v1;
     1461                v1 = __temp__0;
    12401462                print_register<BitBlock>("v1",v1);
    12411463                BitBlock __temp__1;
    12421464                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;
     1465                BitBlock w1;
     1466                w1 = __temp__1;
    12441467                print_register<BitBlock>("w1",w1);
    1245                 BitBlock LAngle_scope = simd_andc(v1,w1);
     1468                BitBlock LAngle_scope;
     1469                LAngle_scope = simd_andc(v1,w1);
    12461470                print_register<BitBlock>("LAngle_scope",LAngle_scope);
    1247                 BitBlock PI_opener = simd_and(LAngle_scope,lex.QMark);
     1471                BitBlock PI_opener;
     1472                PI_opener = simd_and(LAngle_scope,lex.QMark);
    12481473                print_register<BitBlock>("PI_opener",PI_opener);
    1249                 BitBlock CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
     1474                BitBlock CtCD_opener;
     1475                CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    12501476                print_register<BitBlock>("CtCD_opener",CtCD_opener);
    1251                 BitBlock CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
     1477                BitBlock CtCDPI_opener;
     1478                CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    12521479                print_register<BitBlock>("CtCDPI_opener",CtCDPI_opener);
    1253                 BitBlock CD_closer = simd<1>::constant<0>();
     1480                BitBlock CD_closer;
     1481                CD_closer = simd<1>::constant<0>();
    12541482                print_register<BitBlock>("CD_closer",CD_closer);
    1255                 BitBlock DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
     1483                BitBlock DoubleHyphen;
     1484                DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    12561485                print_register<BitBlock>("DoubleHyphen",DoubleHyphen);
    12571486                if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
     
    12591488                        BitBlock __temp__2;
    12601489                        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);
     1490                        BitBlock DoubleRBracket;
     1491                        DoubleRBracket = simd_and(__temp__2,lex.RBracket);
    12621492                        print_register<BitBlock>("DoubleRBracket",DoubleRBracket);
    12631493                        BitBlock __temp__3;
     
    12701500                        carry_set_0.carryDequeueEnqueue(0,2);
    12711501                }
    1272                 BitBlock PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
     1502                BitBlock PI_closer;
     1503                PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    12731504                print_register<BitBlock>("PI_closer",PI_closer);
    12741505                BitBlock __temp__4;
    12751506                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;
     1507                BitBlock CtCDPI_Cursor;
     1508                CtCDPI_Cursor = __temp__4;
    12771509                print_register<BitBlock>("CtCDPI_Cursor",CtCDPI_Cursor);
    12781510                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor,EOF_mask),carry_set_0.carryRange(3,13))))
     
    12801512                        CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    12811513                        print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1282                         BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     1514                        BitBlock PI_Cursor;
     1515                        PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    12831516                        print_register<BitBlock>("PI_Cursor",PI_Cursor);
    12841517                        BitBlock __temp__5;
    12851518                        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;
     1519                        BitBlock CD_Ct_Cursor;
     1520                        CD_Ct_Cursor = __temp__5;
    12871521                        print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1288                         BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1522                        BitBlock CD_Cursor;
     1523                        CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    12891524                        print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1290                         BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     1525                        BitBlock Ct_Cursor;
     1526                        Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    12911527                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    12921528                        if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
     
    13021538                                BitBlock __temp__7;
    13031539                                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;
     1540                                BitBlock PI_name_end;
     1541                                PI_name_end = __temp__7;
    13051542                                print_register<BitBlock>("PI_name_end",PI_name_end);
    1306                                 BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1543                                BitBlock PI_error;
     1544                                PI_error = simd_and(PI_Cursor,PI_name_end);
    13071545                                print_register<BitBlock>("PI_error",PI_error);
    1308                                 BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     1546                                BitBlock PI_noWS;
     1547                                PI_noWS = simd_andc(PI_name_end,lex.WS);
    13091548                                print_register<BitBlock>("PI_noWS",PI_noWS);
    13101549                                BitBlock __temp__8;
     
    13561595                                Ct_Cursor = __temp__11;
    13571596                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1358                                 BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1597                                BitBlock Ct_error;
     1598                                Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    13591599                                print_register<BitBlock>("Ct_error",Ct_error);
    13601600                                BitBlock __temp__12;
     
    14021642                                CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    14031643                                print_register<BitBlock>("CtCDPI_starts",CtCDPI_starts);
    1404                                 BitBlock PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
     1644                                BitBlock PI_Cursor;
     1645                                PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    14051646                                print_register<BitBlock>("PI_Cursor",PI_Cursor);
    14061647                                BitBlock __temp__5;
    14071648                                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;
     1649                                BitBlock CD_Ct_Cursor;
     1650                                CD_Ct_Cursor = __temp__5;
    14091651                                print_register<BitBlock>("CD_Ct_Cursor",CD_Ct_Cursor);
    1410                                 BitBlock CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
     1652                                BitBlock CD_Cursor;
     1653                                CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    14111654                                print_register<BitBlock>("CD_Cursor",CD_Cursor);
    1412                                 BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
     1655                                BitBlock Ct_Cursor;
     1656                                Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    14131657                                print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    14141658                                if (bitblock::any(PI_Cursor))
     
    14241668                                        BitBlock __temp__7;
    14251669                                        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;
     1670                                        BitBlock PI_name_end;
     1671                                        PI_name_end = __temp__7;
    14271672                                        print_register<BitBlock>("PI_name_end",PI_name_end);
    1428                                         BitBlock PI_error = simd_and(PI_Cursor,PI_name_end);
     1673                                        BitBlock PI_error;
     1674                                        PI_error = simd_and(PI_Cursor,PI_name_end);
    14291675                                        print_register<BitBlock>("PI_error",PI_error);
    1430                                         BitBlock PI_noWS = simd_andc(PI_name_end,lex.WS);
     1676                                        BitBlock PI_noWS;
     1677                                        PI_noWS = simd_andc(PI_name_end,lex.WS);
    14311678                                        print_register<BitBlock>("PI_noWS",PI_noWS);
    14321679                                        BitBlock __temp__8;
     
    14701717                                        Ct_Cursor = __temp__11;
    14711718                                        print_register<BitBlock>("Ct_Cursor",Ct_Cursor);
    1472                                         BitBlock Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
     1719                                        BitBlock Ct_error;
     1720                                        Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    14731721                                        print_register<BitBlock>("Ct_error",Ct_error);
    14741722                                        BitBlock __temp__12;
     
    15371785        IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
    15381786        {
    1539                 BitBlock EqExpected = simd<1>::constant<0>();
     1787                BitBlock EqExpected;
     1788                EqExpected = simd<1>::constant<0>();
    15401789                print_register<BitBlock>("EqExpected",EqExpected);
    1541                 BitBlock AttListEnd = simd<1>::constant<0>();
     1790                BitBlock AttListEnd;
     1791                AttListEnd = simd<1>::constant<0>();
    15421792                print_register<BitBlock>("AttListEnd",AttListEnd);
    1543                 BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     1793                BitBlock DQuoteDelim;
     1794                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
    15441795                print_register<BitBlock>("DQuoteDelim",DQuoteDelim);
    1545                 BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     1796                BitBlock SQuoteDelim;
     1797                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
    15461798                print_register<BitBlock>("SQuoteDelim",SQuoteDelim);
    1547                 BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
     1799                BitBlock AttListDelim;
     1800                AttListDelim = simd_or(lex.Slash,lex.RAngle);
    15481801                print_register<BitBlock>("AttListDelim",AttListDelim);
    15491802                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
     
    15551808                tag_Callouts.ElemName_ends = __temp__0;
    15561809                print_register<BitBlock>("tag_Callouts.ElemName_ends",tag_Callouts.ElemName_ends);
    1557                 BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     1810                BitBlock ParseError;
     1811                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    15581812                print_register<BitBlock>("ParseError",ParseError);
    15591813                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    15691823                        BitBlock __temp__1;
    15701824                        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;
     1825                        BitBlock AfterWS;
     1826                        AfterWS = __temp__1;
    15721827                        print_register<BitBlock>("AfterWS",AfterWS);
    15731828                        AttListEnd = simd_and(AfterWS,AttListDelim);
    15741829                        print_register<BitBlock>("AttListEnd",AttListEnd);
    1575                         BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
     1830                        BitBlock AttNameStart;
     1831                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    15761832                        print_register<BitBlock>("AttNameStart",AttNameStart);
    15771833                        if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
     
    15831839                                BitBlock __temp__2;
    15841840                                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;
     1841                                BitBlock AttNameFollow;
     1842                                AttNameFollow = __temp__2;
    15861843                                print_register<BitBlock>("AttNameFollow",AttNameFollow);
    15871844                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     
    16041861                                BitBlock __temp__4;
    16051862                                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;
     1863                                BitBlock AttValPos;
     1864                                AttValPos = __temp__4;
    16071865                                print_register<BitBlock>("AttValPos",AttValPos);
    16081866                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    16091867                                print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1610                                 BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1868                                BitBlock DQuoteAttVal;
     1869                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    16111870                                print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    1612                                 BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1871                                BitBlock SQuoteAttVal;
     1872                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    16131873                                print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    16141874                                BitBlock __temp__5;
    16151875                                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;
     1876                                BitBlock DQuoteAttEnd;
     1877                                DQuoteAttEnd = __temp__5;
    16171878                                print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    16181879                                BitBlock __temp__6;
    16191880                                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;
     1881                                BitBlock SQuoteAttEnd;
     1882                                SQuoteAttEnd = __temp__6;
    16211883                                print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    1622                                 BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1884                                BitBlock AttValEnd;
     1885                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    16231886                                print_register<BitBlock>("AttValEnd",AttValEnd);
    16241887                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     
    16261889                                BitBlock __temp__7;
    16271890                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),__temp__7));
    1628                                 BitBlock AttValFollow = __temp__7;
     1891                                BitBlock AttValFollow;
     1892                                AttValFollow = __temp__7;
    16291893                                print_register<BitBlock>("AttValFollow",AttValFollow);
    16301894                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     
    16601924                                        BitBlock __temp__2;
    16611925                                        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;
     1926                                        BitBlock AttNameFollow;
     1927                                        AttNameFollow = __temp__2;
    16631928                                        print_register<BitBlock>("AttNameFollow",AttNameFollow);
    16641929                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     
    16801945                                        BitBlock __temp__4;
    16811946                                        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;
     1947                                        BitBlock AttValPos;
     1948                                        AttValPos = __temp__4;
    16831949                                        print_register<BitBlock>("AttValPos",AttValPos);
    16841950                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    16851951                                        print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1686                                         BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     1952                                        BitBlock DQuoteAttVal;
     1953                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    16871954                                        print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    1688                                         BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     1955                                        BitBlock SQuoteAttVal;
     1956                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    16891957                                        print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    16901958                                        BitBlock __temp__5;
    16911959                                        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;
     1960                                        BitBlock DQuoteAttEnd;
     1961                                        DQuoteAttEnd = __temp__5;
    16931962                                        print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    16941963                                        BitBlock __temp__6;
    16951964                                        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;
     1965                                        BitBlock SQuoteAttEnd;
     1966                                        SQuoteAttEnd = __temp__6;
    16971967                                        print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    1698                                         BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     1968                                        BitBlock AttValEnd;
     1969                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    16991970                                        print_register<BitBlock>("AttValEnd",AttValEnd);
    17001971                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     
    17021973                                        BitBlock __temp__7;
    17031974                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),__temp__7));
    1704                                         BitBlock AttValFollow = __temp__7;
     1975                                        BitBlock AttValFollow;
     1976                                        AttValFollow = __temp__7;
    17051977                                        print_register<BitBlock>("AttValFollow",AttValFollow);
    17061978                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     
    17422014                        carry_set_0.carryDequeueEnqueue(1,8);
    17432015                }
    1744                 BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
     2016                BitBlock STagEnds;
     2017                STagEnds = simd_and(AttListEnd,lex.RAngle);
    17452018                print_register<BitBlock>("STagEnds",STagEnds);
    17462019                BitBlock __temp__9;
     
    17522025                BitBlock __temp__10;
    17532026                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;
     2027                BitBlock EndTagEnds;
     2028                EndTagEnds = __temp__10;
    17552029                print_register<BitBlock>("EndTagEnds",EndTagEnds);
    17562030                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
     
    17802054        void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
    17812055        {
    1782                 BitBlock EqExpected = simd<1>::constant<0>();
     2056                BitBlock EqExpected;
     2057                EqExpected = simd<1>::constant<0>();
    17832058                print_register<BitBlock>("EqExpected",EqExpected);
    1784                 BitBlock AttListEnd = simd<1>::constant<0>();
     2059                BitBlock AttListEnd;
     2060                AttListEnd = simd<1>::constant<0>();
    17852061                print_register<BitBlock>("AttListEnd",AttListEnd);
    1786                 BitBlock DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
     2062                BitBlock DQuoteDelim;
     2063                DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
    17872064                print_register<BitBlock>("DQuoteDelim",DQuoteDelim);
    1788                 BitBlock SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
     2065                BitBlock SQuoteDelim;
     2066                SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
    17892067                print_register<BitBlock>("SQuoteDelim",SQuoteDelim);
    1790                 BitBlock AttListDelim = simd_or(lex.Slash,lex.RAngle);
     2068                BitBlock AttListDelim;
     2069                AttListDelim = simd_or(lex.Slash,lex.RAngle);
    17912070                print_register<BitBlock>("AttListDelim",AttListDelim);
    17922071                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
     
    17982077                tag_Callouts.ElemName_ends = __temp__0;
    17992078                print_register<BitBlock>("tag_Callouts.ElemName_ends",tag_Callouts.ElemName_ends);
    1800                 BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
     2079                BitBlock ParseError;
     2080                ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    18012081                print_register<BitBlock>("ParseError",ParseError);
    18022082                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    18122092                        BitBlock __temp__1;
    18132093                        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;
     2094                        BitBlock AfterWS;
     2095                        AfterWS = __temp__1;
    18152096                        print_register<BitBlock>("AfterWS",AfterWS);
    18162097                        AttListEnd = simd_and(AfterWS,AttListDelim);
    18172098                        print_register<BitBlock>("AttListEnd",AttListEnd);
    1818                         BitBlock AttNameStart = simd_andc(AfterWS,AttListDelim);
     2099                        BitBlock AttNameStart;
     2100                        AttNameStart = simd_andc(AfterWS,AttListDelim);
    18192101                        print_register<BitBlock>("AttNameStart",AttNameStart);
    18202102                        if (bitblock::any(simd_or(simd_and(AttNameStart,EOF_mask),carry_set_0.carryRange(2,7))))
     
    18262108                                BitBlock __temp__2;
    18272109                                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;
     2110                                BitBlock AttNameFollow;
     2111                                AttNameFollow = __temp__2;
    18292112                                print_register<BitBlock>("AttNameFollow",AttNameFollow);
    18302113                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     
    18472130                                BitBlock __temp__4;
    18482131                                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;
     2132                                BitBlock AttValPos;
     2133                                AttValPos = __temp__4;
    18502134                                print_register<BitBlock>("AttValPos",AttValPos);
    18512135                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    18522136                                print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1853                                 BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     2137                                BitBlock DQuoteAttVal;
     2138                                DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    18542139                                print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    1855                                 BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     2140                                BitBlock SQuoteAttVal;
     2141                                SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    18562142                                print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    18572143                                BitBlock __temp__5;
    18582144                                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;
     2145                                BitBlock DQuoteAttEnd;
     2146                                DQuoteAttEnd = __temp__5;
    18602147                                print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    18612148                                BitBlock __temp__6;
    18622149                                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;
     2150                                BitBlock SQuoteAttEnd;
     2151                                SQuoteAttEnd = __temp__6;
    18642152                                print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    1865                                 BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     2153                                BitBlock AttValEnd;
     2154                                AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    18662155                                print_register<BitBlock>("AttValEnd",AttValEnd);
    18672156                                ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     
    18692158                                BitBlock __temp__7;
    18702159                                carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),__temp__7));
    1871                                 BitBlock AttValFollow = __temp__7;
     2160                                BitBlock AttValFollow;
     2161                                AttValFollow = __temp__7;
    18722162                                print_register<BitBlock>("AttValFollow",AttValFollow);
    18732163                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     
    19032193                                        BitBlock __temp__2;
    19042194                                        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;
     2195                                        BitBlock AttNameFollow;
     2196                                        AttNameFollow = __temp__2;
    19062197                                        print_register<BitBlock>("AttNameFollow",AttNameFollow);
    19072198                                        tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
     
    19232214                                        BitBlock __temp__4;
    19242215                                        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;
     2216                                        BitBlock AttValPos;
     2217                                        AttValPos = __temp__4;
    19262218                                        print_register<BitBlock>("AttValPos",AttValPos);
    19272219                                        tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    19282220                                        print_register<BitBlock>("tag_Callouts.AttVal_starts",tag_Callouts.AttVal_starts);
    1929                                         BitBlock DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
     2221                                        BitBlock DQuoteAttVal;
     2222                                        DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    19302223                                        print_register<BitBlock>("DQuoteAttVal",DQuoteAttVal);
    1931                                         BitBlock SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
     2224                                        BitBlock SQuoteAttVal;
     2225                                        SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    19322226                                        print_register<BitBlock>("SQuoteAttVal",SQuoteAttVal);
    19332227                                        BitBlock __temp__5;
    19342228                                        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;
     2229                                        BitBlock DQuoteAttEnd;
     2230                                        DQuoteAttEnd = __temp__5;
    19362231                                        print_register<BitBlock>("DQuoteAttEnd",DQuoteAttEnd);
    19372232                                        BitBlock __temp__6;
    19382233                                        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;
     2234                                        BitBlock SQuoteAttEnd;
     2235                                        SQuoteAttEnd = __temp__6;
    19402236                                        print_register<BitBlock>("SQuoteAttEnd",SQuoteAttEnd);
    1941                                         BitBlock AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
     2237                                        BitBlock AttValEnd;
     2238                                        AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    19422239                                        print_register<BitBlock>("AttValEnd",AttValEnd);
    19432240                                        ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
     
    19452242                                        BitBlock __temp__7;
    19462243                                        carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),__temp__7));
    1947                                         BitBlock AttValFollow = __temp__7;
     2244                                        BitBlock AttValFollow;
     2245                                        AttValFollow = __temp__7;
    19482246                                        print_register<BitBlock>("AttValFollow",AttValFollow);
    19492247                                        tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
     
    19852283                        carry_set_0.carryDequeueEnqueue(1,8);
    19862284                }
    1987                 BitBlock STagEnds = simd_and(AttListEnd,lex.RAngle);
     2285                BitBlock STagEnds;
     2286                STagEnds = simd_and(AttListEnd,lex.RAngle);
    19882287                print_register<BitBlock>("STagEnds",STagEnds);
    19892288                BitBlock __temp__9;
     
    19952294                BitBlock __temp__10;
    19962295                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;
     2296                BitBlock EndTagEnds;
     2297                EndTagEnds = __temp__10;
    19982298                print_register<BitBlock>("EndTagEnds",EndTagEnds);
    19992299                if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
     
    20432343                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    20442344                print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2045                 BitBlock ref_error = simd<1>::constant<0>();
     2345                BitBlock ref_error;
     2346                ref_error = simd<1>::constant<0>();
    20462347                print_register<BitBlock>("ref_error",ref_error);
    20472348                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
     
    20492350                        BitBlock __temp__0;
    20502351                        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;
     2352                        BitBlock Ref_scope;
     2353                        Ref_scope = __temp__0;
    20522354                        print_register<BitBlock>("Ref_scope",Ref_scope);
    2053                         BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
     2355                        BitBlock NumRef2;
     2356                        NumRef2 = simd_and(Ref_scope,lex.Hash);
    20542357                        print_register<BitBlock>("NumRef2",NumRef2);
    20552358                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
     
    20572360                        BitBlock __temp__1;
    20582361                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),__temp__1));
    2059                         BitBlock NumRef3 = __temp__1;
     2362                        BitBlock NumRef3;
     2363                        NumRef3 = __temp__1;
    20602364                        print_register<BitBlock>("NumRef3",NumRef3);
    2061                         BitBlock HexRef3 = simd_and(NumRef3,lex.x);
     2365                        BitBlock HexRef3;
     2366                        HexRef3 = simd_and(NumRef3,lex.x);
    20622367                        print_register<BitBlock>("HexRef3",HexRef3);
    20632368                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
     
    20792384                        ref_Callouts.HexRef_ends = __temp__5;
    20802385                        print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2081                         BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     2386                        BitBlock ref_error1;
     2387                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
    20822388                        print_register<BitBlock>("ref_error1",ref_error1);
    2083                         BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     2389                        BitBlock ref_error2;
     2390                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
    20842391                        print_register<BitBlock>("ref_error2",ref_error2);
    2085                         BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     2392                        BitBlock ref_ends;
     2393                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
    20862394                        print_register<BitBlock>("ref_ends",ref_ends);
    2087                         BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
     2395                        BitBlock ref_error3;
     2396                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    20882397                        print_register<BitBlock>("ref_error3",ref_error3);
    20892398                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
     
    21132422                ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    21142423                print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2115                 BitBlock ref_error = simd<1>::constant<0>();
     2424                BitBlock ref_error;
     2425                ref_error = simd<1>::constant<0>();
    21162426                print_register<BitBlock>("ref_error",ref_error);
    21172427                if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
     
    21192429                        BitBlock __temp__0;
    21202430                        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;
     2431                        BitBlock Ref_scope;
     2432                        Ref_scope = __temp__0;
    21222433                        print_register<BitBlock>("Ref_scope",Ref_scope);
    2123                         BitBlock NumRef2 = simd_and(Ref_scope,lex.Hash);
     2434                        BitBlock NumRef2;
     2435                        NumRef2 = simd_and(Ref_scope,lex.Hash);
    21242436                        print_register<BitBlock>("NumRef2",NumRef2);
    21252437                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
     
    21272439                        BitBlock __temp__1;
    21282440                        carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),__temp__1));
    2129                         BitBlock NumRef3 = __temp__1;
     2441                        BitBlock NumRef3;
     2442                        NumRef3 = __temp__1;
    21302443                        print_register<BitBlock>("NumRef3",NumRef3);
    2131                         BitBlock HexRef3 = simd_and(NumRef3,lex.x);
     2444                        BitBlock HexRef3;
     2445                        HexRef3 = simd_and(NumRef3,lex.x);
    21322446                        print_register<BitBlock>("HexRef3",HexRef3);
    21332447                        ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
     
    21492463                        ref_Callouts.HexRef_ends = __temp__5;
    21502464                        print_register<BitBlock>("ref_Callouts.HexRef_ends",ref_Callouts.HexRef_ends);
    2151                         BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
     2465                        BitBlock ref_error1;
     2466                        ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
    21522467                        print_register<BitBlock>("ref_error1",ref_error1);
    2153                         BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
     2468                        BitBlock ref_error2;
     2469                        ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
    21542470                        print_register<BitBlock>("ref_error2",ref_error2);
    2155                         BitBlock ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
     2471                        BitBlock ref_ends;
     2472                        ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
    21562473                        print_register<BitBlock>("ref_ends",ref_ends);
    2157                         BitBlock ref_error3 = simd_andc(ref_ends,lex.Semicolon);
     2474                        BitBlock ref_error3;
     2475                        ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    21582476                        print_register<BitBlock>("ref_error3",ref_error3);
    21592477                        if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
     
    21812499                BitBlock __temp__0;
    21822500                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;
     2501                BitBlock PI_names;
     2502                PI_names = __temp__0;
    21842503                print_register<BitBlock>("PI_names",PI_names);
    21852504                BitBlock __temp__1;
    21862505                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;
     2506                BitBlock GenRefs;
     2507                GenRefs = __temp__1;
    21882508                print_register<BitBlock>("GenRefs",GenRefs);
    21892509                BitBlock __temp__2;
    21902510                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;
     2511                BitBlock ElemNames;
     2512                ElemNames = __temp__2;
    21922513                print_register<BitBlock>("ElemNames",ElemNames);
    21932514                BitBlock __temp__3;
    21942515                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;
     2516                BitBlock AttNames;
     2517                AttNames = __temp__3;
    21962518                print_register<BitBlock>("AttNames",AttNames);
    2197                 BitBlock qname_stream = simd_or(ElemNames,AttNames);
     2519                BitBlock qname_stream;
     2520                qname_stream = simd_or(ElemNames,AttNames);
    21982521                print_register<BitBlock>("qname_stream",qname_stream);
    2199                 BitBlock ncname_stream = simd_or(PI_names,GenRefs);
     2522                BitBlock ncname_stream;
     2523                ncname_stream = simd_or(PI_names,GenRefs);
    22002524                print_register<BitBlock>("ncname_stream",ncname_stream);
    2201                 BitBlock name_stream = simd_or(qname_stream,ncname_stream);
     2525                BitBlock name_stream;
     2526                name_stream = simd_or(qname_stream,ncname_stream);
    22022527                print_register<BitBlock>("name_stream",name_stream);
    22032528                BitBlock __temp__4;
    22042529                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);
     2530                BitBlock name_start;
     2531                name_start = simd_andc(name_stream,__temp__4);
    22062532                print_register<BitBlock>("name_start",name_start);
    22072533                BitBlock __temp__5;
    22082534                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);
     2535                BitBlock name_cursor;
     2536                name_cursor = simd_andc(name_stream,__temp__5);
    22102537                print_register<BitBlock>("name_cursor",name_cursor);
    2211                 BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
     2538                BitBlock void_prefix_err;
     2539                void_prefix_err = simd_and(name_cursor,lex.Colon);
    22122540                print_register<BitBlock>("void_prefix_err",void_prefix_err);
    22132541                BitBlock __temp__6;
    22142542                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);
     2543                BitBlock namespace_sep;
     2544                namespace_sep = simd_and(__temp__6,lex.Colon);
    22162545                print_register<BitBlock>("namespace_sep",namespace_sep);
    22172546                BitBlock __temp__7;
    22182547                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;
     2548                BitBlock local_part_start;
     2549                local_part_start = __temp__7;
    22202550                print_register<BitBlock>("local_part_start",local_part_start);
    2221                 BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
     2551                BitBlock local_part_err;
     2552                local_part_err = simd_andc(local_part_start,lex.NameScan);
    22222553                print_register<BitBlock>("local_part_err",local_part_err);
    22232554                BitBlock __temp__8;
    22242555                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);
     2556                BitBlock colon2_err;
     2557                colon2_err = simd_and(__temp__8,lex.Colon);
    22262558                print_register<BitBlock>("colon2_err",colon2_err);
    2227                 BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
     2559                BitBlock ncname_err;
     2560                ncname_err = simd_and(ncname_stream,lex.Colon);
    22282561                print_register<BitBlock>("ncname_err",ncname_err);
    22292562                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
     
    22422575                BitBlock __temp__0;
    22432576                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;
     2577                BitBlock PI_names;
     2578                PI_names = __temp__0;
    22452579                print_register<BitBlock>("PI_names",PI_names);
    22462580                BitBlock __temp__1;
    22472581                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;
     2582                BitBlock GenRefs;
     2583                GenRefs = __temp__1;
    22492584                print_register<BitBlock>("GenRefs",GenRefs);
    22502585                BitBlock __temp__2;
    22512586                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;
     2587                BitBlock ElemNames;
     2588                ElemNames = __temp__2;
    22532589                print_register<BitBlock>("ElemNames",ElemNames);
    22542590                BitBlock __temp__3;
    22552591                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;
     2592                BitBlock AttNames;
     2593                AttNames = __temp__3;
    22572594                print_register<BitBlock>("AttNames",AttNames);
    2258                 BitBlock qname_stream = simd_or(ElemNames,AttNames);
     2595                BitBlock qname_stream;
     2596                qname_stream = simd_or(ElemNames,AttNames);
    22592597                print_register<BitBlock>("qname_stream",qname_stream);
    2260                 BitBlock ncname_stream = simd_or(PI_names,GenRefs);
     2598                BitBlock ncname_stream;
     2599                ncname_stream = simd_or(PI_names,GenRefs);
    22612600                print_register<BitBlock>("ncname_stream",ncname_stream);
    2262                 BitBlock name_stream = simd_or(qname_stream,ncname_stream);
     2601                BitBlock name_stream;
     2602                name_stream = simd_or(qname_stream,ncname_stream);
    22632603                print_register<BitBlock>("name_stream",name_stream);
    22642604                BitBlock __temp__4;
    22652605                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);
     2606                BitBlock name_start;
     2607                name_start = simd_andc(name_stream,__temp__4);
    22672608                print_register<BitBlock>("name_start",name_start);
    22682609                BitBlock __temp__5;
    22692610                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);
     2611                BitBlock name_cursor;
     2612                name_cursor = simd_andc(name_stream,__temp__5);
    22712613                print_register<BitBlock>("name_cursor",name_cursor);
    2272                 BitBlock void_prefix_err = simd_and(name_cursor,lex.Colon);
     2614                BitBlock void_prefix_err;
     2615                void_prefix_err = simd_and(name_cursor,lex.Colon);
    22732616                print_register<BitBlock>("void_prefix_err",void_prefix_err);
    22742617                BitBlock __temp__6;
    22752618                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);
     2619                BitBlock namespace_sep;
     2620                namespace_sep = simd_and(__temp__6,lex.Colon);
    22772621                print_register<BitBlock>("namespace_sep",namespace_sep);
    22782622                BitBlock __temp__7;
    22792623                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;
     2624                BitBlock local_part_start;
     2625                local_part_start = __temp__7;
    22812626                print_register<BitBlock>("local_part_start",local_part_start);
    2282                 BitBlock local_part_err = simd_andc(local_part_start,lex.NameScan);
     2627                BitBlock local_part_err;
     2628                local_part_err = simd_andc(local_part_start,lex.NameScan);
    22832629                print_register<BitBlock>("local_part_err",local_part_err);
    22842630                BitBlock __temp__8;
    22852631                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);
     2632                BitBlock colon2_err;
     2633                colon2_err = simd_and(__temp__8,lex.Colon);
    22872634                print_register<BitBlock>("colon2_err",colon2_err);
    2288                 BitBlock ncname_err = simd_and(ncname_stream,lex.Colon);
     2635                BitBlock ncname_err;
     2636                ncname_err = simd_and(ncname_stream,lex.Colon);
    22892637                print_register<BitBlock>("ncname_err",ncname_err);
    22902638                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
  • proto/pabloj/trunk/src/pabloB/ast/ASTNode.java

    r3295 r3330  
    159159        insertChild(index+1, successor);
    160160    }
     161        public void removeChild(ASTNode node) {
     162            int index = children.indexOf(node);
     163            removeChild(index);
     164        }   
    161165        public void removeChild(int index) {
    162166                ASTNode child = children.remove(index);
  • proto/pabloj/trunk/src/pabloB/ast/ASTTransformer.java

    r3261 r3330  
    6060        public ASTNode visit(KernelPropertyNode node);
    6161
    62         public ASTNode visit(LocalVarDeclNode node);
    63 
    6462        public ASTNode visit(ParameterListNode node);
    6563
     
    8179
    8280        public ASTNode visit(StructTypeNode node);
     81
     82        public ASTNode visit(VarDeclNode node);
    8383
    8484        public ASTNode visit(VoidTypeNode node);
     
    193193                }
    194194
    195                 public ASTNode visit(LocalVarDeclNode node) {
    196                         return defaultVisit(node);
    197                 }
    198 
    199195                public ASTNode visit(ParameterListNode node) {
    200196                        return defaultVisit(node);
     
    234230
    235231                public ASTNode visit(StructTypeNode node) {
     232                        return defaultVisit(node);
     233                }
     234
     235                public ASTNode visit(VarDeclNode node) {
    236236                        return defaultVisit(node);
    237237                }
  • proto/pabloj/trunk/src/pabloB/ast/ASTVisitor.java

    r3261 r3330  
    8686        public T visitLeave(KernelPropertyNode node, List<T> childResults);
    8787
    88         public void visitEnter(LocalVarDeclNode node);
    89         public T visitLeave(LocalVarDeclNode node, List<T> childResults);
    90 
    9188        public void visitEnter(ParameterListNode node);
    9289        public T visitLeave(ParameterListNode node, List<T> childResults);
     
    118115        public void visitEnter(StructTypeNode node);
    119116        public T visitLeave(StructTypeNode node, List<T> childResults);
     117
     118        public void visitEnter(VarDeclNode node);
     119        public T visitLeave(VarDeclNode node, List<T> childResults);
    120120
    121121        public void visitEnter(VoidTypeNode node);
     
    317317                }
    318318
    319                 public void visitEnter(LocalVarDeclNode node) {
    320                         defaultVisitEnter(node);
    321                 }
    322                 public T visitLeave(LocalVarDeclNode node, List<T> childResults) {
    323                         return defaultVisitLeave(node, childResults);
    324                 }
    325 
    326319                public void visitEnter(ParameterListNode node) {
    327320                        defaultVisitEnter(node);
     
    391384                }
    392385                public T visitLeave(StructTypeNode node, List<T> childResults) {
     386                        return defaultVisitLeave(node, childResults);
     387                }
     388
     389                public void visitEnter(VarDeclNode node) {
     390                        defaultVisitEnter(node);
     391                }
     392                public T visitLeave(VarDeclNode node, List<T> childResults) {
    393393                        return defaultVisitLeave(node, childResults);
    394394                }
  • proto/pabloj/trunk/src/pabloB/ast/SimpleVisitor.java

    r3261 r3330  
    6161        public void visit(KernelPropertyNode node);
    6262
    63         public void visit(LocalVarDeclNode node);
    64 
    6563        public void visit(ParameterListNode node);
    6664
     
    8280
    8381        public void visit(StructTypeNode node);
     82
     83        public void visit(VarDeclNode node);
    8484
    8585        public void visit(VoidTypeNode node);
     
    194194                }
    195195
    196                 public void visit(LocalVarDeclNode node) {
    197                         defaultVisit(node);
    198                 }
    199 
    200196                public void visit(ParameterListNode node) {
    201197                        defaultVisit(node);
     
    235231
    236232                public void visit(StructTypeNode node) {
     233                        defaultVisit(node);
     234                }
     235
     236                public void visit(VarDeclNode node) {
    237237                        defaultVisit(node);
    238238                }
  • proto/pabloj/trunk/src/pabloB/ast/VoidVisitor.java

    r3261 r3330  
    8484        public void visitLeave(KernelPropertyNode node);
    8585
    86         public void visitEnter(LocalVarDeclNode node);
    87         public void visitLeave(LocalVarDeclNode node);
    88 
    8986        public void visitEnter(ParameterListNode node);
    9087        public void visitLeave(ParameterListNode node);
     
    116113        public void visitEnter(StructTypeNode node);
    117114        public void visitLeave(StructTypeNode node);
     115
     116        public void visitEnter(VarDeclNode node);
     117        public void visitLeave(VarDeclNode node);
    118118
    119119        public void visitEnter(VoidTypeNode node);
     
    314314                }
    315315
    316                 public void visitEnter(LocalVarDeclNode node) {
    317                         defaultVisitEnter(node);
    318                 }
    319                 public void visitLeave(LocalVarDeclNode node) {
    320                         defaultVisitLeave(node);
    321                 }
    322 
    323316                public void visitEnter(ParameterListNode node) {
    324317                        defaultVisitEnter(node);
     
    388381                }
    389382                public void visitLeave(StructTypeNode node) {
     383                        defaultVisitLeave(node);
     384                }
     385
     386                public void visitEnter(VarDeclNode node) {
     387                        defaultVisitEnter(node);
     388                }
     389                public void visitLeave(VarDeclNode node) {
    390390                        defaultVisitLeave(node);
    391391                }
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r3261 r3330  
    586586                if( nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.BOOL, Lextant.INT, Lextant.STRUCT, Lextant.VOID) ) {
    587587                        {
    588                                 ASTNode child = parseLocalVarDecl();
     588                                ASTNode child = parseVarDecl();
    589589                                result.appendChild(child);
    590590                                allChildren.add(child);
     
    814814        }
    815815         
    816         public ASTNode parseLocalVarDecl() {
     816        public ASTNode parseVarDecl() {
    817817                if( !(nowReading.isLextant(Lextant.BITBLOCK, Lextant.BITFIELD, Lextant.BOOL, Lextant.INT, Lextant.STRUCT, Lextant.VOID)) ) {
    818                         return syntaxErrorNode("localVarDecl² [BITBLOCK¹, BITFIELD¹, BOOL¹, INT¹, STRUCT¹, VOID¹]");
    819                 }
    820        
    821                 boolean allowCompression = true;
    822                 ASTNode result = new LocalVarDeclNode(nowReading);
     818                        return syntaxErrorNode("varDecl² [BITBLOCK¹, BITFIELD¹, BOOL¹, INT¹, STRUCT¹, VOID¹]");
     819                }
     820       
     821                boolean allowCompression = true;
     822                ASTNode result = new VarDeclNode(nowReading);
    823823                result.setProductionTag(29);
    824824                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
     
    832832                        result.appendChild(child);
    833833                        allChildren.add(child);
    834                 }
    835                 if( nowReading.isLextant(Lextant.ASSIGN) ) {
    836                         {
    837                                 ASTNode child = parseAssignOperator();
    838                                 // node omitted - no result.appendChild(child);
    839                                 allChildren.add(child);
    840                                 result.setToken( child.getToken() );
    841                         }
    842                         {
    843                                 ASTNode child = parseExpr();
    844                                 result.appendChild(child);
    845                                 allChildren.add(child);
    846                         }
    847834                }
    848835                expect(Lextant.TERMINATOR);
  • proto/pabloj/trunk/src/pabloS/ast/ASTNode.java

    r3295 r3330  
    169169        insertChild(index+1, successor);
    170170    }
     171        public void removeChild(ASTNode node) {
     172            int index = children.indexOf(node);
     173            removeChild(index);
     174        }   
    171175        public void removeChild(int index) {
    172176                ASTNode child = children.remove(index);
  • proto/pabloj/trunk/src/pabloS/ast/ASTTransformer.java

    r3192 r3330  
    4040        public ASTNode visit(IntegerConstantNode node);
    4141
    42         public ASTNode visit(LocalVarDeclNode node);
    43 
    4442        public ASTNode visit(ParameterListNode node);
    4543
     
    6361
    6462        public ASTNode visit(UnaryOperatorNode node);
     63
     64        public ASTNode visit(VarDeclNode node);
    6565
    6666        public ASTNode visit(VoidTypeNode node);
     
    135135                }
    136136
    137                 public ASTNode visit(LocalVarDeclNode node) {
    138                         return defaultVisit(node);
    139                 }
    140 
    141137                public ASTNode visit(ParameterListNode node) {
    142138                        return defaultVisit(node);
     
    183179                }
    184180
     181                public ASTNode visit(VarDeclNode node) {
     182                        return defaultVisit(node);
     183                }
     184
    185185                public ASTNode visit(VoidTypeNode node) {
    186186                        return defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/ASTVisitor.java

    r3192 r3330  
    5656        public T visitLeave(IntegerConstantNode node, List<T> childResults);
    5757
    58         public void visitEnter(LocalVarDeclNode node);
    59         public T visitLeave(LocalVarDeclNode node, List<T> childResults);
    60 
    6158        public void visitEnter(ParameterListNode node);
    6259        public T visitLeave(ParameterListNode node, List<T> childResults);
     
    9188        public void visitEnter(UnaryOperatorNode node);
    9289        public T visitLeave(UnaryOperatorNode node, List<T> childResults);
     90
     91        public void visitEnter(VarDeclNode node);
     92        public T visitLeave(VarDeclNode node, List<T> childResults);
    9393
    9494        public void visitEnter(VoidTypeNode node);
     
    220220                }
    221221
    222                 public void visitEnter(LocalVarDeclNode node) {
    223                         defaultVisitEnter(node);
    224                 }
    225                 public T visitLeave(LocalVarDeclNode node, List<T> childResults) {
    226                         return defaultVisitLeave(node, childResults);
    227                 }
    228 
    229222                public void visitEnter(ParameterListNode node) {
    230223                        defaultVisitEnter(node);
     
    301294                }
    302295                public T visitLeave(UnaryOperatorNode node, List<T> childResults) {
     296                        return defaultVisitLeave(node, childResults);
     297                }
     298
     299                public void visitEnter(VarDeclNode node) {
     300                        defaultVisitEnter(node);
     301                }
     302                public T visitLeave(VarDeclNode node, List<T> childResults) {
    303303                        return defaultVisitLeave(node, childResults);
    304304                }
  • proto/pabloj/trunk/src/pabloS/ast/SimpleVisitor.java

    r3192 r3330  
    4141        public void visit(IntegerConstantNode node);
    4242
    43         public void visit(LocalVarDeclNode node);
    44 
    4543        public void visit(ParameterListNode node);
    4644
     
    6462
    6563        public void visit(UnaryOperatorNode node);
     64
     65        public void visit(VarDeclNode node);
    6666
    6767        public void visit(VoidTypeNode node);
     
    136136                }
    137137
    138                 public void visit(LocalVarDeclNode node) {
    139                         defaultVisit(node);
    140                 }
    141 
    142138                public void visit(ParameterListNode node) {
    143139                        defaultVisit(node);
     
    184180                }
    185181
     182                public void visit(VarDeclNode node) {
     183                        defaultVisit(node);
     184                }
     185
    186186                public void visit(VoidTypeNode node) {
    187187                        defaultVisit(node);
  • proto/pabloj/trunk/src/pabloS/ast/VoidVisitor.java

    r3192 r3330  
    5454        public void visitLeave(IntegerConstantNode node);
    5555
    56         public void visitEnter(LocalVarDeclNode node);
    57         public void visitLeave(LocalVarDeclNode node);
    58 
    5956        public void visitEnter(ParameterListNode node);
    6057        public void visitLeave(ParameterListNode node);
     
    8986        public void visitEnter(UnaryOperatorNode node);
    9087        public void visitLeave(UnaryOperatorNode node);
     88
     89        public void visitEnter(VarDeclNode node);
     90        public void visitLeave(VarDeclNode node);
    9191
    9292        public void visitEnter(VoidTypeNode node);
     
    217217                }
    218218
    219                 public void visitEnter(LocalVarDeclNode node) {
    220                         defaultVisitEnter(node);
    221                 }
    222                 public void visitLeave(LocalVarDeclNode node) {
    223                         defaultVisitLeave(node);
    224                 }
    225 
    226219                public void visitEnter(ParameterListNode node) {
    227220                        defaultVisitEnter(node);
     
    298291                }
    299292                public void visitLeave(UnaryOperatorNode node) {
     293                        defaultVisitLeave(node);
     294                }
     295
     296                public void visitEnter(VarDeclNode node) {
     297                        defaultVisitEnter(node);
     298                }
     299                public void visitLeave(VarDeclNode node) {
    300300                        defaultVisitLeave(node);
    301301                }
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r3260 r3330  
    378378                if( nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID) ) {
    379379                        {
    380                                 ASTNode child = parseLocalVarDecl();
     380                                ASTNode child = parseVarDecl();
    381381                                result.appendChild(child);
    382382                                allChildren.add(child);
     
    444444        }
    445445         
    446         public ASTNode parseLocalVarDecl() {
     446        public ASTNode parseVarDecl() {
    447447                if( !(nowReading.isLextant(Lextant.INT, Lextant.STREAM, Lextant.STRUCT, Lextant.VOID)) ) {
    448                         return syntaxErrorNode("localVarDecl² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
    449                 }
    450        
    451                 boolean allowCompression = true;
    452                 ASTNode result = new LocalVarDeclNode(nowReading);
     448                        return syntaxErrorNode("varDecl² [INT¹, STREAM¹, STRUCT¹, VOID¹]");
     449                }
     450       
     451                boolean allowCompression = true;
     452                ASTNode result = new VarDeclNode(nowReading);
    453453                result.setProductionTag(15);
    454454                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
  • proto/pabloj/trunk/src/toolchain/pabloB/ast/Accessors.java

    r3325 r3330  
    127127       
    128128        ////////////////////////////////////////////////////////////////////////////
    129         // Local Var Decl Statements
    130         ////////////////////////////////////////////////////////////////////////////
    131        
    132     public static IdentifierNode identifier(LocalVarDeclNode node) {
     129        // Var Decl Statements
     130        ////////////////////////////////////////////////////////////////////////////
     131       
     132    public static IdentifierNode identifier(VarDeclNode node) {
    133133        ASTNode child = node.child(1);
    134134        assert child instanceof IdentifierNode;
     
    136136    }   
    137137   
    138         public static ASTNode lhs(LocalVarDeclNode node) {
     138        public static ASTNode lhs(VarDeclNode node) {
    139139                return node.child(1);
    140140        }       
    141141       
    142         public static ASTNode rhs(LocalVarDeclNode node) {
     142        public static ASTNode rhs(VarDeclNode node) {
    143143       
    144144                return node.child(2);
    145145        }               
    146146       
    147         public static String assignOperatorLexeme(LocalVarDeclNode node) {
    148                 return node.getToken().getPrintableLexeme();
    149         }       
    150        
    151         public static boolean hasInitializationAssign(LocalVarDeclNode node) {
    152 
    153                 if (node.nChildren() > 2) {
    154                         return true;
    155                 }
    156                 return false;
    157         }       
     147        public static String assignOperatorLexeme(VarDeclNode node) {
     148                return node.getToken().getPrintableLexeme();
     149        }       
     150       
    158151       
    159152        ////////////////////////////////////////////////////////////////////////////
  • proto/pabloj/trunk/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3325 r3330  
    326326        }
    327327                               
    328         public CodeStore visitLeave(LocalVarDeclNode node, List<CodeStore> childResults) {
     328       
     329        public CodeStore visitLeave(VarDeclNode node, List<CodeStore> childResults) {
    329330       
    330331                CodeStore code = new CodeStore();
     
    333334                CodeStore identifier                    = (CodeStore)childResults.get(1);
    334335               
    335                 if(Accessors.hasInitializationAssign(node)) {
    336                
    337                         CodeStore expression                    = (CodeStore)childResults.get(2);
    338                
    339                         code.addFormattedLine("%s %s %s %s;",
    340                                                                 type.getResultVarName(),
    341                                                                 identifier.getResultVarName(),
    342                                                                 Accessors.assignOperatorLexeme(node),
    343                                                                 expression.getResultVarName());
    344                 } else {
    345                        
    346                         code.addFormattedLine("%s %s;",
     336                code.addFormattedLine("%s %s;",
    347337                                        type.getResultVarName(),
    348338                                        identifier.getResultVarName());
    349                 }
    350                
     339
    351340                return code;           
    352341        }       
     342       
    353343       
    354344        public CodeStore visitLeave(BlockStmtNode node, List<CodeStore> childResults) {
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/AddAlignmentAssertions.java

    r3264 r3330  
    3232                }
    3333               
    34                 // visits               
    35                 public void visitEnter(LocalVarDeclNode node) {
    36                         addAssertStmt(node, Accessors.identifier(node));
    37                 }               
    38                
    3934                public void visitEnter(AssignNode node) {
    4035                        addAssertStmt(node, Accessors.lhs(node));
  • proto/pabloj/trunk/src/toolchain/pabloB/transformer/visitors/AddAssignmentPrints.java

    r3325 r3330  
    3333                }
    3434               
    35                 // visits
    36                 public void visitEnter(LocalVarDeclNode node) {
    37                         addPrintStatement(node, Accessors.identifier(node));
    38                 }               
    39                
    4035                public void visitEnter(AssignNode node) {
    4136                        addPrintStatement(node, Accessors.lhs(node));
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Accessors.java

    r3325 r3330  
    7575
    7676        public static boolean isAssignmentRhs(ASTNode node) {
    77                 return isAssignNodeRhs(node) || isLocalVarDeclNodeRhs(node);
     77                return isAssignNodeRhs(node) || isVarDeclNodeRhs(node);
    7878        }
    7979       
     
    104104       
    105105        ////////////////////////////////////////////////////////////////////////////
    106         // LocalVarDeclNode
    107         ////////////////////////////////////////////////////////////////////////////
    108         public static ASTNode typeNode(LocalVarDeclNode node) {
    109                 return node.child(0);
    110         }       
    111 
    112         public static IdentifierNode identifier(LocalVarDeclNode node) {
     106        // VarDeclNode
     107        ////////////////////////////////////////////////////////////////////////////
     108        public static ASTNode typeNode(VarDeclNode node) {
     109                return node.child(0);
     110        }       
     111
     112        public static IdentifierNode identifier(VarDeclNode node) {
    113113                ASTNode child = node.child(1);
    114114                assert child instanceof IdentifierNode;
     
    116116        }       
    117117
    118         public static boolean hasInitExpr(LocalVarDeclNode node) {
    119             if(3 == node.nChildren()) {
    120                 return true;
    121             }
    122         return false;
    123     }       
    124 
    125         public static ASTNode lhs(LocalVarDeclNode node) {
     118        public static ASTNode lhs(VarDeclNode node) {
    126119            return node.child(1);
    127120        }       
    128121       
    129         public static ASTNode rhs(LocalVarDeclNode node) {
     122    public static boolean hasInitializationExpr(VarDeclNode node) {
     123        if(3 == node.nChildren()) {
     124            return true;
     125        }
     126        return false;
     127    }           
     128       
     129        public static ASTNode rhs(VarDeclNode node) {
    130130                return node.child(2);
    131131        }               
    132132
    133         public static boolean isLocalVarDeclNodeRhs(ASTNode node) {
     133        public static boolean isVarDeclNodeRhs(ASTNode node) {
    134134                ASTNode parent = node.getParent();
    135                 if ((parent instanceof LocalVarDeclNode)) {
    136                         if (Accessors.rhs((LocalVarDeclNode)parent) == node) {
     135                if ((parent instanceof VarDeclNode)) {
     136                        if (Accessors.rhs((VarDeclNode)parent) == node) {
    137137                                return true;
    138138                        }
     
    141141        }
    142142       
    143         public static String assignOperatorLexeme(LocalVarDeclNode node) {
     143        public static String assignOperatorLexeme(VarDeclNode node) {
    144144                return node.getToken().getLexeme();
    145145        }       
  • proto/pabloj/trunk/src/toolchain/pabloS/ast/Generators.java

    r3325 r3330  
    3838        }
    3939       
    40         public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, ASTNode lhs) {
     40        public static VarDeclNode makeVarDeclNode(Locator locator, ASTNode type, ASTNode lhs) {
    4141            Token assignToken = Generators.makeLextantToken(locator, Lextant.ASSIGN);
    42             LocalVarDeclNode localVarDecl = new LocalVarDeclNode(assignToken);
     42            VarDeclNode localVarDecl = new VarDeclNode(assignToken);
    4343            localVarDecl.appendChild(type);
    4444            localVarDecl.appendChild(lhs);
     
    4949        }
    5050       
    51         public static LocalVarDeclNode makeLocalVarDeclNode(Locator locator, ASTNode type, ASTNode lhs, ASTNode rhs) {         
    52             LocalVarDeclNode localVarDecl = makeLocalVarDeclNode(locator,type,lhs);
     51        public static VarDeclNode makeVarDeclNode(Locator locator, ASTNode type, ASTNode lhs, ASTNode rhs) {           
     52            VarDeclNode localVarDecl = makeVarDeclNode(locator,type,lhs);
    5353                localVarDecl.appendChild(rhs);
    5454                return localVarDecl;
  • proto/pabloj/trunk/src/toolchain/pabloS/semanticAnalyzer/SemanticAnalyzer.java

    r3316 r3330  
    138138                //
    139139                @Override
    140                 public void visitLeave(LocalVarDeclNode node) {
     140                public void visitLeave(VarDeclNode node) {
    141141                        ASTNode typeNode = Accessors.typeNode(node);
    142142                       
    143                         if(Accessors.hasInitExpr(node)) {
     143                        if(Accessors.hasInitializationExpr(node)) {
    144144                                ASTNode rhs = Accessors.rhs(node);
    145145                                typecheckAssignment(node, typeNode, rhs);
     
    390390                private boolean isVariableBeingDefined(IdentifierNode node) {
    391391                        ASTNode parent = node.getParent();
    392                         return ((parent instanceof LocalVarDeclNode) && node == Accessors.identifier((LocalVarDeclNode) parent));
     392                        return ((parent instanceof VarDeclNode) && node == Accessors.identifier((VarDeclNode) parent));
    393393                }
    394394
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/Transformer.java

    r3327 r3330  
    1010import toolchain.pabloS.lang.*;
    1111import toolchain.pabloS.lang.carrySet.CarrySetEncoder;
    12 import toolchain.pabloS.transformer.visitors.CombineAdvances;
    13 import toolchain.pabloS.transformer.visitors.ConvertBitwiseBooleanToIDISACalls;
    14 import toolchain.pabloS.transformer.visitors.ExpandAugmentedAssignments;
    15 import toolchain.pabloS.transformer.visitors.SurroundAssert0sWithIfs;
    16 import toolchain.pabloS.transformer.visitors.SurroundConditionsWithBitBlockAny;
    17 import toolchain.pabloS.transformer.visitors.carry.CarryIntroXFormer;
    18 import toolchain.pabloS.transformer.visitors.carry.TempifyCarryBuiltinCalls;
     12import toolchain.pabloS.transformer.visitors.*;
     13import toolchain.pabloS.transformer.visitors.carry.*;
    1914
    2015public class Transformer {
     
    7166                decoratedTree = ConvertBitwiseBooleanToIDISACalls.apply(decoratedTree);
    7267                //decoratedTree = InitializeStreamDefaults.apply(decoratedTree);
     68               
     69                decoratedTree = SplitVarDeclsInitializations.apply(decoratedTree);
    7370                               
    7471                return decoratedTree;
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/InitializeStreamDefaults.java

    r3308 r3330  
    3131        static private class Bitwise2IDISAGeneralXFormer extends VoidVisitor.Default {
    3232               
    33                 public void visitLeave(LocalVarDeclNode node) {
    34                         if(Accessors.hasInitExpr(node)) {
     33                public void visitLeave(VarDeclNode node) {
     34                        if(Accessors.hasInitializationExpr(node)) {
    3535                                return;
    3636                        }
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/CarryIntroXFormer.java

    r3325 r3330  
    165165                    }
    166166                }
    167 
    168         ///////////////////////////////////////////////////////////////////
    169         // LocalVarDeclNode
    170         public void visitLeave(LocalVarDeclNode node) {
    171             if(Accessors.hasInitExpr(node)) {
    172 
    173                 ASTNode rhs = Accessors.rhs(node);
    174                 if(BuiltinCallUtil.isCarry(rhs)) {
    175                     IdentifierNode lhs = (IdentifierNode) Accessors.lhs(node);
    176                    
    177                     FuncCallNode funcCall = (FuncCallNode) rhs;
    178                    
    179                     PabloSBuiltin builtin = BuiltinCallUtil.builtin(funcCall);
    180                     Counter counter = selectCounter(builtin, carryCounter, advanceNCounter);
    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();
    187                 }
    188             }
    189         }
    190167               
    191168                ///////////////////////////////////////////////////////////////////
  • proto/pabloj/trunk/src/toolchain/pabloS/transformer/visitors/carry/TempifyCarryBuiltinCalls.java

    r3327 r3330  
    109109            }
    110110           
    111         public void visitLeave(LocalVarDeclNode node) {
     111        public void visitLeave(VarDeclNode node) {
    112112            bindTempDeclsToBlockStmt(node);
    113113            bindTempAssignToBlockStmt(node);           
     
    141141                IdentifierNode name              = Generators.makeIdentifierNode(locator, labeller.newLabel());
    142142                StreamTypeNode type              = Generators.makeStreamType(locator);
    143                 LocalVarDeclNode localVarDecl    = Generators.makeLocalVarDeclNode(locator, type, name.deepCopy());
     143                VarDeclNode localVarDecl         = Generators.makeVarDeclNode(locator, type, name.deepCopy());
    144144                AssignNode assignStmt            = Generators.makeAssignNode(locator, name.deepCopy(), node.deepCopy());
    145145
Note: See TracChangeset for help on using the changeset viewer.