Changeset 3134 for proto/pabloj


Ignore:
Timestamp:
May 13, 2013, 2:14:46 PM (6 years ago)
Author:
shermer
Message:

Changes to hopefully bring into compatibility with trunk, rev. 3127.

Location:
proto/pabloj/branches/refactor-experimental
Files:
6 added
12 edited

Legend:

Unmodified
Added
Removed
  • proto/pabloj/branches/refactor-experimental/.settings/org.eclipse.ltk.core.refactoring.prefs

    r3117 r3134  
    1 #Mon May 06 13:35:16 PDT 2013
    21eclipse.preferences.version=1
    32org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false
  • proto/pabloj/branches/refactor-experimental/input/grammar/scatter/pabloS.scatter

    r3115 r3134  
    120120        stmt                                    #-> (funcCallOrAssignStmt | ifStmt | whileStmt | returnStmt | localVarDecl) (TERMINATOR)? ;
    121121                       
    122         funcCallOrAssignStmt    #-> expr ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
     122//      funcCallOrAssignStmt    #-> expr ((funcCallRest _promote_) | (assignRest _promote_)) TERMINATOR  ; // | (idisaCallRest _promote_)
     123       
     124        funcCallOrAssignStmt    # -> expr (assignRest _promote_)? TERMINATOR ;
    123125       
    124126        funcCallRest                    -> LROUND^ funcCallArgList RROUND ;
  • proto/pabloj/branches/refactor-experimental/output/cpplang/pablo_definitions.hpp

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

    r3029 r3134  
    99</listAttribute>
    1010<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="application.PabloJ"/>
    11 <stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-b ${project_loc}/input/test/pabloB/test.pablob -t idisa_definitions.template"/>
     11<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="-x clang -b ${project_loc}/input/test/pabloB/test.pablob -t idisa_definitions.template"/>
    1212<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="pabloj"/>
    1313<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-ea"/>
  • proto/pabloj/branches/refactor-experimental/src/application/config/ConfigurationFactory.java

    r2998 r3134  
    3434       
    3535        if (configuration.targetLang.equals(Configuration.CLANG)) { // C language
     36                System.out.println("I'm using clang");
    3637                configuration.templateFileName = cli.getOptionValue("t", "pablo_definitions.template");
    3738                configuration.templateDirectory = FileUtil.ensureEndsWith(cli.getOptionValue("T", Configuration.TEMPLATES_DIRECTORY + Configuration.CLANG), File.separator);
    3839                configuration.outputFileName = cli.getOptionValue("o", FileUtil.replaceFileNameExtension(new File(configuration.templateFileName).getName(), ".h"));
    3940               
    40                 //compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.CLANG);
    41                
    42         } else { // C++ language - default
     41                //compilerConfig.outputDirectory = cli.getOptionValue("O", CompilerConfig.CLANG);                       
     42               
     43        } else { // C++ language - default
     44                System.out.println("I'm using cpplang");
    4345                configuration.templateFileName = cli.getOptionValue("t", "pablo_definitions.template");
    4446                configuration.templateDirectory = FileUtil.ensureEndsWith(cli.getOptionValue("T", Configuration.TEMPLATES_DIRECTORY + Configuration.CPPLANG), File.separator);
  • proto/pabloj/branches/refactor-experimental/src/application/config/ConfigurationOptions.java

    r2998 r3134  
    8585                        options.addOption(option);                     
    8686
    87                     OptionBuilder.hasArg(false);
     87                    OptionBuilder.hasArg(true);
    8888                    OptionBuilder.isRequired(false);
    8989                    OptionBuilder.withLongOpt("language");
  • proto/pabloj/branches/refactor-experimental/src/pabloS/parser/Parser.java

    r3115 r3134  
    320320                        allChildren.add(child);
    321321                }
    322                 if( nowReading.isLextant(Lextant.LROUND) ) {
    323                         {
    324                                 ASTNode child = parseFuncCallRest();
     322                if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
     323                        {
     324                                ASTNode child = parseAssignRest();
    325325                                result.appendChild(child);
    326326                                allChildren.add(child);
     
    328328                        result = promoteLastChild(result);
    329329                        allowCompression = false;
    330                 }
    331                 else if( nowReading.isLextant(Lextant.AND_ASSIGN, Lextant.ASSIGN, Lextant.OR_ASSIGN, Lextant.XOR_ASSIGN) ) {
    332                         {
    333                                 ASTNode child = parseAssignRest();
    334                                 result.appendChild(child);
    335                                 allChildren.add(child);
    336                         }
    337                         result = promoteLastChild(result);
    338                         allowCompression = false;
    339                 }
    340                 else {
    341                         return syntaxErrorNode("[AND_ASSIGN¹, ASSIGN¹, LROUND¹, OR_ASSIGN¹, XOR_ASSIGN¹]");
    342330                }
    343331                expect(Lextant.TERMINATOR);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/codeGenerator/idisa/AbstractIDISABuiltin2Lang.java

    r3032 r3134  
    2626package toolchain.pabloB.codeGenerator.idisa;
    2727
     28import java.util.ArrayList;
     29
     30import toolchain.pabloB.codeGenerator.helpers.UnparserUtil;
     31
    2832public abstract class AbstractIDISABuiltin2Lang {
     33       
     34        protected String _firstArg;     
     35       
     36        protected String getArgCsv(String[] arguments, int start) {
     37                ArrayList<String> argList = new ArrayList<String>();
     38                for (String arg: arguments)
     39                {
     40                        for (String parts: arg.split(","))
     41                        {
     42                                argList.add(parts.trim());
     43                        }
     44                }
     45                _firstArg = argList.get(0);
     46               
     47                String csv = UnparserUtil.makeDelimitedList(argList.subList(start, argList.size()), ", ");
     48                return csv;
     49        }
     50       
     51        protected String getArgCsv(String[] arguments)
     52        {
     53                return getArgCsv(arguments, 0);
     54        }       
     55       
    2956        public abstract String makeIDISAFunctionCall0(String operationBaseName, String operationClassName, String fieldWidth, String ...arguments);
    3057        public abstract String makeIDISAFunctionCall1(String operationBaseName, String operationClassName, String fieldWidth, String ...arguments);
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/codeGenerator/idisa/IDISABuiltin2C.java

    r3032 r3134  
    22
    33public class IDISABuiltin2C extends AbstractIDISABuiltin2Lang {
     4       
     5        private String appendParameter(String origin, String newp)
     6        {
     7                if (origin.length() > 0)
     8                        return origin + ", " + _firstArg;
     9                else
     10                        return _firstArg;               
     11        }
    412
    513        @Override
    614        public String makeIDISAFunctionCall0(String operationBaseName,
    715                        String operationClassName, String fieldWidth, String... arguments) {
    8                 // TODO Auto-generated method stub
    9                 return null;
     16               
     17                String csv = getArgCsv(arguments);
     18                return String.format("%s_%s_%s(%s)", operationClassName, operationBaseName, fieldWidth, csv);
    1019        }
    1120
     
    1322        public String makeIDISAFunctionCall1(String operationBaseName,
    1423                        String operationClassName, String fieldWidth, String... arguments) {
    15                 // TODO Auto-generated method stub
    16                 return null;
     24               
     25                String csv = getArgCsv(arguments, 1);           
     26               
     27                return String.format("%s_%s_%s(%s)", operationClassName, operationBaseName, fieldWidth, appendParameter(csv, _firstArg));
    1728        }
    1829
     
    2031        public String makeIDISAFunctionCall2(String operationBaseName,
    2132                        String operationClassName, String fieldWidth, String... arguments) {
    22                 // TODO Auto-generated method stub
    23                 return null;
     33               
     34                String csv = getArgCsv(arguments);
     35                return String.format("%s_%s(%s)", operationClassName, operationBaseName, csv);
    2436        }
    2537
     
    2739        public String makeIDISAFunctionCall3(String operationBaseName,
    2840                        String operationClassName, String fieldWidth, String... arguments) {
    29                 // TODO Auto-generated method stub
    30                 return null;
     41               
     42                String csv = getArgCsv(arguments);
     43                return String.format("%s_%s(%s)", operationClassName, operationBaseName, csv);
    3144        }
    3245
     
    3447        public String makeIDISAFunctionCall4(String operationBaseName,
    3548                        String operationClassName, String fieldWidth, String... arguments) {
    36                 // TODO Auto-generated method stub
    37                 return null;
     49               
     50                String csv = getArgCsv(arguments, 1);
     51                return String.format("%s_%s(%s)", operationClassName, operationBaseName, appendParameter(csv, _firstArg));
    3852        }
    3953
     
    4155        public String makeIDISAFunctionCallStore(String operationBaseName,
    4256                        String operationClassName, String fieldWidth, String[] arguments) {
    43                 // TODO Auto-generated method stub
    44                 return null;
     57               
     58                String csv = getArgCsv(arguments, 1);
     59                return String.format("%s_%s(%s)", operationClassName, operationBaseName, _firstArg + ", &" + csv);
    4560        }
    4661
     
    4863        public String makeIDISAFunctionCallLoad(String operationBaseName,
    4964                        String operationClassName, String fieldWidth, String[] arguments) {
    50                 // TODO Auto-generated method stub
    51                 return null;
     65                String csv = getArgCsv(arguments, 1);
     66                return String.format("%s_%s(%s)", operationClassName, operationBaseName, "&" + _firstArg);
    5267        }
    5368}
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/codeGenerator/idisa/IDISABuiltin2CPP.java

    r3032 r3134  
    1313
    1414
    15 public class IDISABuiltin2CPP extends AbstractIDISABuiltin2Lang{
    16        
    17         private String _firstArg;
    18        
    19         private String getArgCsv(String[] arguments, int start) {
    20                 ArrayList<String> argList = new ArrayList<String>();
    21                 for (String arg: arguments)
    22                 {
    23                         for (String parts: arg.split(","))
    24                         {
    25                                 argList.add(parts.trim());
    26                         }
    27                 }
    28                 _firstArg = argList.get(0);
    29                
    30                 String csv = UnparserUtil.makeDelimitedList(argList.subList(start, argList.size()), ", ");
    31                 return csv;
    32         }
    33        
    34         private String getArgCsv(String[] arguments)
    35         {
    36                 return getArgCsv(arguments, 0);
    37         }
     15public class IDISABuiltin2CPP extends AbstractIDISABuiltin2Lang{       
    3816
    3917        @Override
     
    4119               
    4220                String csv = getArgCsv(arguments);
    43                
    4421                return String.format("%s<%s>::%s(%s)", operationClassName, fieldWidth, operationBaseName, csv);
    4522        }
     
    5027               
    5128                String csv = getArgCsv(arguments, 1);
    52                                                
    5329                return String.format("%s<%s>::%s<%s>(%s)", operationClassName, fieldWidth, operationBaseName, _firstArg, csv);
    5430        }
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/codeGenerator/visitors/Unparser.java

    r3115 r3134  
    151151        public CodeStore visitLeave(StateIdentifierNode node, List<CodeStore> childResults) {           
    152152               
    153 //              stateIdentifier = Accessors.stateName(node); // synthetic attribute
    154                
    155                 CodeStore code = new CodeStore();
    156                 code.setResultVarName(stateIdentifier);         
     153            // stateIdentifier = Accessors.stateName(node); // synthetic attribute
     154                CodeStore code = new CodeStore();
     155                // code.setResultVarName(stateIdentifier);             
    157156                return code;
    158157        }
     
    190189        public CodeStore visitLeave(StateSizeNode node, List<CodeStore> childResults) {
    191190                CodeStore code = new CodeStore();
    192 //              code.setResultVarName(Accessors.integerConstantLexeme(node));
     191        //      code.setResultVarName(Accessors.integerConstantLexeme(node));
    193192                return code;
    194193        }       
  • proto/pabloj/branches/refactor-experimental/src/toolchain/pabloB/lang/idisa/IDISABuiltin.java

    r3035 r3134  
    3636public enum IDISABuiltin {
    3737               
    38         // SIMD operations (opPattern == 0) class_name<fw>::op(data_type arg, ...)
     38        // SIMD operations (opPattern == 0)
     39        // C++: class_name<fw>::op(data_type arg, ...)
     40        // C:   class_name_op_fw(args...)
    3941        ESIMD_MERGEH (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(),  BITBLOCK, BITBLOCK,  BITBLOCK)),
    4042        ESIMD_MERGEL (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(),  BITBLOCK, BITBLOCK,  BITBLOCK)),
     
    8688        SIMD_XOR_HL (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBuiltinGenerator(),  BITBLOCK,  BITBLOCK)),
    8789       
    88         // SIMD (opPatterns == 1) class_name<fw>::op<x>(data_type arg, ...)
     90        // SIMD (opPatterns == 1)
     91        // C++: class_name<fw>::op<x>(data_type arg, ...)
     92        // C:   class_name_op_fw(data_type arg, ..., x)
    8993        MVMD_DSLLI (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDConstantBuiltinGenerator(),  INTEGERCONSTANT,  BITBLOCK,  BITBLOCK)),
    9094        MVMD_DSRLI (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDConstantBuiltinGenerator(),  INTEGERCONSTANT,  BITBLOCK,  BITBLOCK)),
     
    99103        SIMD_SRLI (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDConstantBuiltinGenerator(),  INTEGERCONSTANT,   BITBLOCK)),
    100104       
    101         // SIMD logic operations (opPattern == 2) simd_op(data_type arg, ...)
     105        // SIMD logic operations (opPattern == 2)
     106        // C++: simd_op(data_type arg, ...)
     107        // C:   simd_op(data_type arg, ...)
    102108        SIMD_NOR (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDLogicBuiltinGenerator(),  BITBLOCK, BITBLOCK,  BITBLOCK)),
    103109        SIMD_NOT (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDLogicBuiltinGenerator(),  BITBLOCK,  BITBLOCK)),
     
    107113        SIMD_AND (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDLogicBuiltinGenerator(),  BITBLOCK, BITBLOCK,  BITBLOCK)),
    108114       
    109         // SIMD (opPattern == 3) class_name::op(data_type arg, ...)
     115        // SIMD (opPattern == 3)
     116        // C++: class_name::op(data_type arg, ...)
     117        // C:   class_name_op(data_type arg, ...)
    110118        BITBLOCK_ALL (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockBuiltinGenerator(),  BITBLOCK,  BOOL)),
    111119        BITBLOCK_ANY (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockBuiltinGenerator(),  BITBLOCK,  BOOL)),
     
    114122        BITBLOCK_SRL (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockBuiltinGenerator(),  BITBLOCK, BITBLOCK,  BITBLOCK)),
    115123       
    116         // SIMD (opPattern == 4) class_name::op<x>(data_type arg, ...)
     124        // SIMD (opPattern == 4)
     125        // C++: class_name::op<x>(data_type arg, ...)
     126        // C:   class_name_op(data_type arg, ..., x)
    117127        BITBLOCK_SLLI (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockImmediateBuiltinGenerator(),  INTEGERCONSTANT,  BITBLOCK)),
    118128        BITBLOCK_SRLI (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockImmediateBuiltinGenerator(),  INTEGERCONSTANT,  BITBLOCK)),
    119129       
    120         // SIMD Stores (with args = (Bitblock, Bitblock*)
     130        // SIMD Stores (with args = (Bitblock, Bitblock*))
    121131        BITBLOCK_STORE_ALIGNED (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockStoreBuiltinGenerator(),  BITBLOCK, BITBLOCK_POINTER,  VOID)),
    122132        BITBLOCK_STORE_UNALIGNED (makeAllSimpleSignatures(BITBLOCK_SIZE, new SIMDBitblockStoreBuiltinGenerator(),  BITBLOCK, BITBLOCK_POINTER,  VOID)),
Note: See TracChangeset for help on using the changeset viewer.