Changeset 2988


Ignore:
Timestamp:
Mar 29, 2013, 5:30:20 PM (5 years ago)
Author:
ksherdy
Message:

Added carry getter/setter for implementation consistency.

Location:
proto/pabloj/trunk
Files:
15 edited

Legend:

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

    r2981 r2988  
    2020        e.g. pablo.operation() -> pablos.operation<fw>(...)
    2121
     22
     23--------------------------------------------------------------------------------
     24IDISA Builtins Design
     25--------------------------------------------------------------------------------
     26
     27PabloB syntax   --> PabloB Parser --> output (C,C++,LLVM)
     28       
     29                                                ^
     30                                                |
     31                                               
     32                                IDISA Library Generator
     33                       
     34                                                ^
     35                                                |
     36                                                architecture (sse2, ...)
     37       
     38       
     39        AST:
     40       
     41                IDISA Function Call
     42                /               |               \
     43        cid                     fw              args_list       
     44       
     45       
     46       
    2247================================================================================
    2348PabloS Types
  • proto/pabloj/trunk/input/grammar/scatter/pabloB.scatter

    r2985 r2988  
    44// PabloB (block-at-a-time language)
    55//
    6 // Modified: 2-December-2012    - Original definition.
    7 // Modified: 29-March-2013              - Added IDISA function call.
    8 //                                                              - Added 2^k integer types.
     6// Modified: 02-12-2012 - Original definition.
     7// Modified: 29-03-2013 - Added IDISA function call.
     8//                                              - Added 2^k integer types.
    99//
    1010// TODO: Add BlockMode blocks to specify SIMD field width.
     
    105105        // s t r e a m   s t r u c t   d e c l a r a t i o n s                                                 
    106106        //
    107         kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)? (compoundIdentifier (funcCallRest _promote_))? RCURLY TERMINATOR? ; // TODO eliminate carry.Declare ?
     107               
     108        kernelDef                       ->      KERNEL kernelName LCURLY initDef funcDef (optFuncDef)*  RCURLY TERMINATOR? ;
    108109       
    109110        kernelName                      #-> identifier ;
     
    111112        // s t a t e   i n i t
    112113        //
     114       
    113115        initDef                         ->  INIT initBlock TERMINATOR? ;
    114116       
    115         initBlock                       #-> LCURLY stateInitStmt* RCURLY;
     117        // initBlock                    #-> LCURLY (stateInitStmt)* RCURLY;
     118       
     119        initBlock                       #-> LCURLY (funcCallOrAssignStmt)* RCURLY; // TODO - hack - stick carry set decl stuff in the init section for now
    116120       
    117121        stateInitStmt           ->  stateIdentifier LSQUARE stateSize RSQUARE ASSIGN LCURLY stateInitList RCURLY TERMINATOR?;
     
    125129        stateValue                      ->  integerConstant ;
    126130       
    127         //stateInitList         ->      streamType (COMMA streamType)* ;
     131       
    128132       
    129133        // k e r n e l   f u n c t i o n s
     
    153157        // s t a t e m e n t s
    154158        //
    155         stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    156                        
    157         funcCallOrAssignStmt    -> compoundIdentifier ( (idisaCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
     159        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ; 
     160       
     161        funcCallOrAssignStmt    #-> expr ( (idisaCallRest _promote_) | (funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR ;
    158162       
    159163        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
  • proto/pabloj/trunk/input/grammar/scatter/pabloS.scatter

    r2984 r2988  
    118118        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    119119                       
    120         funcCallOrAssignStmt    #-> compoundIdentifier ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
     120        funcCallOrAssignStmt    #-> expr ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
    121121       
    122122        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
  • proto/pabloj/trunk/input/test/pabloB/proto/parabix2_pablo.pablob

    r2984 r2988  
    1 // PabloB version of parabix2_pablo.py
    2 //
    3 // KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
    4        
    51struct Basis_bits
    62{
     
    129125        BitBlock name_follows;
    130126        BitBlock att_refs;
    131 };     
     127};
     128 
     129kernel Classify_bytes_Validate_utf8
     130{
     131        init
     132        {
     133                CarryDeclare(carry_set_0, 10, 0);       
     134        }
     135         
     136        function void do_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8)
     137        {
     138                var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     139                var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     140                var BitBlock temp3 = simd.andc<1>(temp2, temp1);
     141                var BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     142                var BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     143                var BitBlock temp6 = simd.and<1>(temp4, temp5);
     144                lex.RefStart = simd.and<1>(temp3, temp6);
     145                var BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     146                var BitBlock temp8 = simd.andc<1>(temp7, temp1);
     147                var BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     148                var BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     149                var BitBlock temp11 = simd.and<1>(temp9, temp10);
     150                lex.Semicolon = simd.and<1>(temp8, temp11);
     151                var BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     152                var BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     153                var BitBlock temp14 = simd.andc<1>(temp12, temp13);
     154                lex.LAngle = simd.and<1>(temp8, temp14);
     155                var BitBlock temp15 = simd.and<1>(temp12, temp5);
     156                lex.RAngle = simd.and<1>(temp8, temp15);
     157                var BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     158                var BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     159                var BitBlock temp18 = simd.and<1>(temp16, temp17);
     160                lex.LBracket = simd.and<1>(temp18, temp11);
     161                var BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     162                var BitBlock temp20 = simd.and<1>(temp12, temp19);
     163                lex.RBracket = simd.and<1>(temp18, temp20);
     164                var BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     165                var BitBlock temp22 = simd.andc<1>(temp19, temp21);
     166                lex.Exclam = simd.and<1>(temp3, temp22);
     167                var BitBlock temp23 = simd.and<1>(temp12, temp10);
     168                lex.QMark = simd.and<1>(temp8, temp23);
     169                lex.Hyphen = simd.and<1>(temp3, temp20);
     170                lex.Equals = simd.and<1>(temp8, temp20);
     171                var BitBlock temp24 = simd.and<1>(temp4, temp10);
     172                lex.SQuote = simd.and<1>(temp3, temp24);
     173                var BitBlock temp25 = simd.andc<1>(temp5, temp21);
     174                lex.DQuote = simd.and<1>(temp3, temp25);
     175                lex.Slash = simd.and<1>(temp3, temp23);
     176                var BitBlock temp26 = simd.andc<1>(temp10, temp21);
     177                lex.Hash = simd.and<1>(temp3, temp26);
     178                var BitBlock temp27 = simd.and<1>(temp16, temp7);
     179                var BitBlock temp28 = simd.andc<1>(temp9, temp13);
     180                lex.x = simd.and<1>(temp27, temp28);
     181                var BitBlock temp29 = simd.and<1>(temp9, temp5);
     182                lex.Colon = simd.and<1>(temp8, temp29);
     183                var BitBlock temp30 = simd.and<1>(temp18, temp23);
     184                var BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     185                var BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     186                var BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     187                var BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     188                var BitBlock temp35 = simd.not<1>(temp34);
     189                var BitBlock temp36 = simd.or<1>(temp21, temp13);
     190                var BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     191                var BitBlock temp38 = simd.and<1>(temp32, temp37);
     192                var BitBlock temp39 = simd.or<1>(temp31, temp38);
     193                var BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     194                var BitBlock temp41 = simd.and<1>(temp40, temp37);
     195                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
     196                var BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     197                var BitBlock temp43 = simd.and<1>(temp3, temp15);
     198                var BitBlock temp44 = simd.or<1>(temp42, temp43);
     199                var BitBlock temp45 = simd.andc<1>(temp8, temp34);
     200                var BitBlock temp46 = simd.or<1>(temp44, temp45);
     201                var BitBlock temp47 = simd.or<1>(temp46, temp38);
     202                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
     203                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
     204                var BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     205                var BitBlock x00_x1F = simd.not<1>(temp48);
     206                var BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     207                var BitBlock temp50 = simd.or<1>(temp1, temp49);
     208                lex.CR = simd.andc<1>(temp20, temp50);
     209                lex.LF = simd.andc<1>(temp29, temp50);
     210                var BitBlock temp51 = simd.and<1>(temp9, temp19);
     211                lex.HT = simd.andc<1>(temp51, temp50);
     212                lex.SP = simd.andc<1>(temp3, temp36);
     213                var BitBlock temp52 = simd.or<1>(temp20, temp29);
     214                var BitBlock temp53 = simd.or<1>(temp52, temp51);
     215                var BitBlock temp54 = simd.andc<1>(temp53, temp50);
     216                lex.WS = simd.or<1>(temp54, lex.SP);
     217                var BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     218                var BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     219                lex.Digit = simd.andc<1>(temp8, temp56);
     220                var BitBlock temp57 = simd.andc<1>(temp16, temp49);
     221                var BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     222                var BitBlock temp59 = simd.not<1>(temp10);
     223                var BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     224                var BitBlock temp61 = simd.and<1>(temp58, temp60);
     225                var BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     226                var BitBlock temp63 = simd.and<1>(temp16, temp2);
     227                var BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     228                var BitBlock temp65 = simd.and<1>(temp64, temp60);
     229                lex.Hex = simd.or<1>(temp62, temp65);
     230                var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     231                if (bitblock.any<1>(lex_error))
     232                {
     233                        assert_0_error("Error: illegal character", lex_error);
     234                }
     235                u8.unibyte = simd.not<1>(basis_bits.bit_0);
     236                u8.suffix = simd.constant<1>(0);
     237                var BitBlock u8_error = simd.constant<1>(0);
     238                var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     239                var BitBlock u8anyscope = simd.constant<1>(0);
     240                if (bitblock.any<1>(simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
     241                {
     242                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
     243                        u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
     244                        u8.prefix3 = simd.and<1>(u8.prefix, temp2);
     245                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
     246                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
     247                        var BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     248                        var BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     249                        var BitBlock temp68 = simd.andc<1>(temp66, temp67);
     250                        var BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     251                        var BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     252                        var BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     253                        u8.badprefix = simd.or<1>(temp68, temp71);
     254                        u8_error = u8.badprefix;
     255                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
     256                        u8anyscope = u8.scope22;
     257                        if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
     258                        {
     259                                var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     260                                var BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     261                                var BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     262                                var BitBlock temp72 = simd.andc<1>(temp4, temp13);
     263                                var BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     264                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
     265                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
     266                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
     267                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
     268                                var BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     269                                var BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     270                                u8.xBF = simd.and<1>(temp73, temp23);
     271                                u8.xBE = simd.and<1>(temp73, temp15);
     272                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
     273                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
     274                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
     275                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
     276                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
     277                                var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.GetCarry(6), 6);
     278                                var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.GetCarry(7), 7);
     279                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
     280                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     281                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
     282                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
     283                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
     284                                var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     285                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     286                                var BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     287                                var BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     288                                var BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     289                                var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     290                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
     291                                var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
     292                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
     293                        }
     294                        else
     295                        {
     296                                carry_set_0.CarryDequeueEnqueue(1, 9);
     297                        }
     298                        var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     299                        if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF)))
     300                        {
     301                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
     302                        }
     303                }
     304                else
     305                {
     306                        carry_set_0.CarryDequeueEnqueue(0, 10);
     307                }
     308                carry_set_0.CarryAdjust(10);
     309        }
    132310       
    133 kernel BasisBits
    134 {
    135         init
    136         {
     311        function void do_final_block(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8, BitBlock EOF_mask)
     312        {
     313                var BitBlock temp1 = simd.or<1>(basis_bits.bit_0, basis_bits.bit_1);
     314                var BitBlock temp2 = simd.andc<1>(basis_bits.bit_2, basis_bits.bit_3);
     315                var BitBlock temp3 = simd.andc<1>(temp2, temp1);
     316                var BitBlock temp4 = simd.andc<1>(basis_bits.bit_5, basis_bits.bit_4);
     317                var BitBlock temp5 = simd.andc<1>(basis_bits.bit_6, basis_bits.bit_7);
     318                var BitBlock temp6 = simd.and<1>(temp4, temp5);
     319                lex.RefStart = simd.and<1>(temp3, temp6);
     320                var BitBlock temp7 = simd.and<1>(basis_bits.bit_2, basis_bits.bit_3);
     321                var BitBlock temp8 = simd.andc<1>(temp7, temp1);
     322                var BitBlock temp9 = simd.andc<1>(basis_bits.bit_4, basis_bits.bit_5);
     323                var BitBlock temp10 = simd.and<1>(basis_bits.bit_6, basis_bits.bit_7);
     324                var BitBlock temp11 = simd.and<1>(temp9, temp10);
     325                lex.Semicolon = simd.and<1>(temp8, temp11);
     326                var BitBlock temp12 = simd.and<1>(basis_bits.bit_4, basis_bits.bit_5);
     327                var BitBlock temp13 = simd.or<1>(basis_bits.bit_6, basis_bits.bit_7);
     328                var BitBlock temp14 = simd.andc<1>(temp12, temp13);
     329                lex.LAngle = simd.and<1>(temp8, temp14);
     330                var BitBlock temp15 = simd.and<1>(temp12, temp5);
     331                lex.RAngle = simd.and<1>(temp8, temp15);
     332                var BitBlock temp16 = simd.andc<1>(basis_bits.bit_1, basis_bits.bit_0);
     333                var BitBlock temp17 = simd.andc<1>(basis_bits.bit_3, basis_bits.bit_2);
     334                var BitBlock temp18 = simd.and<1>(temp16, temp17);
     335                lex.LBracket = simd.and<1>(temp18, temp11);
     336                var BitBlock temp19 = simd.andc<1>(basis_bits.bit_7, basis_bits.bit_6);
     337                var BitBlock temp20 = simd.and<1>(temp12, temp19);
     338                lex.RBracket = simd.and<1>(temp18, temp20);
     339                var BitBlock temp21 = simd.or<1>(basis_bits.bit_4, basis_bits.bit_5);
     340                var BitBlock temp22 = simd.andc<1>(temp19, temp21);
     341                lex.Exclam = simd.and<1>(temp3, temp22);
     342                var BitBlock temp23 = simd.and<1>(temp12, temp10);
     343                lex.QMark = simd.and<1>(temp8, temp23);
     344                lex.Hyphen = simd.and<1>(temp3, temp20);
     345                lex.Equals = simd.and<1>(temp8, temp20);
     346                var BitBlock temp24 = simd.and<1>(temp4, temp10);
     347                lex.SQuote = simd.and<1>(temp3, temp24);
     348                var BitBlock temp25 = simd.andc<1>(temp5, temp21);
     349                lex.DQuote = simd.and<1>(temp3, temp25);
     350                lex.Slash = simd.and<1>(temp3, temp23);
     351                var BitBlock temp26 = simd.andc<1>(temp10, temp21);
     352                lex.Hash = simd.and<1>(temp3, temp26);
     353                var BitBlock temp27 = simd.and<1>(temp16, temp7);
     354                var BitBlock temp28 = simd.andc<1>(temp9, temp13);
     355                lex.x = simd.and<1>(temp27, temp28);
     356                var BitBlock temp29 = simd.and<1>(temp9, temp5);
     357                lex.Colon = simd.and<1>(temp8, temp29);
     358                var BitBlock temp30 = simd.and<1>(temp18, temp23);
     359                var BitBlock temp31 = simd.or<1>(temp30, lex.Colon);
     360                var BitBlock temp32 = simd.andc<1>(temp16, basis_bits.bit_2);
     361                var BitBlock temp33 = simd.or<1>(basis_bits.bit_5, temp10);
     362                var BitBlock temp34 = simd.and<1>(basis_bits.bit_4, temp33);
     363                var BitBlock temp35 = simd.not<1>(temp34);
     364                var BitBlock temp36 = simd.or<1>(temp21, temp13);
     365                var BitBlock temp37 = simd.or<1>(simd.and<1>(basis_bits.bit_3, temp35), simd.andc<1>(temp36, basis_bits.bit_3));
     366                var BitBlock temp38 = simd.and<1>(temp32, temp37);
     367                var BitBlock temp39 = simd.or<1>(temp31, temp38);
     368                var BitBlock temp40 = simd.and<1>(temp16, basis_bits.bit_2);
     369                var BitBlock temp41 = simd.and<1>(temp40, temp37);
     370                lex.ASCII_name_start = simd.or<1>(temp39, temp41);
     371                var BitBlock temp42 = simd.or<1>(temp30, lex.Hyphen);
     372                var BitBlock temp43 = simd.and<1>(temp3, temp15);
     373                var BitBlock temp44 = simd.or<1>(temp42, temp43);
     374                var BitBlock temp45 = simd.andc<1>(temp8, temp34);
     375                var BitBlock temp46 = simd.or<1>(temp44, temp45);
     376                var BitBlock temp47 = simd.or<1>(temp46, temp38);
     377                lex.ASCII_name_char = simd.or<1>(temp47, temp41);
     378                lex.NameScan = simd.or<1>(lex.ASCII_name_char, basis_bits.bit_0);
     379                var BitBlock temp48 = simd.or<1>(temp1, basis_bits.bit_2);
     380                var BitBlock x00_x1F = simd.not<1>(temp48);
     381                var BitBlock temp49 = simd.or<1>(basis_bits.bit_2, basis_bits.bit_3);
     382                var BitBlock temp50 = simd.or<1>(temp1, temp49);
     383                lex.CR = simd.andc<1>(temp20, temp50);
     384                lex.LF = simd.andc<1>(temp29, temp50);
     385                var BitBlock temp51 = simd.and<1>(temp9, temp19);
     386                lex.HT = simd.andc<1>(temp51, temp50);
     387                lex.SP = simd.andc<1>(temp3, temp36);
     388                var BitBlock temp52 = simd.or<1>(temp20, temp29);
     389                var BitBlock temp53 = simd.or<1>(temp52, temp51);
     390                var BitBlock temp54 = simd.andc<1>(temp53, temp50);
     391                lex.WS = simd.or<1>(temp54, lex.SP);
     392                var BitBlock temp55 = simd.or<1>(basis_bits.bit_5, basis_bits.bit_6);
     393                var BitBlock temp56 = simd.and<1>(basis_bits.bit_4, temp55);
     394                lex.Digit = simd.andc<1>(temp8, temp56);
     395                var BitBlock temp57 = simd.andc<1>(temp16, temp49);
     396                var BitBlock temp58 = simd.andc<1>(temp57, basis_bits.bit_4);
     397                var BitBlock temp59 = simd.not<1>(temp10);
     398                var BitBlock temp60 = simd.or<1>(simd.and<1>(basis_bits.bit_5, temp59), simd.andc<1>(temp13, basis_bits.bit_5));
     399                var BitBlock temp61 = simd.and<1>(temp58, temp60);
     400                var BitBlock temp62 = simd.or<1>(lex.Digit, temp61);
     401                var BitBlock temp63 = simd.and<1>(temp16, temp2);
     402                var BitBlock temp64 = simd.andc<1>(temp63, basis_bits.bit_4);
     403                var BitBlock temp65 = simd.and<1>(temp64, temp60);
     404                lex.Hex = simd.or<1>(temp62, temp65);
     405                var BitBlock lex_error = simd.andc<1>(x00_x1F, lex.WS);
     406                if (bitblock.any<1>(simd.and<1>(lex_error, EOF_mask)))
     407                {
     408                        assert_0_error("Error: illegal character", simd.and<1>(lex_error, EOF_mask));
     409                }
     410                u8.unibyte = simd.not<1>(basis_bits.bit_0);
     411                u8.suffix = simd.constant<1>(0);
     412                var BitBlock u8_error = simd.constant<1>(0);
     413                var BitBlock u8_FFFE_FFFF = simd.constant<1>(0);
     414                var BitBlock u8anyscope = simd.constant<1>(0);
     415                if (bitblock.any<1>(simd.or<1>(basis_bits.bit_0, carry_set_0.CarryRange(0, 10))))
     416                {
     417                        u8.prefix = simd.and<1>(basis_bits.bit_0, basis_bits.bit_1);
     418                        u8.prefix2 = simd.andc<1>(u8.prefix, basis_bits.bit_2);
     419                        u8.prefix3 = simd.and<1>(u8.prefix, temp2);
     420                        u8.prefix4 = simd.and<1>(u8.prefix, temp7);
     421                        u8.suffix = simd.andc<1>(basis_bits.bit_0, basis_bits.bit_1);
     422                        var BitBlock temp66 = simd.andc<1>(u8.prefix, temp49);
     423                        var BitBlock temp67 = simd.or<1>(temp21, basis_bits.bit_6);
     424                        var BitBlock temp68 = simd.andc<1>(temp66, temp67);
     425                        var BitBlock temp69 = simd.and<1>(basis_bits.bit_5, temp13);
     426                        var BitBlock temp70 = simd.or<1>(basis_bits.bit_4, temp69);
     427                        var BitBlock temp71 = simd.and<1>(u8.prefix4, temp70);
     428                        u8.badprefix = simd.or<1>(temp68, temp71);
     429                        u8_error = u8.badprefix;
     430                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
     431                        u8anyscope = u8.scope22;
     432                        if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
     433                        {
     434                                var BitBlock xE0 = simd.andc<1>(u8.prefix3, temp36);
     435                                var BitBlock xED = simd.and<1>(u8.prefix3, temp20);
     436                                var BitBlock xF0 = simd.andc<1>(u8.prefix4, temp36);
     437                                var BitBlock temp72 = simd.andc<1>(temp4, temp13);
     438                                var BitBlock xF4 = simd.and<1>(u8.prefix4, temp72);
     439                                u8.xA0_xBF = simd.and<1>(u8.suffix, basis_bits.bit_2);
     440                                u8.x80_x9F = simd.andc<1>(u8.suffix, basis_bits.bit_2);
     441                                u8.x90_xBF = simd.and<1>(u8.suffix, temp49);
     442                                u8.x80_x8F = simd.andc<1>(u8.suffix, temp49);
     443                                var BitBlock xEF = simd.and<1>(u8.prefix3, temp23);
     444                                var BitBlock temp73 = simd.and<1>(u8.suffix, temp7);
     445                                u8.xBF = simd.and<1>(temp73, temp23);
     446                                u8.xBE = simd.and<1>(temp73, temp15);
     447                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
     448                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
     449                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
     450                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
     451                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
     452                                var BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xE0, xF0), carry_set_0.GetCarry(6), 6);
     453                                var BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd.or<1>(xED, xF4), carry_set_0.GetCarry(7), 7);
     454                                u8.xE0_scope = simd.and<1>(u8.scope32, E0_F0_scope);
     455                                u8.xED_scope = simd.and<1>(u8.scope32, ED_F4_scope);
     456                                u8.xF0_scope = simd.and<1>(u8.scope42, E0_F0_scope);
     457                                u8.xF4_scope = simd.and<1>(u8.scope42, ED_F4_scope);
     458                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
     459                                var BitBlock u8lastscope = simd.or<1>(simd.or<1>(u8.scope22, u8.scope33), u8.scope44);
     460                                u8anyscope = simd.or<1>(simd.or<1>(simd.or<1>(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     461                                var BitBlock u8error1 = simd.and<1>(u8.xE0_scope, u8.x80_x9F);
     462                                var BitBlock u8error2 = simd.and<1>(u8.xED_scope, u8.xA0_xBF);
     463                                var BitBlock u8error3 = simd.and<1>(u8.xF0_scope, u8.x80_x8F);
     464                                var BitBlock u8error4 = simd.and<1>(u8.xF4_scope, u8.x90_xBF);
     465                                u8_error = simd.or<1>(u8_error, simd.or<1>(simd.or<1>(simd.or<1>(u8error1, u8error2), u8error3), u8error4));
     466                                var BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
     467                                u8_FFFE_FFFF = simd.and<1>(EF_BF_pending, simd.or<1>(u8.xBE, u8.xBF));
     468                        }
     469                        else
     470                        {
     471                                carry_set_0.CarryDequeueEnqueue(1, 9);
     472                        }
     473                        var BitBlock u8mismatch = simd.xor<1>(u8anyscope, u8.suffix);
     474                        if (bitblock.any<1>(simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF)))
     475                        {
     476                                assert_0_error("UTF-8 error found", simd.or<1>(simd.or<1>(u8_error, u8mismatch), u8_FFFE_FFFF));
     477                        }
     478                }
     479                else
     480                {
     481                        carry_set_0.CarryDequeueEnqueue(0, 10);
     482                }
     483        }
     484       
     485};
     486 
     487kernel Parse_CtCDPI
     488{
     489        init
     490        {
     491                CarryDeclare(carry_set_0, 17, 2);
     492                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2),2));
     493        }
    137494         
    138         }
    139 
    140         function void do_block()
    141         {
    142                
    143                
    144         }
    145 
    146 };     
     495        function void do_block(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams)
     496        {
     497                ctCDPI_Callouts.Ct_starts = simd.constant<1>(0);
     498                ctCDPI_Callouts.Ct_ends = simd.constant<1>(0);
     499                ctCDPI_Callouts.CD_starts = simd.constant<1>(0);
     500                ctCDPI_Callouts.CD_ends = simd.constant<1>(0);
     501                ctCDPI_Callouts.PI_starts = simd.constant<1>(0);
     502                ctCDPI_Callouts.PI_name_starts = simd.constant<1>(0);
     503                ctCDPI_Callouts.PI_name_ends = simd.constant<1>(0);
     504                ctCDPI_Callouts.PI_ends = simd.constant<1>(0);
     505                var BitBlock CtCDPI_starts = simd.constant<1>(0);
     506                var BitBlock CtCDPI_ends = simd.constant<1>(0);
     507                var BitBlock ctCDPI_mask = simd.constant<1>(0);
     508                var BitBlock v = simd.or<1>(lex.LAngle, lex.Hyphen);
     509                var BitBlock w = simd.or<1>(lex.Hyphen, lex.QMark);
     510                var BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
     511                var BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
     512                var BitBlock LAngle_scope = simd.andc<1>(v1, w1);
     513                var BitBlock PI_opener = simd.and<1>(LAngle_scope, lex.QMark);
     514                var BitBlock CtCD_opener = simd.and<1>(LAngle_scope, lex.Exclam);
     515                var BitBlock CtCDPI_opener = simd.or<1>(PI_opener, CtCD_opener);
     516                var BitBlock CD_closer = simd.constant<1>(0);
     517                var BitBlock DoubleHyphen = simd.and<1>(simd.and<1>(v1, w1), lex.Hyphen);
     518                if (bitblock.any<1>(simd.or<1>(lex.RBracket, carry_set_0.CarryRange(0, 2))))
     519                {
     520                        var BitBlock DoubleRBracket = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
     521                        CD_closer = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
     522                }
     523                else
     524                {
     525                        carry_set_0.CarryDequeueEnqueue(0, 2);
     526                }
     527                var BitBlock PI_closer = simd.and<1>(simd.andc<1>(w1, v1), lex.RAngle);
     528                var BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
     529                if (bitblock.any<1>(simd.or<1>(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
     530                {
     531                        CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
     532                        var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
     533                        var BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
     534                        var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
     535                        var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
     536                        if (bitblock.any<1>(simd.or<1>(PI_Cursor, carry_set_0.CarryRange(4, 4))))
     537                        {
     538                                ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
     539                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
     540                                ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
     541                                var BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
     542                                var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
     543                                var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
     544                                PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
     545                                if (bitblock.any<1>(PI_error))
     546                                {
     547                                        assert_0_error("Error in PI syntax", PI_error);
     548                                }
     549                                ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
     550                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd.not<1>(PI_closer), carry_set_0.GetCarry(7), 7);
     551                                ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
     552                                CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
     553                        }
     554                        else
     555                        {
     556                                carry_set_0.CarryDequeueEnqueue(4, 4);
     557                        }
     558                        if (bitblock.any<1>(simd.or<1>(CD_Cursor, carry_set_0.CarryRange(8, 1))))
     559                        {
     560                                ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
     561                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd.not<1>(CD_closer), carry_set_0.GetCarry(8), 8);
     562                                ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
     563                                CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
     564                        }
     565                        else
     566                        {
     567                                carry_set_0.CarryDequeueEnqueue(8, 1);
     568                        }
     569                        if (bitblock.any<1>(simd.or<1>(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
     570                        {
     571                                ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
     572                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
     573                                var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
     574                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
     575                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd.not<1>(DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
     576                                if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
     577                                {
     578                                        assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
     579                                }
     580                                ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
     581                                CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
     582                        }
     583                        else
     584                        {
     585                                carry_set_0.CarryDequeueEnqueue(9, 5);
     586                        }
     587                        CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
     588                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
     589                        if (bitblock.any<1>(simd.constant<1>(0)))
     590                        {
     591                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.constant<1>(0));
     592                        }
     593                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.not<1>(CtCDPI_opener), carry_set_0.GetCarry(15), 15);
     594                        while (bitblock.any<1>(CtCDPI_Cursor))
     595                        {
     596                                CarryDeclare(carry_set_1, 13, 0);
     597                                CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
     598                                var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
     599                                var BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), simd.constant<1>(0), 0);
     600                                var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
     601                                var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
     602                                if (bitblock.any<1>(PI_Cursor))
     603                                {
     604                                        ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
     605                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd.constant<1>(0), 1);
     606                                        ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
     607                                        var BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd.constant<1>(0), 2);
     608                                        var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
     609                                        var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
     610                                        PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd.constant<1>(0), 3), PI_closer)));
     611                                        if (bitblock.any<1>(PI_error))
     612                                        {
     613                                                assert_0_error("Error in PI syntax", PI_error);
     614                                        }
     615                                        ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
     616                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd.not<1>(PI_closer), simd.constant<1>(0), 4);
     617                                        ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
     618                                        CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
     619                                }
     620                                if (bitblock.any<1>(CD_Cursor))
     621                                {
     622                                        ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
     623                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd.not<1>(CD_closer), simd.constant<1>(0), 5);
     624                                        ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
     625                                        CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
     626                                }
     627                                if (bitblock.any<1>(Ct_Cursor))
     628                                {
     629                                        ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
     630                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 6);
     631                                        var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
     632                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 7), simd.constant<1>(0), 8);
     633                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd.not<1>(DoubleHyphen), simd.constant<1>(0), 9), simd.constant<1>(0), 10);
     634                                        if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
     635                                        {
     636                                                assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
     637                                        }
     638                                        ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
     639                                        CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
     640                                }
     641                                CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
     642                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd.constant<1>(0), 11);
     643                                if (bitblock.any<1>(simd.constant<1>(0)))
     644                                {
     645                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.constant<1>(0));
     646                                }
     647                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.not<1>(CtCDPI_opener), simd.constant<1>(0), 12);
     648                                carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
     649                        }
     650                }
     651                else
     652                {
     653                        carry_set_0.CarryDequeueEnqueue(3, 13);
     654                }
     655                check_streams.misc_mask = simd.and<1>(simd.or<1>(simd.or<1>(simd.or<1>(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd.or<1>(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd.or<1>(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
     656                marker.LAngle_scope = simd.andc<1>(LAngle_scope, ctCDPI_mask);
     657                marker.Ref_opener = simd.andc<1>(lex.RefStart, ctCDPI_mask);
     658                marker.CD_closer = simd.andc<1>(CD_closer, ctCDPI_mask);
     659                carry_set_0.CarryAdjust(17);
     660        }
     661       
     662        function void do_final_block(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
     663        {
     664                ctCDPI_Callouts.Ct_starts = simd.constant<1>(0);
     665                ctCDPI_Callouts.Ct_ends = simd.constant<1>(0);
     666                ctCDPI_Callouts.CD_starts = simd.constant<1>(0);
     667                ctCDPI_Callouts.CD_ends = simd.constant<1>(0);
     668                ctCDPI_Callouts.PI_starts = simd.constant<1>(0);
     669                ctCDPI_Callouts.PI_name_starts = simd.constant<1>(0);
     670                ctCDPI_Callouts.PI_name_ends = simd.constant<1>(0);
     671                ctCDPI_Callouts.PI_ends = simd.constant<1>(0);
     672                var BitBlock CtCDPI_starts = simd.constant<1>(0);
     673                var BitBlock CtCDPI_ends = simd.constant<1>(0);
     674                var BitBlock ctCDPI_mask = simd.constant<1>(0);
     675                var BitBlock v = simd.or<1>(lex.LAngle, lex.Hyphen);
     676                var BitBlock w = simd.or<1>(lex.Hyphen, lex.QMark);
     677                var BitBlock v1 = carry_set_0.BitBlock_advance_n_<1>(v, carry_set_0.Pending64(0), 0);
     678                var BitBlock w1 = carry_set_0.BitBlock_advance_n_<1>(w, carry_set_0.Pending64(1), 1);
     679                var BitBlock LAngle_scope = simd.andc<1>(v1, w1);
     680                var BitBlock PI_opener = simd.and<1>(LAngle_scope, lex.QMark);
     681                var BitBlock CtCD_opener = simd.and<1>(LAngle_scope, lex.Exclam);
     682                var BitBlock CtCDPI_opener = simd.or<1>(PI_opener, CtCD_opener);
     683                var BitBlock CD_closer = simd.constant<1>(0);
     684                var BitBlock DoubleHyphen = simd.and<1>(simd.and<1>(v1, w1), lex.Hyphen);
     685                if (bitblock.any<1>(simd.or<1>(lex.RBracket, carry_set_0.CarryRange(0, 2))))
     686                {
     687                        var BitBlock DoubleRBracket = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
     688                        CD_closer = simd.and<1>(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
     689                }
     690                else
     691                {
     692                        carry_set_0.CarryDequeueEnqueue(0, 2);
     693                }
     694                var BitBlock PI_closer = simd.and<1>(simd.andc<1>(w1, v1), lex.RAngle);
     695                var BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
     696                if (bitblock.any<1>(simd.or<1>(simd.and<1>(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
     697                {
     698                        CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
     699                        var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
     700                        var BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
     701                        var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
     702                        var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
     703                        if (bitblock.any<1>(simd.or<1>(PI_Cursor, carry_set_0.CarryRange(4, 4))))
     704                        {
     705                                ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
     706                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
     707                                ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
     708                                var BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
     709                                var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
     710                                var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
     711                                PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
     712                                if (bitblock.any<1>(PI_error))
     713                                {
     714                                        assert_0_error("Error in PI syntax", PI_error);
     715                                }
     716                                ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
     717                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd.andc<1>(EOF_mask, PI_closer), carry_set_0.GetCarry(7), 7);
     718                                ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
     719                                CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
     720                        }
     721                        else
     722                        {
     723                                carry_set_0.CarryDequeueEnqueue(4, 4);
     724                        }
     725                        if (bitblock.any<1>(simd.or<1>(CD_Cursor, carry_set_0.CarryRange(8, 1))))
     726                        {
     727                                ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
     728                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd.andc<1>(EOF_mask, CD_closer), carry_set_0.GetCarry(8), 8);
     729                                ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
     730                                CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
     731                        }
     732                        else
     733                        {
     734                                carry_set_0.CarryDequeueEnqueue(8, 1);
     735                        }
     736                        if (bitblock.any<1>(simd.or<1>(Ct_Cursor, carry_set_0.CarryRange(9, 5))))
     737                        {
     738                                ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
     739                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
     740                                var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
     741                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
     742                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd.andc<1>(EOF_mask, DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
     743                                if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
     744                                {
     745                                        assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
     746                                }
     747                                ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
     748                                CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
     749                        }
     750                        else
     751                        {
     752                                carry_set_0.CarryDequeueEnqueue(9, 5);
     753                        }
     754                        CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
     755                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
     756                        if (bitblock.any<1>(simd.andc<1>(ctCDPI_mask, EOF_mask)))
     757                        {
     758                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.andc<1>(ctCDPI_mask, EOF_mask));
     759                        }
     760                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.andc<1>(EOF_mask, CtCDPI_opener), carry_set_0.GetCarry(15), 15);
     761                        while (bitblock.any<1>(simd.and<1>(CtCDPI_Cursor, EOF_mask)))
     762                        {
     763                                CarryDeclare(carry_set_1, 13, 0);
     764                                CtCDPI_starts = simd.or<1>(CtCDPI_starts, CtCDPI_Cursor);
     765                                var BitBlock PI_Cursor = simd.and<1>(CtCDPI_Cursor, PI_opener);
     766                                var BitBlock CD_Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(simd.andc<1>(CtCDPI_Cursor, PI_Cursor), simd.constant<1>(0), 0);
     767                                var BitBlock CD_Cursor = simd.and<1>(CD_Ct_Cursor, lex.LBracket);
     768                                var BitBlock Ct_Cursor = simd.and<1>(CD_Ct_Cursor, lex.Hyphen);
     769                                if (bitblock.any<1>(PI_Cursor))
     770                                {
     771                                        ctCDPI_Callouts.PI_starts = simd.or<1>(ctCDPI_Callouts.PI_starts, PI_Cursor);
     772                                        PI_Cursor = carry_set_1.BitBlock_advance_ci_co(PI_Cursor, simd.constant<1>(0), 1);
     773                                        ctCDPI_Callouts.PI_name_starts = simd.or<1>(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
     774                                        var BitBlock PI_name_end = carry_set_1.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, simd.constant<1>(0), 2);
     775                                        var BitBlock PI_error = simd.and<1>(PI_Cursor, PI_name_end);
     776                                        var BitBlock PI_noWS = simd.andc<1>(PI_name_end, lex.WS);
     777                                        PI_error = simd.or<1>(PI_error, simd.or<1>(simd.andc<1>(PI_noWS, lex.QMark), simd.andc<1>(carry_set_1.BitBlock_advance_ci_co(PI_noWS, simd.constant<1>(0), 3), PI_closer)));
     778                                        if (bitblock.any<1>(PI_error))
     779                                        {
     780                                                assert_0_error("Error in PI syntax", PI_error);
     781                                        }
     782                                        ctCDPI_Callouts.PI_name_ends = simd.or<1>(ctCDPI_Callouts.PI_name_ends, PI_name_end);
     783                                        PI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(PI_name_end, simd.andc<1>(EOF_mask, PI_closer), simd.constant<1>(0), 4);
     784                                        ctCDPI_Callouts.PI_ends = simd.or<1>(ctCDPI_Callouts.PI_ends, PI_Cursor);
     785                                        CtCDPI_ends = simd.or<1>(CtCDPI_ends, PI_Cursor);
     786                                }
     787                                if (bitblock.any<1>(CD_Cursor))
     788                                {
     789                                        ctCDPI_Callouts.CD_starts = simd.or<1>(ctCDPI_Callouts.CD_starts, CD_Cursor);
     790                                        CD_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CD_Cursor, simd.andc<1>(EOF_mask, CD_closer), simd.constant<1>(0), 5);
     791                                        ctCDPI_Callouts.CD_ends = simd.or<1>(ctCDPI_Callouts.CD_ends, CD_Cursor);
     792                                        CtCDPI_ends = simd.or<1>(CtCDPI_ends, CD_Cursor);
     793                                }
     794                                if (bitblock.any<1>(Ct_Cursor))
     795                                {
     796                                        ctCDPI_Callouts.Ct_starts = simd.or<1>(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
     797                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 6);
     798                                        var BitBlock Ct_error = simd.andc<1>(Ct_Cursor, lex.Hyphen);
     799                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_advance_ci_co(Ct_Cursor, simd.constant<1>(0), 7), simd.constant<1>(0), 8);
     800                                        Ct_Cursor = carry_set_1.BitBlock_advance_ci_co(carry_set_1.BitBlock_scanthru_ci_co(Ct_Cursor, simd.andc<1>(EOF_mask, DoubleHyphen), simd.constant<1>(0), 9), simd.constant<1>(0), 10);
     801                                        if (bitblock.any<1>(simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle))))
     802                                        {
     803                                                assert_0_error("Error in comment syntax", simd.or<1>(Ct_error, simd.andc<1>(Ct_Cursor, lex.RAngle)));
     804                                        }
     805                                        ctCDPI_Callouts.Ct_ends = simd.or<1>(ctCDPI_Callouts.Ct_ends, Ct_Cursor);
     806                                        CtCDPI_ends = simd.or<1>(CtCDPI_ends, Ct_Cursor);
     807                                }
     808                                CtCDPI_Cursor = simd.or<1>(simd.or<1>(PI_Cursor, CD_Cursor), Ct_Cursor);
     809                                ctCDPI_mask = carry_set_1.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, simd.constant<1>(0), 11);
     810                                if (bitblock.any<1>(simd.andc<1>(ctCDPI_mask, EOF_mask)))
     811                                {
     812                                        assert_0_error("Error in comment, CDATA or processing instruction syntax", simd.andc<1>(ctCDPI_mask, EOF_mask));
     813                                }
     814                                CtCDPI_Cursor = carry_set_1.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd.andc<1>(EOF_mask, CtCDPI_opener), simd.constant<1>(0), 12);
     815                                carry_set_0.CarryCombine(carry_set_1.cq, 3, 13);
     816                        }
     817                }
     818                else
     819                {
     820                        carry_set_0.CarryDequeueEnqueue(3, 13);
     821                }
     822                check_streams.misc_mask = simd.and<1>(simd.or<1>(simd.or<1>(simd.or<1>(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd.or<1>(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd.or<1>(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
     823                marker.LAngle_scope = simd.andc<1>(LAngle_scope, ctCDPI_mask);
     824                marker.Ref_opener = simd.andc<1>(lex.RefStart, ctCDPI_mask);
     825                marker.CD_closer = simd.andc<1>(CD_closer, ctCDPI_mask);
     826        }
     827       
     828};
     829 
     830kernel Parse_tags
     831{
     832        init
     833        {
     834                CarryDeclare(carry_set_0, 13, 0);       
     835        }
     836         
     837        function void do_block(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts)
     838        {
     839                var BitBlock EqExpected = simd.constant<1>(0);
     840                var BitBlock AttListEnd = simd.constant<1>(0);
     841                var BitBlock DQuoteDelim = simd.or<1>(lex.DQuote, lex.LAngle);
     842                var BitBlock SQuoteDelim = simd.or<1>(lex.SQuote, lex.LAngle);
     843                var BitBlock AttListDelim = simd.or<1>(lex.Slash, lex.RAngle);
     844                tag_Callouts.ElemName_starts = simd.andc<1>(marker.LAngle_scope, lex.Slash);
     845                tag_Callouts.EndTag_marks = simd.and<1>(marker.LAngle_scope, lex.Slash);
     846                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
     847                var BitBlock ParseError = simd.and<1>(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
     848                tag_Callouts.AttName_starts = simd.constant<1>(0);
     849                tag_Callouts.AttName_ends = simd.constant<1>(0);
     850                tag_Callouts.AttVal_starts = simd.constant<1>(0);
     851                tag_Callouts.AttVal_ends = simd.constant<1>(0);
     852                if (bitblock.any<1>(simd.or<1>(simd.and<1>(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
     853                {
     854                        var BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
     855                        AttListEnd = simd.and<1>(AfterWS, AttListDelim);
     856                        var BitBlock AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
     857                        if (bitblock.any<1>(simd.or<1>(AttNameStart, carry_set_0.CarryRange(2, 7))))
     858                        {
     859                                ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
     860                                tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
     861                                var BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
     862                                tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
     863                                if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
     864                                {
     865                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
     866                                }
     867                                else
     868                                {
     869                                        EqExpected = AttNameFollow;
     870                                        carry_set_0.CarryDequeueEnqueue(3, 1);
     871                                }
     872                                ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
     873                                var BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
     874                                tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
     875                                var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
     876                                var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
     877                                var BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.not<1>(DQuoteDelim), carry_set_0.GetCarry(5), 5);
     878                                var BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.not<1>(SQuoteDelim), carry_set_0.GetCarry(6), 6);
     879                                var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
     880                                ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
     881                                var BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
     882                                tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
     883                                if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
     884                                {
     885                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
     886                                        AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
     887                                        AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
     888                                }
     889                                else
     890                                {
     891                                        AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
     892                                        AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
     893                                        carry_set_0.CarryDequeueEnqueue(8, 1);
     894                                }
     895                                ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
     896                                while (bitblock.any<1>(AttNameStart))
     897                                {
     898                                        CarryDeclare(carry_set_1, 7, 0);
     899                                        ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
     900                                        tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
     901                                        var BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd.constant<1>(0), 0);
     902                                        tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
     903                                        if (bitblock.any<1>(simd.and<1>(AttNameFollow, lex.WS)))
     904                                        {
     905                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd.constant<1>(0), 1);
     906                                        }
     907                                        else
     908                                        {
     909                                                EqExpected = AttNameFollow;
     910                                        }
     911                                        ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
     912                                        var BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd.constant<1>(0), 2);
     913                                        tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
     914                                        var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
     915                                        var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
     916                                        var BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.not<1>(DQuoteDelim), simd.constant<1>(0), 3);
     917                                        var BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.not<1>(SQuoteDelim), simd.constant<1>(0), 4);
     918                                        var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
     919                                        ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
     920                                        var BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd.constant<1>(0), 5);
     921                                        tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
     922                                        if (bitblock.any<1>(simd.and<1>(AttValFollow, lex.WS)))
     923                                        {
     924                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd.constant<1>(0), 6);
     925                                                AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
     926                                                AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
     927                                        }
     928                                        else
     929                                        {
     930                                                AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
     931                                                AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
     932                                        }
     933                                        ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
     934                                        carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
     935                                }
     936                        }
     937                        else
     938                        {
     939                                carry_set_0.CarryDequeueEnqueue(2, 7);
     940                        }
     941                }
     942                else
     943                {
     944                        AttListEnd = simd.and<1>(tag_Callouts.ElemName_ends, AttListDelim);
     945                        ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.ElemName_ends, AttListDelim));
     946                        carry_set_0.CarryDequeueEnqueue(1, 8);
     947                }
     948                var BitBlock STagEnds = simd.and<1>(AttListEnd, lex.RAngle);
     949                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
     950                ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.EmptyTag_marks, lex.RAngle));
     951                var BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
     952                if (bitblock.any<1>(simd.or<1>(simd.and<1>(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
     953                {
     954                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
     955                }
     956                else
     957                {
     958                        carry_set_0.CarryDequeueEnqueue(11, 1);
     959                }
     960                ParseError = simd.or<1>(ParseError, simd.andc<1>(EndTagEnds, lex.RAngle));
     961                if (bitblock.any<1>(ParseError))
     962                {
     963                        assert_0_error("Tag parsing error found", ParseError);
     964                }
     965                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
     966                carry_set_0.CarryAdjust(13);
     967        }
     968       
     969        function void do_final_block(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts, BitBlock EOF_mask)
     970        {
     971                var BitBlock EqExpected = simd.constant<1>(0);
     972                var BitBlock AttListEnd = simd.constant<1>(0);
     973                var BitBlock DQuoteDelim = simd.or<1>(lex.DQuote, lex.LAngle);
     974                var BitBlock SQuoteDelim = simd.or<1>(lex.SQuote, lex.LAngle);
     975                var BitBlock AttListDelim = simd.or<1>(lex.Slash, lex.RAngle);
     976                tag_Callouts.ElemName_starts = simd.andc<1>(marker.LAngle_scope, lex.Slash);
     977                tag_Callouts.EndTag_marks = simd.and<1>(marker.LAngle_scope, lex.Slash);
     978                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
     979                var BitBlock ParseError = simd.and<1>(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
     980                tag_Callouts.AttName_starts = simd.constant<1>(0);
     981                tag_Callouts.AttName_ends = simd.constant<1>(0);
     982                tag_Callouts.AttVal_starts = simd.constant<1>(0);
     983                tag_Callouts.AttVal_ends = simd.constant<1>(0);
     984                if (bitblock.any<1>(simd.or<1>(simd.and<1>(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
     985                {
     986                        var BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
     987                        AttListEnd = simd.and<1>(AfterWS, AttListDelim);
     988                        var BitBlock AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
     989                        if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttNameStart, EOF_mask), carry_set_0.CarryRange(2, 7))))
     990                        {
     991                                ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
     992                                tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
     993                                var BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
     994                                tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
     995                                if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
     996                                {
     997                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
     998                                }
     999                                else
     1000                                {
     1001                                        EqExpected = AttNameFollow;
     1002                                        carry_set_0.CarryDequeueEnqueue(3, 1);
     1003                                }
     1004                                ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
     1005                                var BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
     1006                                tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
     1007                                var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
     1008                                var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
     1009                                var BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.andc<1>(EOF_mask, DQuoteDelim), carry_set_0.GetCarry(5), 5);
     1010                                var BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.andc<1>(EOF_mask, SQuoteDelim), carry_set_0.GetCarry(6), 6);
     1011                                var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
     1012                                ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
     1013                                var BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
     1014                                tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
     1015                                if (bitblock.any<1>(simd.or<1>(simd.and<1>(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
     1016                                {
     1017                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
     1018                                        AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
     1019                                        AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
     1020                                }
     1021                                else
     1022                                {
     1023                                        AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
     1024                                        AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
     1025                                        carry_set_0.CarryDequeueEnqueue(8, 1);
     1026                                }
     1027                                ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
     1028                                while (bitblock.any<1>(simd.and<1>(AttNameStart, EOF_mask)))
     1029                                {
     1030                                        CarryDeclare(carry_set_1, 7, 0);
     1031                                        ParseError = simd.or<1>(ParseError, simd.andc<1>(AttNameStart, lex.NameScan));
     1032                                        tag_Callouts.AttName_starts = simd.or<1>(tag_Callouts.AttName_starts, AttNameStart);
     1033                                        var BitBlock AttNameFollow = carry_set_1.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, simd.constant<1>(0), 0);
     1034                                        tag_Callouts.AttName_ends = simd.or<1>(tag_Callouts.AttName_ends, AttNameFollow);
     1035                                        if (bitblock.any<1>(simd.and<1>(AttNameFollow, lex.WS)))
     1036                                        {
     1037                                                EqExpected = carry_set_1.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, simd.constant<1>(0), 1);
     1038                                        }
     1039                                        else
     1040                                        {
     1041                                                EqExpected = AttNameFollow;
     1042                                        }
     1043                                        ParseError = simd.or<1>(ParseError, simd.andc<1>(EqExpected, lex.Equals));
     1044                                        var BitBlock AttValPos = carry_set_1.BitBlock_advance_then_scanthru(EqExpected, lex.WS, simd.constant<1>(0), 2);
     1045                                        tag_Callouts.AttVal_starts = simd.or<1>(tag_Callouts.AttVal_starts, AttValPos);
     1046                                        var BitBlock DQuoteAttVal = simd.and<1>(AttValPos, lex.DQuote);
     1047                                        var BitBlock SQuoteAttVal = simd.and<1>(AttValPos, lex.SQuote);
     1048                                        var BitBlock DQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(DQuoteAttVal, simd.andc<1>(EOF_mask, DQuoteDelim), simd.constant<1>(0), 3);
     1049                                        var BitBlock SQuoteAttEnd = carry_set_1.BitBlock_advance_then_scanthru(SQuoteAttVal, simd.andc<1>(EOF_mask, SQuoteDelim), simd.constant<1>(0), 4);
     1050                                        var BitBlock AttValEnd = simd.or<1>(DQuoteAttEnd, SQuoteAttEnd);
     1051                                        ParseError = simd.or<1>(ParseError, simd.andc<1>(simd.or<1>(AttValPos, AttValEnd), simd.or<1>(lex.DQuote, lex.SQuote)));
     1052                                        var BitBlock AttValFollow = carry_set_1.BitBlock_advance_ci_co(AttValEnd, simd.constant<1>(0), 5);
     1053                                        tag_Callouts.AttVal_ends = simd.or<1>(tag_Callouts.AttVal_ends, AttValFollow);
     1054                                        if (bitblock.any<1>(simd.and<1>(AttValFollow, lex.WS)))
     1055                                        {
     1056                                                AfterWS = carry_set_1.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, simd.constant<1>(0), 6);
     1057                                                AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AfterWS, AttListDelim));
     1058                                                AttNameStart = simd.andc<1>(AfterWS, AttListDelim);
     1059                                        }
     1060                                        else
     1061                                        {
     1062                                                AttListEnd = simd.or<1>(AttListEnd, simd.and<1>(AttValFollow, AttListDelim));
     1063                                                AttNameStart = simd.andc<1>(AttValFollow, AttListDelim);
     1064                                        }
     1065                                        ParseError = simd.or<1>(ParseError, simd.and<1>(AttValFollow, AttNameStart));
     1066                                        carry_set_0.CarryCombine(carry_set_1.cq, 2, 7);
     1067                                }
     1068                        }
     1069                        else
     1070                        {
     1071                                carry_set_0.CarryDequeueEnqueue(2, 7);
     1072                        }
     1073                }
     1074                else
     1075                {
     1076                        AttListEnd = simd.and<1>(tag_Callouts.ElemName_ends, AttListDelim);
     1077                        ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.ElemName_ends, AttListDelim));
     1078                        carry_set_0.CarryDequeueEnqueue(1, 8);
     1079                }
     1080                var BitBlock STagEnds = simd.and<1>(AttListEnd, lex.RAngle);
     1081                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd.and<1>(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
     1082                ParseError = simd.or<1>(ParseError, simd.andc<1>(tag_Callouts.EmptyTag_marks, lex.RAngle));
     1083                var BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
     1084                if (bitblock.any<1>(simd.or<1>(simd.and<1>(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
     1085                {
     1086                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
     1087                }
     1088                else
     1089                {
     1090                        carry_set_0.CarryDequeueEnqueue(11, 1);
     1091                }
     1092                ParseError = simd.or<1>(ParseError, simd.andc<1>(EndTagEnds, lex.RAngle));
     1093                if (bitblock.any<1>(ParseError))
     1094                {
     1095                        assert_0_error("Tag parsing error found", ParseError);
     1096                }
     1097                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
     1098        }
     1099       
     1100};
     1101 
     1102kernel Parse_refs
     1103{
     1104        init
     1105        {
     1106                CarryDeclare(carry_set_0, 6, 0);       
     1107        }
     1108         
     1109        function void do_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts)
     1110        {
     1111                ref_Callouts.GenRef_starts = simd.constant<1>(0);
     1112                ref_Callouts.GenRef_ends = simd.constant<1>(0);
     1113                ref_Callouts.DecRef_starts = simd.constant<1>(0);
     1114                ref_Callouts.DecRef_ends = simd.constant<1>(0);
     1115                ref_Callouts.HexRef_starts = simd.constant<1>(0);
     1116                ref_Callouts.HexRef_ends = simd.constant<1>(0);
     1117                var BitBlock ref_error = simd.constant<1>(0);
     1118                if (bitblock.any<1>(simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
     1119                {
     1120                        var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
     1121                        var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     1122                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
     1123                        var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
     1124                        var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     1125                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
     1126                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
     1127                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
     1128                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
     1129                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
     1130                        var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     1131                        var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     1132                        var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     1133                        var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     1134                        if (bitblock.any<1>(simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3)))
     1135                        {
     1136                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
     1137                        }
     1138                }
     1139                else
     1140                {
     1141                        carry_set_0.CarryDequeueEnqueue(0, 6);
     1142                }
     1143                carry_set_0.CarryAdjust(6);
     1144        }
     1145       
     1146        function void do_final_block(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts, BitBlock EOF_mask)
     1147        {
     1148                ref_Callouts.GenRef_starts = simd.constant<1>(0);
     1149                ref_Callouts.GenRef_ends = simd.constant<1>(0);
     1150                ref_Callouts.DecRef_starts = simd.constant<1>(0);
     1151                ref_Callouts.DecRef_ends = simd.constant<1>(0);
     1152                ref_Callouts.HexRef_starts = simd.constant<1>(0);
     1153                ref_Callouts.HexRef_ends = simd.constant<1>(0);
     1154                var BitBlock ref_error = simd.constant<1>(0);
     1155                if (bitblock.any<1>(simd.or<1>(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
     1156                {
     1157                        var BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
     1158                        var BitBlock NumRef2 = simd.and<1>(Ref_scope, lex.Hash);
     1159                        ref_Callouts.GenRef_starts = simd.andc<1>(Ref_scope, lex.Hash);
     1160                        var BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
     1161                        var BitBlock HexRef3 = simd.and<1>(NumRef3, lex.x);
     1162                        ref_Callouts.DecRef_starts = simd.andc<1>(NumRef3, lex.x);
     1163                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
     1164                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
     1165                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
     1166                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
     1167                        var BitBlock ref_error1 = simd.andc<1>(ref_Callouts.DecRef_starts, lex.Digit);
     1168                        var BitBlock ref_error2 = simd.andc<1>(ref_Callouts.HexRef_starts, lex.Hex);
     1169                        var BitBlock ref_ends = simd.or<1>(simd.or<1>(ref_Callouts.GenRef_ends, ref_Callouts.DecRef_ends), ref_Callouts.HexRef_ends);
     1170                        var BitBlock ref_error3 = simd.andc<1>(ref_ends, lex.Semicolon);
     1171                        if (bitblock.any<1>(simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3)))
     1172                        {
     1173                                assert_0_error("Reference error found", simd.or<1>(simd.or<1>(ref_error1, ref_error2), ref_error3));
     1174                        }
     1175                }
     1176                else
     1177                {
     1178                        carry_set_0.CarryDequeueEnqueue(0, 6);
     1179                }
     1180        }
     1181       
     1182};
     1183 
     1184kernel Validate_xml_names
     1185{
     1186        init
     1187        {
     1188                CarryDeclare(carry_set_0, 9, 0);       
     1189        }
     1190         
     1191        function void do_block(struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Lex lex, struct U8 u8, struct Check_streams check_streams)
     1192        {
     1193                var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
     1194                var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
     1195                var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
     1196                var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
     1197                var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     1198                var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     1199                var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     1200                var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
     1201                var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
     1202                var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     1203                var BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
     1204                var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
     1205                var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     1206                var BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
     1207                var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     1208                if (bitblock.any<1>(simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     1209                {
     1210                        assert_0_error("name syntax error", simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err));
     1211                }
     1212                check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
     1213                check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
     1214                carry_set_0.CarryAdjust(9);
     1215        }
     1216       
     1217        function void do_final_block(struct CtCDPI_Callouts ctCDPI_Callouts, struct Ref_Callouts ref_Callouts, struct Tag_Callouts tag_Callouts, struct Lex lex, struct U8 u8, struct Check_streams check_streams, BitBlock EOF_mask)
     1218        {
     1219                var BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
     1220                var BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
     1221                var BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
     1222                var BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
     1223                var BitBlock qname_stream = simd.or<1>(ElemNames, AttNames);
     1224                var BitBlock ncname_stream = simd.or<1>(PI_names, GenRefs);
     1225                var BitBlock name_stream = simd.or<1>(qname_stream, ncname_stream);
     1226                var BitBlock name_start = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
     1227                var BitBlock name_cursor = simd.andc<1>(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
     1228                var BitBlock void_prefix_err = simd.and<1>(name_cursor, lex.Colon);
     1229                var BitBlock namespace_sep = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
     1230                var BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
     1231                var BitBlock local_part_err = simd.andc<1>(local_part_start, lex.NameScan);
     1232                var BitBlock colon2_err = simd.and<1>(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd.andc<1>(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
     1233                var BitBlock ncname_err = simd.and<1>(ncname_stream, lex.Colon);
     1234                if (bitblock.any<1>(simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     1235                {
     1236                        assert_0_error("name syntax error", simd.or<1>(simd.or<1>(simd.or<1>(void_prefix_err, local_part_err), colon2_err), ncname_err));
     1237                }
     1238                check_streams.non_ascii_name_starts = simd.andc<1>(name_start, lex.ASCII_name_start);
     1239                check_streams.non_ascii_names = simd.andc<1>(simd.andc<1>(simd.andc<1>(name_stream, name_start), lex.ASCII_name_char), u8.suffix);
     1240        }
     1241       
     1242};
     1243 
     1244kernel Do_check_streams
     1245{
     1246        init
     1247        {
     1248                CarryDeclare(carry_set_0, 0, 0);       
     1249        }
     1250         
     1251        function void do_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams)
     1252        {
     1253                if (bitblock.any<1>(simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans)))
     1254                {
     1255                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
     1256                }
     1257                check_streams.tag_marks = simd.or<1>(simd.or<1>(simd.or<1>(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
     1258                check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
     1259                check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
     1260        }
     1261       
     1262        function void do_final_block(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams, BitBlock EOF_mask)
     1263        {
     1264                if (bitblock.any<1>(simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans)))
     1265                {
     1266                        assert_0_error("Error: ]]> in text", simd.andc<1>(marker.CD_closer, tag_Callouts.AttVal_spans));
     1267                }
     1268                check_streams.tag_marks = simd.or<1>(simd.or<1>(simd.or<1>(tag_Callouts.EmptyTag_marks, tag_Callouts.ElemName_starts), tag_Callouts.EndTag_marks), tag_Callouts.AttName_starts);
     1269                check_streams.name_follows = simd.or<1>(tag_Callouts.ElemName_ends, tag_Callouts.AttName_ends);
     1270                check_streams.att_refs = simd.and<1>(tag_Callouts.AttVal_spans, marker.Ref_opener);
     1271        }
     1272       
     1273};
  • proto/pabloj/trunk/input/test/pabloB/statements/idisa/idisa1.pablob

    r2984 r2988  
    11// KERNEL kernelName LCURLY funcDef (optFuncDef)? RCURLY TERMINATOR?;
    2        
    3 struct Basis_bits
    4 {
    5         BitBlock bit_0;
    6         BitBlock bit_1;
    7         BitBlock bit_2;
    8         BitBlock bit_3;
    9         BitBlock bit_4;
    10         BitBlock bit_5;
    11         BitBlock bit_6;
    12         BitBlock bit_7;
    13 };
    14  
    15 struct U8
    16 {
    17         BitBlock unibyte;
    18         BitBlock prefix;
    19         BitBlock prefix2;
    20         BitBlock prefix3;
    21         BitBlock prefix4;
    22         BitBlock suffix;
    23         BitBlock badprefix;
    24         BitBlock xE0;
    25         BitBlock xED;
    26         BitBlock xF0;
    27         BitBlock xF4;
    28         BitBlock xA0_xBF;
    29         BitBlock x80_x9F;
    30         BitBlock x90_xBF;
    31         BitBlock x80_x8F;
    32         BitBlock xEF;
    33         BitBlock xBF;
    34         BitBlock xBE;
    35         BitBlock scope22;
    36         BitBlock scope32;
    37         BitBlock scope33;
    38         BitBlock scope42;
    39         BitBlock scope43;
    40         BitBlock scope44;
    41         BitBlock xE0_scope;
    42         BitBlock xED_scope;
    43         BitBlock xF0_scope;
    44         BitBlock xF4_scope;
    45         BitBlock xEF_scope;
    46 };
    47  
    48 struct Lex
    49 {
    50         BitBlock CR;
    51         BitBlock LF;
    52         BitBlock HT;
    53         BitBlock SP;
    54         BitBlock CRLF;
    55         BitBlock RefStart;
    56         BitBlock Semicolon;
    57         BitBlock Colon;
    58         BitBlock LAngle;
    59         BitBlock RAngle;
    60         BitBlock LBracket;
    61         BitBlock RBracket;
    62         BitBlock Exclam;
    63         BitBlock QMark;
    64         BitBlock Hyphen;
    65         BitBlock Equals;
    66         BitBlock SQuote;
    67         BitBlock DQuote;
    68         BitBlock Slash;
    69         BitBlock Hash;
    70         BitBlock x;
    71         BitBlock ASCII_name_start;
    72         BitBlock ASCII_name_char;
    73         BitBlock NameScan;
    74         BitBlock Digit;
    75         BitBlock Hex;
    76         BitBlock WS;
    77 };
    78  
    79 struct Marker
    80 {
    81         BitBlock LAngle_scope;
    82         BitBlock Ref_opener;
    83         BitBlock CD_closer;
    84 };
    85  
    86 struct CtCDPI_Callouts
    87 {
    88         BitBlock Ct_starts;
    89         BitBlock Ct_ends;
    90         BitBlock CD_starts;
    91         BitBlock CD_ends;
    92         BitBlock PI_starts;
    93         BitBlock PI_name_starts;
    94         BitBlock PI_name_ends;
    95         BitBlock PI_ends;
    96 };
    97  
    98 struct Ref_Callouts
    99 {
    100         BitBlock GenRef_starts;
    101         BitBlock GenRef_ends;
    102         BitBlock DecRef_starts;
    103         BitBlock DecRef_ends;
    104         BitBlock HexRef_starts;
    105         BitBlock HexRef_ends;
    106 };
    107  
    108 struct Tag_Callouts
    109 {
    110         BitBlock ElemName_starts;
    111         BitBlock ElemName_ends;
    112         BitBlock AttName_starts;
    113         BitBlock AttName_ends;
    114         BitBlock AttVal_starts;
    115         BitBlock AttVal_ends;
    116         BitBlock AttVal_spans;
    117         BitBlock EmptyTag_marks;
    118         BitBlock EndTag_marks;
    119 };
    120  
    121 struct Check_streams
    122 {
    123         BitBlock misc_mask;
    124         BitBlock non_ascii_name_starts;
    125         BitBlock non_ascii_names;
    126         BitBlock tag_marks;
    127         BitBlock name_follows;
    128         BitBlock att_refs;
    129 };     
    130        
    131 kernel BasisBits
     2               
     3kernel KernelName
    1324{
    1335        init
     
    14214        }
    14315
     16        function void do_final_block()
     17        {
     18               
     19               
     20        }
     21
    14422};     
  • proto/pabloj/trunk/output/cpplang/pablo_definitions.hpp

    r2967 r2988  
    311311                        u8.badprefix = simd_or(temp68, temp71);
    312312                        u8_error = u8.badprefix;
    313                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
     313                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
    314314                        u8anyscope = u8.scope22;
    315315                        if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
     
    328328                                u8.xBF = simd_and(temp73, temp23);
    329329                                u8.xBE = simd_and(temp73, temp15);
    330                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
    331                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
    332                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
    333                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    334                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    335                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.CarryAt(6), 6);
    336                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.CarryAt(7), 7);
     330                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
     331                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
     332                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
     333                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
     334                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
     335                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
     336                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
    337337                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    338338                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    339339                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    340340                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    341                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
     341                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
    342342                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    343343                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    347347                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    348348                                u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    349                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     349                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
    350350                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    351351                        }
     
    486486                        u8.badprefix = simd_or(temp68, temp71);
    487487                        u8_error = u8.badprefix;
    488                         u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.CarryAt(0), 0);
     488                        u8.scope22 = carry_set_0.BitBlock_advance_ci_co(u8.prefix2, carry_set_0.GetCarry(0), 0);
    489489                        u8anyscope = u8.scope22;
    490490                        if (bitblock::any(simd_or(simd_or(u8.prefix3, u8.prefix4), carry_set_0.CarryRange(1, 9))))
     
    503503                                u8.xBF = simd_and(temp73, temp23);
    504504                                u8.xBE = simd_and(temp73, temp15);
    505                                 u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.CarryAt(1), 1);
    506                                 u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.CarryAt(2), 2);
    507                                 u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.CarryAt(3), 3);
    508                                 u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.CarryAt(4), 4);
    509                                 u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.CarryAt(5), 5);
    510                                 BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.CarryAt(6), 6);
    511                                 BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.CarryAt(7), 7);
     505                                u8.scope32 = carry_set_0.BitBlock_advance_ci_co(u8.prefix3, carry_set_0.GetCarry(1), 1);
     506                                u8.scope33 = carry_set_0.BitBlock_advance_ci_co(u8.scope32, carry_set_0.GetCarry(2), 2);
     507                                u8.scope42 = carry_set_0.BitBlock_advance_ci_co(u8.prefix4, carry_set_0.GetCarry(3), 3);
     508                                u8.scope43 = carry_set_0.BitBlock_advance_ci_co(u8.scope42, carry_set_0.GetCarry(4), 4);
     509                                u8.scope44 = carry_set_0.BitBlock_advance_ci_co(u8.scope43, carry_set_0.GetCarry(5), 5);
     510                                BitBlock E0_F0_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xE0, xF0), carry_set_0.GetCarry(6), 6);
     511                                BitBlock ED_F4_scope = carry_set_0.BitBlock_advance_ci_co(simd_or(xED, xF4), carry_set_0.GetCarry(7), 7);
    512512                                u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    513513                                u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    514514                                u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    515515                                u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    516                                 u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.CarryAt(8), 8);
     516                                u8.xEF_scope = carry_set_0.BitBlock_advance_ci_co(xEF, carry_set_0.GetCarry(8), 8);
    517517                                BitBlock u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    518518                                u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     
    522522                                BitBlock u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    523523                                u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    524                                 BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.CarryAt(9), 9);
     524                                BitBlock EF_BF_pending = carry_set_0.BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carry_set_0.GetCarry(9), 9);
    525525                                u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    526526                        }
     
    548548        Parse_CtCDPI()
    549549        {
    550                 carry_set_0.cq[2] = carry_set_0.CarryFlip(carry_set_0.cq[2]);
     550                carry_set_0.SetCarry(carry_set_0.CarryFlip(carry_set_0.GetCarry(2)), 2);
    551551        }
    552552         
     
    576576                if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    577577                {
    578                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.CarryAt(0), 0), lex.RBracket);
    579                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.CarryAt(1), 1), lex.RAngle);
     578                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
     579                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    580580                }
    581581                else
     
    584584                }
    585585                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    586                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.CarryAt(2), 2);
     586                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    587587                if (bitblock::any(simd_or(CtCDPI_Cursor, carry_set_0.CarryRange(3, 13))))
    588588                {
    589589                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    590590                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    591                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.CarryAt(3), 3);
     591                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    592592                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    593593                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
     
    595595                        {
    596596                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    597                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.CarryAt(4), 4);
     597                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    598598                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    599                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.CarryAt(5), 5);
     599                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    600600                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    601601                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    602                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.CarryAt(6), 6), PI_closer)));
     602                                PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    603603                                if (bitblock::any(PI_error))
    604604                                {
     
    606606                                }
    607607                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    608                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carry_set_0.CarryAt(7), 7);
     608                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_not(PI_closer), carry_set_0.GetCarry(7), 7);
    609609                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    610610                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    617617                        {
    618618                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    619                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carry_set_0.CarryAt(8), 8);
     619                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_not(CD_closer), carry_set_0.GetCarry(8), 8);
    620620                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    621621                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    628628                        {
    629629                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    630                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(9), 9);
     630                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    631631                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    632                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(10), 10), carry_set_0.CarryAt(11), 11);
    633                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carry_set_0.CarryAt(12), 12), carry_set_0.CarryAt(13), 13);
     632                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
     633                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_not(DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    634634                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    635635                                {
     
    644644                        }
    645645                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    646                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.CarryAt(14), 14);
     646                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    647647                        if (bitblock::any(simd<1>::constant<0>()))
    648648                        {
    649649                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd<1>::constant<0>());
    650650                        }
    651                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_set_0.CarryAt(15), 15);
     651                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_not(CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    652652                        while (bitblock::any(CtCDPI_Cursor))
    653653                        {
     
    711711                        carry_set_0.CarryDequeueEnqueue(3, 13);
    712712                }
    713                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.CarryAt(16), 16)), CtCDPI_starts), EOF_mask);
     713                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    714714                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    715715                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
     
    743743                if (bitblock::any(simd_or(lex.RBracket, carry_set_0.CarryRange(0, 2))))
    744744                {
    745                         BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.CarryAt(0), 0), lex.RBracket);
    746                         CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.CarryAt(1), 1), lex.RAngle);
     745                        BitBlock DoubleRBracket = simd_and(carry_set_0.BitBlock_advance_ci_co(lex.RBracket, carry_set_0.GetCarry(0), 0), lex.RBracket);
     746                        CD_closer = simd_and(carry_set_0.BitBlock_advance_ci_co(DoubleRBracket, carry_set_0.GetCarry(1), 1), lex.RAngle);
    747747                }
    748748                else
     
    751751                }
    752752                BitBlock PI_closer = simd_and(simd_andc(w1, v1), lex.RAngle);
    753                 BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.CarryAt(2), 2);
     753                BitBlock CtCDPI_Cursor = carry_set_0.BitBlock_scantofirst(CtCDPI_opener, carry_set_0.GetCarry(2), 2);
    754754                if (bitblock::any(simd_or(simd_and(CtCDPI_Cursor, EOF_mask), carry_set_0.CarryRange(3, 13))))
    755755                {
    756756                        CtCDPI_starts = simd_or(CtCDPI_starts, CtCDPI_Cursor);
    757757                        BitBlock PI_Cursor = simd_and(CtCDPI_Cursor, PI_opener);
    758                         BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.CarryAt(3), 3);
     758                        BitBlock CD_Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(simd_andc(CtCDPI_Cursor, PI_Cursor), carry_set_0.GetCarry(3), 3);
    759759                        BitBlock CD_Cursor = simd_and(CD_Ct_Cursor, lex.LBracket);
    760760                        BitBlock Ct_Cursor = simd_and(CD_Ct_Cursor, lex.Hyphen);
     
    762762                        {
    763763                                ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts, PI_Cursor);
    764                                 PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.CarryAt(4), 4);
     764                                PI_Cursor = carry_set_0.BitBlock_advance_ci_co(PI_Cursor, carry_set_0.GetCarry(4), 4);
    765765                                ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts, PI_Cursor);
    766                                 BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.CarryAt(5), 5);
     766                                BitBlock PI_name_end = carry_set_0.BitBlock_scanthru_ci_co(PI_Cursor, lex.NameScan, carry_set_0.GetCarry(5), 5);
    767767                                BitBlock PI_error = simd_and(PI_Cursor, PI_name_end);
    768768                                BitBlock PI_noWS = simd_andc(PI_name_end, lex.WS);
    769                                 PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.CarryAt(6), 6), PI_closer)));
     769                                PI_error = simd_or(PI_error, simd_or(simd_andc(PI_noWS, lex.QMark), simd_andc(carry_set_0.BitBlock_advance_ci_co(PI_noWS, carry_set_0.GetCarry(6), 6), PI_closer)));
    770770                                if (bitblock::any(PI_error))
    771771                                {
     
    773773                                }
    774774                                ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends, PI_name_end);
    775                                 PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_set_0.CarryAt(7), 7);
     775                                PI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(PI_name_end, simd_andc(EOF_mask, PI_closer), carry_set_0.GetCarry(7), 7);
    776776                                ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends, PI_Cursor);
    777777                                CtCDPI_ends = simd_or(CtCDPI_ends, PI_Cursor);
     
    784784                        {
    785785                                ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts, CD_Cursor);
    786                                 CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_set_0.CarryAt(8), 8);
     786                                CD_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CD_Cursor, simd_andc(EOF_mask, CD_closer), carry_set_0.GetCarry(8), 8);
    787787                                ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends, CD_Cursor);
    788788                                CtCDPI_ends = simd_or(CtCDPI_ends, CD_Cursor);
     
    795795                        {
    796796                                ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts, Ct_Cursor);
    797                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(9), 9);
     797                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(9), 9);
    798798                                BitBlock Ct_error = simd_andc(Ct_Cursor, lex.Hyphen);
    799                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.CarryAt(10), 10), carry_set_0.CarryAt(11), 11);
    800                                 Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_set_0.CarryAt(12), 12), carry_set_0.CarryAt(13), 13);
     799                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_advance_ci_co(Ct_Cursor, carry_set_0.GetCarry(10), 10), carry_set_0.GetCarry(11), 11);
     800                                Ct_Cursor = carry_set_0.BitBlock_advance_ci_co(carry_set_0.BitBlock_scanthru_ci_co(Ct_Cursor, simd_andc(EOF_mask, DoubleHyphen), carry_set_0.GetCarry(12), 12), carry_set_0.GetCarry(13), 13);
    801801                                if (bitblock::any(simd_or(Ct_error, simd_andc(Ct_Cursor, lex.RAngle))))
    802802                                {
     
    811811                        }
    812812                        CtCDPI_Cursor = simd_or(simd_or(PI_Cursor, CD_Cursor), Ct_Cursor);
    813                         ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.CarryAt(14), 14);
     813                        ctCDPI_mask = carry_set_0.BitBlock_inclusive_span(CtCDPI_starts, CtCDPI_ends, carry_set_0.GetCarry(14), 14);
    814814                        if (bitblock::any(simd_andc(ctCDPI_mask, EOF_mask)))
    815815                        {
    816816                                assert_0_error("Error in comment, CDATA or processing instruction syntax", simd_andc(ctCDPI_mask, EOF_mask));
    817817                        }
    818                         CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_set_0.CarryAt(15), 15);
     818                        CtCDPI_Cursor = carry_set_0.BitBlock_scanthru_ci_co(CtCDPI_Cursor, simd_andc(EOF_mask, CtCDPI_opener), carry_set_0.GetCarry(15), 15);
    819819                        while (bitblock::any(simd_and(CtCDPI_Cursor, EOF_mask)))
    820820                        {
     
    878878                        carry_set_0.CarryDequeueEnqueue(3, 13);
    879879                }
    880                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.CarryAt(16), 16)), CtCDPI_starts), EOF_mask);
     880                check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS, lex.LAngle), carry_set_0.BitBlock_inclusive_span(simd_or(ctCDPI_Callouts.Ct_starts, ctCDPI_Callouts.PI_starts), simd_or(ctCDPI_Callouts.Ct_ends, ctCDPI_Callouts.PI_ends), carry_set_0.GetCarry(16), 16)), CtCDPI_starts), EOF_mask);
    881881                marker.LAngle_scope = simd_andc(LAngle_scope, ctCDPI_mask);
    882882                marker.Ref_opener = simd_andc(lex.RefStart, ctCDPI_mask);
     
    903903                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    904904                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    905                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.CarryAt(0), 0);
     905                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    906906                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    907907                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    911911                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    912912                {
    913                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.CarryAt(1), 1);
     913                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    914914                        AttListEnd = simd_and(AfterWS, AttListDelim);
    915915                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    918918                                ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    919919                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    920                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.CarryAt(2), 2);
     920                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    921921                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    922922                                if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    923923                                {
    924                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.CarryAt(3), 3);
     924                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    925925                                }
    926926                                else
     
    930930                                }
    931931                                ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    932                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.CarryAt(4), 4);
     932                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    933933                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    934934                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    935935                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    936                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carry_set_0.CarryAt(5), 5);
    937                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carry_set_0.CarryAt(6), 6);
     936                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_not(DQuoteDelim), carry_set_0.GetCarry(5), 5);
     937                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_not(SQuoteDelim), carry_set_0.GetCarry(6), 6);
    938938                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    939939                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    940                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.CarryAt(7), 7);
     940                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    941941                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    942942                                if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    943943                                {
    944                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.CarryAt(8), 8);
     944                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    945945                                        AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    946946                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    10061006                }
    10071007                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1008                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.CarryAt(9), 9);
     1008                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    10091009                ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1010                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.CarryAt(10), 10);
     1010                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    10111011                if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    10121012                {
    1013                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.CarryAt(11), 11);
     1013                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    10141014                }
    10151015                else
     
    10221022                        assert_0_error("Tag parsing error found", ParseError);
    10231023                }
    1024                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.CarryAt(12), 12);
     1024                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    10251025                carry_set_0.CarryAdjust(13);
    10261026        }
     
    10351035                tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope, lex.Slash);
    10361036                tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope, lex.Slash);
    1037                 tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.CarryAt(0), 0);
     1037                tag_Callouts.ElemName_ends = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_starts, lex.NameScan, carry_set_0.GetCarry(0), 0);
    10381038                BitBlock ParseError = simd_and(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends);
    10391039                tag_Callouts.AttName_starts = simd<1>::constant<0>();
     
    10431043                if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends, lex.WS), carry_set_0.CarryRange(1, 8))))
    10441044                {
    1045                         BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.CarryAt(1), 1);
     1045                        BitBlock AfterWS = carry_set_0.BitBlock_scanthru_ci_co(tag_Callouts.ElemName_ends, lex.WS, carry_set_0.GetCarry(1), 1);
    10461046                        AttListEnd = simd_and(AfterWS, AttListDelim);
    10471047                        BitBlock AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    10501050                                ParseError = simd_or(ParseError, simd_andc(AttNameStart, lex.NameScan));
    10511051                                tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts, AttNameStart);
    1052                                 BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.CarryAt(2), 2);
     1052                                BitBlock AttNameFollow = carry_set_0.BitBlock_scanthru_ci_co(AttNameStart, lex.NameScan, carry_set_0.GetCarry(2), 2);
    10531053                                tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends, AttNameFollow);
    10541054                                if (bitblock::any(simd_or(simd_and(AttNameFollow, lex.WS), carry_set_0.CarryRange(3, 1))))
    10551055                                {
    1056                                         EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.CarryAt(3), 3);
     1056                                        EqExpected = carry_set_0.BitBlock_scanthru_ci_co(AttNameFollow, lex.WS, carry_set_0.GetCarry(3), 3);
    10571057                                }
    10581058                                else
     
    10621062                                }
    10631063                                ParseError = simd_or(ParseError, simd_andc(EqExpected, lex.Equals));
    1064                                 BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.CarryAt(4), 4);
     1064                                BitBlock AttValPos = carry_set_0.BitBlock_advance_then_scanthru(EqExpected, lex.WS, carry_set_0.GetCarry(4), 4);
    10651065                                tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts, AttValPos);
    10661066                                BitBlock DQuoteAttVal = simd_and(AttValPos, lex.DQuote);
    10671067                                BitBlock SQuoteAttVal = simd_and(AttValPos, lex.SQuote);
    1068                                 BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_set_0.CarryAt(5), 5);
    1069                                 BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_set_0.CarryAt(6), 6);
     1068                                BitBlock DQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(DQuoteAttVal, simd_andc(EOF_mask, DQuoteDelim), carry_set_0.GetCarry(5), 5);
     1069                                BitBlock SQuoteAttEnd = carry_set_0.BitBlock_advance_then_scanthru(SQuoteAttVal, simd_andc(EOF_mask, SQuoteDelim), carry_set_0.GetCarry(6), 6);
    10701070                                BitBlock AttValEnd = simd_or(DQuoteAttEnd, SQuoteAttEnd);
    10711071                                ParseError = simd_or(ParseError, simd_andc(simd_or(AttValPos, AttValEnd), simd_or(lex.DQuote, lex.SQuote)));
    1072                                 BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.CarryAt(7), 7);
     1072                                BitBlock AttValFollow = carry_set_0.BitBlock_advance_ci_co(AttValEnd, carry_set_0.GetCarry(7), 7);
    10731073                                tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends, AttValFollow);
    10741074                                if (bitblock::any(simd_or(simd_and(AttValFollow, lex.WS), carry_set_0.CarryRange(8, 1))))
    10751075                                {
    1076                                         AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.CarryAt(8), 8);
     1076                                        AfterWS = carry_set_0.BitBlock_scanthru_ci_co(AttValFollow, lex.WS, carry_set_0.GetCarry(8), 8);
    10771077                                        AttListEnd = simd_or(AttListEnd, simd_and(AfterWS, AttListDelim));
    10781078                                        AttNameStart = simd_andc(AfterWS, AttListDelim);
     
    11381138                }
    11391139                BitBlock STagEnds = simd_and(AttListEnd, lex.RAngle);
    1140                 tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.CarryAt(9), 9);
     1140                tag_Callouts.EmptyTag_marks = carry_set_0.BitBlock_advance_ci_co(simd_and(AttListEnd, lex.Slash), carry_set_0.GetCarry(9), 9);
    11411141                ParseError = simd_or(ParseError, simd_andc(tag_Callouts.EmptyTag_marks, lex.RAngle));
    1142                 BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.CarryAt(10), 10);
     1142                BitBlock EndTagEnds = carry_set_0.BitBlock_advance_then_scanthru(tag_Callouts.EndTag_marks, lex.NameScan, carry_set_0.GetCarry(10), 10);
    11431143                if (bitblock::any(simd_or(simd_and(EndTagEnds, lex.WS), carry_set_0.CarryRange(11, 1))))
    11441144                {
    1145                         EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.CarryAt(11), 11);
     1145                        EndTagEnds = carry_set_0.BitBlock_scanthru_ci_co(EndTagEnds, lex.WS, carry_set_0.GetCarry(11), 11);
    11461146                }
    11471147                else
     
    11541154                        assert_0_error("Tag parsing error found", ParseError);
    11551155                }
    1156                 tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.CarryAt(12), 12);
     1156                tag_Callouts.AttVal_spans = carry_set_0.BitBlock_span_upto(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends, carry_set_0.GetCarry(12), 12);
    11571157        }
    11581158       
     
    11781178                if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    11791179                {
    1180                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     1180                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
    11811181                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    11821182                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1183                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     1183                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
    11841184                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    11851185                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1186                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
    1187                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
    1188                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    1189                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
     1186                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
     1187                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
     1188                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
     1189                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
    11901190                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    11911191                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
     
    12151215                if (bitblock::any(simd_or(marker.Ref_opener, carry_set_0.CarryRange(0, 6))))
    12161216                {
    1217                         BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.CarryAt(0), 0);
     1217                        BitBlock Ref_scope = carry_set_0.BitBlock_advance_ci_co(marker.Ref_opener, carry_set_0.GetCarry(0), 0);
    12181218                        BitBlock NumRef2 = simd_and(Ref_scope, lex.Hash);
    12191219                        ref_Callouts.GenRef_starts = simd_andc(Ref_scope, lex.Hash);
    1220                         BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.CarryAt(1), 1);
     1220                        BitBlock NumRef3 = carry_set_0.BitBlock_advance_ci_co(NumRef2, carry_set_0.GetCarry(1), 1);
    12211221                        BitBlock HexRef3 = simd_and(NumRef3, lex.x);
    12221222                        ref_Callouts.DecRef_starts = simd_andc(NumRef3, lex.x);
    1223                         ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.CarryAt(2), 2);
    1224                         ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.CarryAt(3), 3);
    1225                         ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.CarryAt(4), 4);
    1226                         ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.CarryAt(5), 5);
     1223                        ref_Callouts.HexRef_starts = carry_set_0.BitBlock_advance_ci_co(HexRef3, carry_set_0.GetCarry(2), 2);
     1224                        ref_Callouts.GenRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.GenRef_starts, lex.NameScan, carry_set_0.GetCarry(3), 3);
     1225                        ref_Callouts.DecRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.DecRef_starts, lex.Digit, carry_set_0.GetCarry(4), 4);
     1226                        ref_Callouts.HexRef_ends = carry_set_0.BitBlock_scanthru_ci_co(ref_Callouts.HexRef_starts, lex.Hex, carry_set_0.GetCarry(5), 5);
    12271227                        BitBlock ref_error1 = simd_andc(ref_Callouts.DecRef_starts, lex.Digit);
    12281228                        BitBlock ref_error2 = simd_andc(ref_Callouts.HexRef_starts, lex.Hex);
     
    12521252        IDISA_INLINE void do_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams)
    12531253        {
    1254                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
    1255                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    1256                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    1257                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     1254                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
     1255                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
     1256                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
     1257                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
    12581258                BitBlock qname_stream = simd_or(ElemNames, AttNames);
    12591259                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    12601260                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1261                 BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    1262                 BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     1261                BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
     1262                BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
    12631263                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1264                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
    1265                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     1264                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
     1265                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
    12661266                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1267                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     1267                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
    12681268                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    12691269                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
     
    12781278        void do_final_block(struct CtCDPI_Callouts & ctCDPI_Callouts, struct Ref_Callouts & ref_Callouts, struct Tag_Callouts & tag_Callouts, struct Lex & lex, struct U8 & u8, struct Check_streams & check_streams, BitBlock & EOF_mask)
    12791279        {
    1280                 BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.CarryAt(0), 0);
    1281                 BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.CarryAt(1), 1);
    1282                 BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.CarryAt(2), 2);
    1283                 BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.CarryAt(3), 3);
     1280                BitBlock PI_names = carry_set_0.BitBlock_span_upto(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends, carry_set_0.GetCarry(0), 0);
     1281                BitBlock GenRefs = carry_set_0.BitBlock_span_upto(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends, carry_set_0.GetCarry(1), 1);
     1282                BitBlock ElemNames = carry_set_0.BitBlock_span_upto(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends, carry_set_0.GetCarry(2), 2);
     1283                BitBlock AttNames = carry_set_0.BitBlock_span_upto(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends, carry_set_0.GetCarry(3), 3);
    12841284                BitBlock qname_stream = simd_or(ElemNames, AttNames);
    12851285                BitBlock ncname_stream = simd_or(PI_names, GenRefs);
    12861286                BitBlock name_stream = simd_or(qname_stream, ncname_stream);
    1287                 BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(4), 4));
    1288                 BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.CarryAt(5), 5));
     1287                BitBlock name_start = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(4), 4));
     1288                BitBlock name_cursor = simd_andc(name_stream, carry_set_0.BitBlock_advance_ci_co(name_stream, carry_set_0.GetCarry(5), 5));
    12891289                BitBlock void_prefix_err = simd_and(name_cursor, lex.Colon);
    1290                 BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(6), 6), lex.Colon);
    1291                 BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.CarryAt(7), 7);
     1290                BitBlock namespace_sep = simd_and(carry_set_0.BitBlock_scanthru_ci_co(name_cursor, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(6), 6), lex.Colon);
     1291                BitBlock local_part_start = carry_set_0.BitBlock_advance_ci_co(namespace_sep, carry_set_0.GetCarry(7), 7);
    12921292                BitBlock local_part_err = simd_andc(local_part_start, lex.NameScan);
    1293                 BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.CarryAt(8), 8), lex.Colon);
     1293                BitBlock colon2_err = simd_and(carry_set_0.BitBlock_scanthru_ci_co(local_part_start, simd_andc(lex.NameScan, lex.Colon), carry_set_0.GetCarry(8), 8), lex.Colon);
    12941294                BitBlock ncname_err = simd_and(ncname_stream, lex.Colon);
    12951295                if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err, local_part_err), colon2_err), ncname_err)))
  • proto/pabloj/trunk/runConfigurations/PabloBAST.launch

    r2984 r2988  
    88</listAttribute>
    99<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="test.pabloB.PabloBAST"/>
    10 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloB/all/all.pablob"/>
     10<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="${workspace_loc}/pabloj/input/test/pabloB/proto/parabix2_pablo.pablob"/>
    1111<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1212</launchConfiguration>
  • proto/pabloj/trunk/runConfigurations/pabloJ.launch

    r2918 r2988  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="applicationGenerator.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${project_loc}/input/test/pabloS/py2pablo/parabix2_pablo.pablos"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-i ${project_loc}/input/test/pabloS/proto/parabix2_pablo.pablos"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pabloj/trunk/src/compilers/pabloB/lang/carrySet/CarrySetBuiltins.java

    r2963 r2988  
    1313        CARRYDECLARE(3),               
    1414        CARRYRANGE(2),
    15         CARRYAT(1),
     15        GETCARRY(1),
     16        SETCARRY(2),
    1617        PENDING64(1),
    1718        CARRYCOMBINE(3),
  • proto/pabloj/trunk/src/compilers/pabloB/lang/carrySet/CarrySetBuiltins2CPP.java

    r2971 r2988  
    1919        carry2CPPCode.put(CarrySetBuiltins.CARRYDECLARE, "CarryDeclare");
    2020        carry2CPPCode.put(CarrySetBuiltins.CARRYRANGE,"CarryRange");
    21         carry2CPPCode.put(CarrySetBuiltins.CARRYAT,"CarryAt");
     21        carry2CPPCode.put(CarrySetBuiltins.GETCARRY,"GetCarry");
     22        carry2CPPCode.put(CarrySetBuiltins.SETCARRY,"SetCarry");
    2223        carry2CPPCode.put(CarrySetBuiltins.PENDING64,"Pending64");
    2324        carry2CPPCode.put(CarrySetBuiltins.CARRYCOMBINE,"CarryCombine");
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/CarryIntroXFormer.java

    r2977 r2988  
    248248                                carryAtCallOrConstant = Generators.makeFuncCallNode(
    249249                                                new String [] {getCarrySetIdentifier(),
    250                                                                 carrySet2Lang.getCode(CarrySetBuiltins.CARRYAT)},
     250                                                                carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
    251251                                                node.getToken(),
    252252                                                currentCarry);
  • proto/pabloj/trunk/src/compilers/pabloS/semanticAnalyzer/visitors/PabloS2PabloBXFormer.java

    r2984 r2988  
    115115                                       
    116116                                        if(carry1Array[i] > 0) {
     117                                                       
     118                                                        pabloB.ast.IntegerConstantNode indexNode = Generators.makeIntegerConstantNode(i, locationToken);
    117119                                               
    118                                                         String carryFlipArrayExpr = String.format(CarrySetBuiltins2Lang.CARRYQARRAYNAME + "[%s]",
    119                                                                                                                                                 Integer.toString(i));   
    120                                                        
    121                                                         String[] carryFlipIdentiferArray = new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
    122                                                                                                                                                                 carryFlipArrayExpr};
    123                                                        
    124                                                         pabloB.ast.CompoundIdentifierNode carryFlipIdentifierNode
    125                                                                         = Generators.makeCompoundIdentifierNode(carryFlipIdentiferArray,
    126                                                                                                                                                         locationToken);
    127                                                        
     120                                                        FuncCallNode getCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     121                                                                new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
     122                                                                                                carrySet2Lang.getCode(CarrySetBuiltins.GETCARRY)},
     123                                                                                                locationToken,
     124                                                                                                new ASTNode [] {indexNode});
     125                                               
    128126                                                        FuncCallNode carryFlipFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
    129127                                                                        new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
    130128                                                                                                        carrySet2Lang.getCode(CarrySetBuiltins.CARRYFLIP)},
    131129                                                                                                        locationToken,
    132                                                                                                         new ASTNode [] {carryFlipIdentifierNode});
     130                                                                                                        new ASTNode [] {getCarryFuncCall});
    133131                                                       
    134                                                         AssignNode assignNode = Generators.makeAssignEqualNode(carryFlipIdentiferArray,
    135                                                                         carryFlipFuncCall,
    136                                                                         locationToken);
     132                                                        FuncCallNode setCarryFuncCall = (FuncCallNode) Generators.makeFuncCallNode(
     133                                                                        new String [] {CarrySetBuiltins2Lang.CARRYSETBASENAME,
     134                                                                                                        carrySet2Lang.getCode(CarrySetBuiltins.SETCARRY)},
     135                                                                                                        locationToken,
     136                                                                                                        new ASTNode [] {carryFlipFuncCall, indexNode});
    137137                                                                                                       
    138                                                         compilers.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(assignNode);
     138                                                        compilers.pabloB.ast.Accessors.initBlockNode(initDefNode).appendChild(setCarryFuncCall);
    139139                                                       
    140140                                        }
  • proto/pabloj/trunk/src/pabloB/parser/Parser.java

    r2984 r2988  
    117117                        allChildren.add(child);
    118118                }
    119                 if( nowReading.isLextant(Lextant.FUNCTION) ) {
     119                while( nowReading.isLextant(Lextant.FUNCTION) ) {
    120120                        {
    121121                                ASTNode child = parseOptFuncDef();
     
    123123                                allChildren.add(child);
    124124                        }
    125                 }
    126                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    127                         {
    128                                 ASTNode child = parseCompoundIdentifier();
    129                                 result.appendChild(child);
    130                                 allChildren.add(child);
    131                         }
    132                         {
    133                                 ASTNode child = parseFuncCallRest();
    134                                 result.appendChild(child);
    135                                 allChildren.add(child);
    136                         }
    137                         result = promoteLastChild(result);
    138                         allowCompression = false;
    139125                }
    140126                expect(Lextant.RCURLY);
     
    202188                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    203189                expect(Lextant.LCURLY);
    204                 while( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
    205                         {
    206                                 ASTNode child = parseStateInitStmt();
     190                while( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
     191                        {
     192                                ASTNode child = parseFuncCallOrAssignStmt();
    207193                                result.appendChild(child);
    208194                                allChildren.add(child);
     
    538524         
    539525        public ASTNode parseStmt() {
    540                 if( !(nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    541                         return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, RETURN¹, VAR¹, WHILE¹]");
     526                if( !(nowReading.isLextant(Lextant.IF, Lextant.LROUND, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     527                        return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, INTEGER_CONST¹, LROUND¹, RETURN¹, SQ_STRING¹, STRING¹, VAR¹, WHILE¹]");
    542528                }
    543529       
     
    546532                result.setProductionTag(20);
    547533                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    548                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     534                if( nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    549535                        {
    550536                                ASTNode child = parseFuncCallOrAssignStmt();
     
    591577         
    592578        public ASTNode parseFuncCallOrAssignStmt() {
    593                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    594                         return syntaxErrorNode("funcCallOrAssignStmt² [IDENTIFIER¹]");
     579                if( !(nowReading.isLextant(Lextant.LROUND) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     580                        return syntaxErrorNode("funcCallOrAssignStmt² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, SQ_STRING¹, STRING¹]");
    595581                }
    596582       
     
    600586                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    601587                {
    602                         ASTNode child = parseCompoundIdentifier();
     588                        ASTNode child = parseExpr();
    603589                        result.appendChild(child);
    604590                        allChildren.add(child);
     
    633619                expect(Lextant.TERMINATOR);
    634620                if(allowCompression) {
    635                         return result;
     621                        return compressIfPossible(result);
    636622                }
    637623                return result;
     
    942928                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    943929                expect(Lextant.LCURLY);
    944                 while( nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     930                while( nowReading.isLextant(Lextant.IF, Lextant.LROUND, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    945931                        {
    946932                                ASTNode child = parseStmt();
  • proto/pabloj/trunk/src/pabloS/applications/SampleApplication.java

    r2984 r2988  
    66
    77package  pabloS.applications;
    8 
    9 import java.io.File;
    108
    119public class SampleApplication {
     
    1816                super();
    1917        }
     18       
    2019       
    2120        protected static void checkArguments(String[] args, String applicationName) {
     
    4645                }
    4746        }
    48        
    49         protected static boolean makeDirectoryIfNecessary(String directoryName) {
    50                 return directoryExists(directoryName) || createDirectory(directoryName);
    51         }
    52         protected static boolean fileExists(String filePath) {
    53                 return (new File(filePath)).exists();
    54         }
    55         protected static boolean directoryExists(String filePath) {
    56                 return fileExists(filePath) && (new File(filePath)).isDirectory();
    57         }
    58         protected static boolean createDirectory(String filePath) {
    59                 return (new File(filePath)).mkdirs();
    60         }
    61 
    62 
    63         protected static void printUsageMessage(String applicationName, String errorMessage) {
    64                 System.err.println("usage: " + applicationName + " filename" + " [target output directory]");
    65                 System.err.println(errorMessage);
    66                 System.exit(EXIT_CODE_FOR_ERROR);
    67         }       
    68        
    6947        private static void exitWithUsageMessage(String applicationName) {
    7048                System.err.println("usage: " + applicationName + " filename [-o outputDirectory]");
  • proto/pabloj/trunk/src/pabloS/parser/Parser.java

    r2984 r2988  
    248248         
    249249        public ASTNode parseStmt() {
    250                 if( !(nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    251                         return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, RETURN¹, VAR¹, WHILE¹]");
     250                if( !(nowReading.isLextant(Lextant.IF, Lextant.LROUND, Lextant.NOT, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     251                        return syntaxErrorNode("stmt² [IDENTIFIER¹, IF¹, INTEGER_CONST¹, LROUND¹, NOT¹, RETURN¹, SQ_STRING¹, STRING¹, VAR¹, WHILE¹]");
    252252                }
    253253       
     
    256256                result.setProductionTag(9);
    257257                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    258                 if( (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     258                if( nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    259259                        {
    260260                                ASTNode child = parseFuncCallOrAssignStmt();
     
    301301         
    302302        public ASTNode parseFuncCallOrAssignStmt() {
    303                 if( !((nowReading.isLexicalType(LexicalType.IDENTIFIER))) ) {
    304                         return syntaxErrorNode("funcCallOrAssignStmt² [IDENTIFIER¹]");
     303                if( !(nowReading.isLextant(Lextant.LROUND, Lextant.NOT) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING))) ) {
     304                        return syntaxErrorNode("funcCallOrAssignStmt² [IDENTIFIER¹, INTEGER_CONST¹, LROUND¹, NOT¹, SQ_STRING¹, STRING¹]");
    305305                }
    306306       
     
    310310                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    311311                {
    312                         ASTNode child = parseCompoundIdentifier();
     312                        ASTNode child = parseExpr();
    313313                        result.appendChild(child);
    314314                        allChildren.add(child);
     
    614614                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    615615                expect(Lextant.LCURLY);
    616                 while( nowReading.isLextant(Lextant.IF, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) ) {
     616                while( nowReading.isLextant(Lextant.IF, Lextant.LROUND, Lextant.NOT, Lextant.RETURN, Lextant.VAR, Lextant.WHILE) || (nowReading.isLexicalType(LexicalType.IDENTIFIER)) || (nowReading.isLexicalType(LexicalType.INTEGER_CONST)) || (nowReading.isLexicalType(LexicalType.SQ_STRING)) || (nowReading.isLexicalType(LexicalType.STRING)) ) {
    617617                        {
    618618                                ASTNode child = parseStmt();
Note: See TracChangeset for help on using the changeset viewer.