Changeset 3767


Ignore:
Timestamp:
Mar 29, 2014, 4:39:19 PM (4 years ago)
Author:
ksherdy
Message:

Replaced function keyword with filter.

Location:
proto/s2k/trunk/framework
Files:
37 edited

Legend:

Unmodified
Added
Removed
  • proto/s2k/trunk/framework/input/grammar/scatter/s2k.scatter

    r3762 r3767  
    11// s2k - A domain specific language for streaming text extraction and transformations.
    22//
    3 // Modified:    2012/09/08      Original definition.
    4 //
     3// Original:    2012/09/08     
     4// Modified:    2014/03/29    Removed VOID type.     
    55//
    66// Tom Shermer, Ken Herdy
     
    3333  // t o k e n s
    3434    tokens {
    35         FUNCTION,
     35        FILTER,
    3636        STREAM,
    3737        STRUCT,
     
    111111    // s t r e a m   f u n c t i o n   d e f i n i t i o n s
    112112    //
    113     funcDef             ->  FUNCTION funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                     
     113    funcDef             ->  FILTER funcName LROUND parameterList? RROUND blockStmt TERMINATOR? ;                     
    114114    parameterList       ->  parameter (COMMA parameter)*;
    115115    funcName            #-> identifier ;
  • proto/s2k/trunk/framework/input/test/s2k/all/all.s2k

    r3762 r3767  
    1212};
    1313
    14 function Foo() {
    15 
    16 }function AssignmentExpressions() {     
     14filter Foo() {
     15
     16}filter AssignmentExpressions() {       
    1717        temp4 = temp;
    1818        temp4 &= temp1 | temp2;
    1919        temp4 |= temp1 ^ temp2;
    2020        temp4 ^= temp1 & temp2;
    21 };function BasicExpressions() {
     21};filter BasicExpressions() {
    2222
    2323        temp4 = temp;
     
    3535};
    3636
    37 function Assignments() {
     37filter Assignments() {
    3838        stream<1> s;
    3939        s = 0;
    40 };function Assignments() {
     40};filter Assignments() {
    4141        stream<1> s;
    4242        stream<1> a;
     
    5050        s |= a | b | c | d;
    5151        // s = s | a | b | c;
    52 };function StreamStructs() {
     52};filter StreamStructs() {
    5353
    5454        // records
     
    5959        //temp1.temp2.temp3 = temp4;
    6060               
    61 };function FunctionExpressions() {
     61};filter nameExpressions() {
    6262         stream<1> a = b.Advance();
    6363};
    64 function Function(struct TagCallouts tagCallouts, struct Lex lex) {     
     64filter name(struct TagCallouts tagCallouts, struct Lex lex) {   
    6565
    6666        stream<1> starts_accum = 0;
     
    7676        }
    7777};
    78 function While() {     
     78filter While() {       
    7979                       
    8080        stream<1> cursor = 1;
     
    8484        }
    8585}
    86 function While() {     
     86filter While() {       
    8787       
    8888        stream<1> cursor;
     
    9393        }
    9494}
    95 function Function() {   
     95filter name() {
    9696        stream<1> cursor1;
    9797       
     
    104104        }
    105105}
    106 function localDecl() {
     106filter localDecl() {
    107107        struct BasisBits A;
    108108        struct BasisBits B;
    109109        struct BasisBits C;
    110 };function Assignments() {
     110};filter Assignments() {
    111111        stream a;
    112112        stream<1> s = a;
    113 }function localDecl() {
     113}filter localDecl() {
    114114        stream<1> A;
    115115        stream B;
    116 }function localDecl() {
     116}filter localDecl() {
    117117
    118118        struct BasisBits A;
    119119
    120 } function Function() {
     120} filter name() {       
    121121       
    122122        stream cursor;
     
    129129       
    130130}
    131 function Function() {   
     131filter name() {
    132132       
    133133        stream cursor;
     
    140140       
    141141}
    142 function Function() {           
     142filter name() {         
    143143        stream cursor;
    144144        if(cursor) {
     
    146146        }
    147147}
    148 function Function() {   
     148filter name() {
    149149       
    150150        stream cursor;
     
    190190};
    191191
    192 function ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
     192filter ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
    193193    stream temp1 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    194194    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     
    218218}
    219219
    220 function Match(struct Lex lex, struct Output output) {
     220filter Match(struct Lex lex, struct Output output) {
    221221    stream cursor = pablo.Advance(lex.a);
    222222    cursor = pablo.Advance((cursor & lex.p));
     
    227227}
    228228
    229 function MatchLines(struct Lex lex, struct Output output) {
     229filter MatchLines(struct Lex lex, struct Output output) {
    230230    stream all_line_starts = (pablo.ScanToFirst((~ lex.LF)) | (pablo.Advance(lex.LF) & (~ lex.LF)));
    231231    stream all_line_ends = lex.LF;
     
    247247
    248248/*
    249 function Main(struct Basis_bits basis_bits, struct Lex lex, struct Output output) {
     249filter Main(struct Basis_bits basis_bits, struct Lex lex, struct Output output) {
    250250    Transpose(byte_data, basis_bits);
    251251    ClassifyBytes(basis_bits, lex);
     
    375375};
    376376
    377 function Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
     377filter Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
    378378    stream temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    379379    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     
    532532}
    533533
    534 function Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
     534filter Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    535535    ctCDPI_Callouts.Ct_starts = pablo.Mask(1,0);
    536536    ctCDPI_Callouts.Ct_ends = pablo.Mask(1,0);
     
    607607}
    608608
    609 function Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     609filter Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    610610    stream EqExpected = pablo.Mask(1,0);
    611611    stream AttListEnd = pablo.Mask(1,0);
     
    675675}
    676676
    677 function Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     677filter Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    678678    ref_Callouts.GenRef_starts = pablo.Mask(1,0);
    679679    ref_Callouts.GenRef_ends = pablo.Mask(1,0);
     
    702702}
    703703
    704 function Validate_xml_names(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) {
     704filter Validate_xml_names(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) {
    705705    stream PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    706706    stream GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
     
    723723}
    724724
    725 function Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
     725filter Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    726726    pablo.assert_0((marker.CD_closer & (~ tag_Callouts.AttVal_spans)), "Error: ]]> in text");
    727727    check_streams.tag_marks = (((tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts) | tag_Callouts.EndTag_marks) | tag_Callouts.AttName_starts);
     
    734734
    735735/*
    736 function Function(stream<1> a, stream<1> b, stream<1> c) {
     736filter name(stream<1> a, stream<1> b, stream<1> c) {
    737737
    738738
     
    747747};
    748748
    749 function Foo() { }
    750 function ClassifyBytes(struct BasisBit basis) {};
     749filter Foo() { }
     750filter ClassifyBytes(struct BasisBit basis) {};
    751751
    752752
     
    782782};
    783783
    784 function ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
     784filter ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
    785785    stream temp1 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    786786    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     
    810810}
    811811
    812 function Match(struct Lex lex, struct Matches matches) {
     812filter Match(struct Lex lex, struct Matches matches) {
    813813    stream m0 = lex.a;
    814814    stream m1 = (pablo.Advance(m0) & lex.p);
     
    819819}
    820820
    821 function MatchLines1(struct Lex lex, struct Matches matches, struct Lines lines) {
     821filter MatchLines1(struct Lex lex, struct Matches matches, struct Lines lines) {
    822822    stream last_start = pablo.First();
    823823    stream LF_or_match = (lex.LF | matches.all_matched);
     
    836836}
    837837
    838 function MatchLines2(struct Lex lex, struct Matches matches, struct Lines lines) {
     838filter MatchLines2(struct Lex lex, struct Matches matches, struct Lines lines) {
    839839    stream last_start = pablo.Mask(1,0);
    840840    last_start = (pablo.Advance((~ last_start)) ^ (~ last_start));
     
    854854}
    855855
    856 function FilterMatchLines(struct Data data, struct Output output) {
     856filter nameMatchLines(struct Data data, struct Output output) {
    857857    output.lines = pablo.filter_bytes(data, (~ lines.all_matched));
    858858}
    859859
    860 function CountLines(struct Lex lex, struct Lines lines) {
     860filter CountLines(struct Lex lex, struct Lines lines) {
    861861    return pablo.PopCount((pablo.MatchStar(lines, (~ lex.LF)) & lex.LF)) ;
    862862}
  • proto/s2k/trunk/framework/input/test/s2k/decl/decl1.s2k

    r3762 r3767  
    66};
    77
    8 function Foo() {
     8filter Foo() {
    99
    1010}
  • proto/s2k/trunk/framework/input/test/s2k/funcDef/funcDef1.s2k

    r3762 r3767  
    77};
    88
    9 function Foo() { }
     9filter Foo() { }
  • proto/s2k/trunk/framework/input/test/s2k/funcDef/funcDef2.s2k

    r3762 r3767  
    55
    66/*
    7 function Function(stream<1> a, stream<1> b, stream<1> c) {
     7filter name(stream<1> a, stream<1> b, stream<1> c) {
    88
    99
  • proto/s2k/trunk/framework/input/test/s2k/funcDef/funcDef3.s2k

    r3762 r3767  
    1 function ClassifyBytes(struct BasisBit basis) {};
     1filter ClassifyBytes(struct BasisBit basis) {};
  • proto/s2k/trunk/framework/input/test/s2k/proto/grep/grep.s2k

    r3762 r3767  
    2727};
    2828
    29 function ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
     29filter ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
    3030    stream temp1 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    3131    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     
    5555}
    5656
    57 function Match(struct Lex lex, struct Output output) {
     57filter Match(struct Lex lex, struct Output output) {
    5858    stream cursor = pablo.Advance(lex.a);
    5959    cursor = pablo.Advance((cursor & lex.p));
     
    6464}
    6565
    66 function MatchLines(struct Lex lex, struct Output output) {
     66filter MatchLines(struct Lex lex, struct Output output) {
    6767    stream all_line_starts = (pablo.ScanToFirst((~ lex.LF)) | (pablo.Advance(lex.LF) & (~ lex.LF)));
    6868    stream all_line_ends = lex.LF;
     
    8484
    8585/*
    86 function Main(struct Basis_bits basis_bits, struct Lex lex, struct Output output) {
     86filter Main(struct Basis_bits basis_bits, struct Lex lex, struct Output output) {
    8787    Transpose(byte_data, basis_bits);
    8888    ClassifyBytes(basis_bits, lex);
  • proto/s2k/trunk/framework/input/test/s2k/proto/parabix2/parabix2_pablo_r2797.s2k

    r3762 r3767  
    121121};
    122122
    123 function Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
     123filter Classify_bytes_Validate_utf8(struct Basis_bits basis_bits, struct Lex lex, struct U8 u8) {
    124124    stream temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
    125125    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     
    278278}
    279279
    280 function Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
     280filter Parse_CtCDPI(struct Lex lex, struct Marker marker, struct CtCDPI_Callouts ctCDPI_Callouts, struct Check_streams check_streams) {
    281281    ctCDPI_Callouts.Ct_starts = pablo.Mask(1,0);
    282282    ctCDPI_Callouts.Ct_ends = pablo.Mask(1,0);
     
    353353}
    354354
    355 function Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
     355filter Parse_tags(struct Lex lex, struct Marker marker, struct Tag_Callouts tag_Callouts) {
    356356    stream EqExpected = pablo.Mask(1,0);
    357357    stream AttListEnd = pablo.Mask(1,0);
     
    421421}
    422422
    423 function Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
     423filter Parse_refs(struct Lex lex, struct Marker marker, struct Ref_Callouts ref_Callouts) {
    424424    ref_Callouts.GenRef_starts = pablo.Mask(1,0);
    425425    ref_Callouts.GenRef_ends = pablo.Mask(1,0);
     
    448448}
    449449
    450 function Validate_xml_names(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) {
     450filter Validate_xml_names(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) {
    451451    stream PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends);
    452452    stream GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends);
     
    469469}
    470470
    471 function Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
     471filter Do_check_streams(struct Marker marker, struct Tag_Callouts tag_Callouts, struct Check_streams check_streams) {
    472472    pablo.assert_0((marker.CD_closer & (~ tag_Callouts.AttVal_spans)), "Error: ]]> in text");
    473473    check_streams.tag_marks = (((tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts) | tag_Callouts.EndTag_marks) | tag_Callouts.AttName_starts);
  • proto/s2k/trunk/framework/input/test/s2k/statements/assign/assign1.s2k

    r3762 r3767  
    1 function Assignments() {
     1filter Assignments() {
    22        stream<1> s;
    33        s = 0;
  • proto/s2k/trunk/framework/input/test/s2k/statements/assign/assign2.s2k

    r3762 r3767  
    1 function BasicExpressions() {
     1filter BasicExpressions() {
    22
    33        temp4 = temp;
  • proto/s2k/trunk/framework/input/test/s2k/statements/assign/assign3.s2k

    r3762 r3767  
    1 function AssignmentExpressions() {     
     1filter AssignmentExpressions() {       
    22        temp4 = temp;
    33        temp4 &= temp1 | temp2;
  • proto/s2k/trunk/framework/input/test/s2k/statements/assign/assign4.s2k

    r3762 r3767  
    1 function StreamStructs() {
     1filter StreamStructs() {
    22
    33        // records
  • proto/s2k/trunk/framework/input/test/s2k/statements/assign/assign5.s2k

    r3762 r3767  
    1 function FunctionExpressions() {
     1filter nameExpressions() {
    22         stream<1> a = b.Advance();
    33};
  • proto/s2k/trunk/framework/input/test/s2k/statements/assign/assign6.s2k

    r3762 r3767  
    1 function Assignments() {
     1filter Assignments() {
    22        stream<1> s;
    33        stream<1> a;
  • proto/s2k/trunk/framework/input/test/s2k/statements/if/if1.s2k

    r3762 r3767  
    1 function Function() {           
     1filter name() {         
    22        stream cursor;
    33        if(cursor) {
  • proto/s2k/trunk/framework/input/test/s2k/statements/if/if2.s2k

    r3762 r3767  
    1 function Function() {   
     1filter name() {
    22       
    33        stream cursor;
  • proto/s2k/trunk/framework/input/test/s2k/statements/if/if3.s2k

    r3762 r3767  
    1 function Function() {   
     1filter name() {
    22       
    33        stream cursor;
  • proto/s2k/trunk/framework/input/test/s2k/statements/if/if4.s2k

    r3762 r3767  
    1 function Function() {   
     1filter name() {
    22       
    33        stream cursor;
  • proto/s2k/trunk/framework/input/test/s2k/statements/localDecl/localDecl1.s2k

    r3762 r3767  
    1 function localDecl() {
     1filter localDecl() {
    22
    33        struct BasisBits A;
  • proto/s2k/trunk/framework/input/test/s2k/statements/localDecl/localDecl2.s2k

    r3762 r3767  
    1 function localDecl() {
     1filter localDecl() {
    22        struct BasisBits A;
    33        struct BasisBits B;
  • proto/s2k/trunk/framework/input/test/s2k/statements/localDecl/localDecl3.s2k

    r3762 r3767  
    1 function localDecl() {
     1filter localDecl() {
    22        stream<1> A;
    33        stream B;
  • proto/s2k/trunk/framework/input/test/s2k/statements/localDecl/localDecl4.s2k

    r3762 r3767  
    1 function Assignments() {
     1filter Assignments() {
    22        stream a;
    33        stream<1> s = a;
  • proto/s2k/trunk/framework/input/test/s2k/statements/while/while1.s2k

    r3762 r3767  
    1 function While() {     
     1filter While() {       
    22                       
    33        stream<1> cursor = 1;
  • proto/s2k/trunk/framework/input/test/s2k/statements/while/while2.s2k

    r3762 r3767  
    1 function While() {     
     1filter While() {       
    22       
    33        stream<1> cursor;
  • proto/s2k/trunk/framework/input/test/s2k/statements/while/while3.s2k

    r3762 r3767  
    1 function Function() {   
     1filter name() {
    22        stream<1> cursor1;
    33       
  • proto/s2k/trunk/framework/input/test/s2k/statements/while/while4.s2k

    r3762 r3767  
    1 function Function(struct TagCallouts tagCallouts, struct Lex lex) {     
     1filter name(struct TagCallouts tagCallouts, struct Lex lex) {   
    22
    33        stream<1> starts_accum = 0;
  • proto/s2k/trunk/framework/input/test/s2k/test.s2k

    r3762 r3767  
    3232};
    3333
    34 function ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
     34filter ClassifyBytes(struct Basis_bits basis_bits, struct Lex lex) {
    3535    stream temp1 = (basis_bits.bit_1 & (~ basis_bits.bit_0));
    3636    stream temp2 = (basis_bits.bit_2 & (~ basis_bits.bit_3));
     
    6060}
    6161
    62 function Match(struct Lex lex, struct Matches matches) {
     62filter Match(struct Lex lex, struct Matches matches) {
    6363    stream m0 = lex.a;
    6464    stream m1 = (pablo.Advance(m0) & lex.p);
     
    6969}
    7070
    71 function MatchLines1(struct Lex lex, struct Matches matches, struct Lines lines) {
     71filter MatchLines1(struct Lex lex, struct Matches matches, struct Lines lines) {
    7272    stream last_start = pablo.First();
    7373    stream LF_or_match = (lex.LF | matches.all_matched);
     
    8686}
    8787
    88 function MatchLines2(struct Lex lex, struct Matches matches, struct Lines lines) {
     88filter MatchLines2(struct Lex lex, struct Matches matches, struct Lines lines) {
    8989    stream last_start = pablo.Mask(1,0);
    9090    last_start = (pablo.Advance((~ last_start)) ^ (~ last_start));
     
    104104}
    105105
    106 function FilterMatchLines(struct Data data, struct Output output) {
     106filter nameMatchLines(struct Data data, struct Output output) {
    107107    output.lines = pablo.filter_bytes(data, (~ lines.all_matched));
    108108}
    109109
    110 function CountLines(struct Lex lex, struct Lines lines) {
     110filter CountLines(struct Lex lex, struct Lines lines) {
    111111    return pablo.PopCount((pablo.MatchStar(lines, (~ lex.LF)) & lex.LF)) ;
    112112}
  • proto/s2k/trunk/framework/input/test/visitors/CarryIntroXFormerFinalBlock/atEOF.s2k

    r3687 r3767  
    1 function void Test() {
     1filter void Test() {
    22        stream<1> X;
    33        stream<1> R;
  • proto/s2k/trunk/framework/input/test/visitors/CarryIntroXFormerFinalBlock/inFile.s2k

    r3687 r3767  
    1 function void Test() {
     1filter void Test() {
    22        stream<1> X;
    33        stream<1> R;
  • proto/s2k/trunk/framework/input/test/visitors/CarryIntroXFormerFinalBlock/pablo2CarryQ.s2k

    r3687 r3767  
    1 function void Test() {
     1filter void Test() {
    22        stream<1> temp;
    33        stream<1> C;    // cursor stream
  • proto/s2k/trunk/framework/input/test/visitors/CarryIntroXFormerNotFinalBlock/pablo2CarryQ.s2k

    r3689 r3767  
    1 function void Test() {
     1filter void Test() {
    22        stream<1> temp;
    33        stream<1> C;    // Cursor stream<1>
  • proto/s2k/trunk/framework/input/test/visitors/CombineAdvances/combineAdvances.s2k

    r3690 r3767  
    1 function void Test() {
     1filter void Test() {
    22        stream<1> temp;
    33        stream<1> X = 0;
  • proto/s2k/trunk/framework/input/test/visitors/ConvertBitwiseBooleanToIDISACalls/ConvertBitwiseBooleanToIDISACalls.s2k

    r3688 r3767  
    1 function void Test() {
     1filter void Test() {
    22
    33/*
  • proto/s2k/trunk/framework/input/test/visitors/ExpandAugmentedAssignments/expandAugmentedAssignments.s2k

    r3690 r3767  
    1 function void Test() {
     1filter void Test() {
    22        stream<1> x;
    33        stream<1> y;
  • proto/s2k/trunk/framework/output/cpplang/parabix2/parabix2_definitions.hpp

    r3764 r3767  
    186186};
    187187 
    188 struct Classify_bytes_Validate_utf8
    189 {
    190         Classify_bytes_Validate_utf8()
    191         {
    192         }
    193        
    194         IDISA_INLINE void do_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8)
    195         {
    196                 BitBlock temp1;
    197                 temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
    198                 BitBlock temp2;
    199                 temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
    200                 BitBlock temp3;
    201                 temp3 = simd_andc(temp2,temp1);
    202                 BitBlock temp4;
    203                 temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
    204                 BitBlock temp5;
    205                 temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
    206                 BitBlock temp6;
    207                 temp6 = simd_and(temp4,temp5);
    208                 lex.RefStart = simd_and(temp3,temp6);
    209                 BitBlock temp7;
    210                 temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
    211                 BitBlock temp8;
    212                 temp8 = simd_andc(temp7,temp1);
    213                 BitBlock temp9;
    214                 temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
    215                 BitBlock temp10;
    216                 temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
    217                 BitBlock temp11;
    218                 temp11 = simd_and(temp9,temp10);
    219                 lex.Semicolon = simd_and(temp8,temp11);
    220                 BitBlock temp12;
    221                 temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
    222                 BitBlock temp13;
    223                 temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
    224                 BitBlock temp14;
    225                 temp14 = simd_andc(temp12,temp13);
    226                 lex.LAngle = simd_and(temp8,temp14);
    227                 BitBlock temp15;
    228                 temp15 = simd_and(temp12,temp5);
    229                 lex.RAngle = simd_and(temp8,temp15);
    230                 BitBlock temp16;
    231                 temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
    232                 BitBlock temp17;
    233                 temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
    234                 BitBlock temp18;
    235                 temp18 = simd_and(temp16,temp17);
    236                 lex.LBracket = simd_and(temp18,temp11);
    237                 BitBlock temp19;
    238                 temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
    239                 BitBlock temp20;
    240                 temp20 = simd_and(temp12,temp19);
    241                 lex.RBracket = simd_and(temp18,temp20);
    242                 BitBlock temp21;
    243                 temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
    244                 BitBlock temp22;
    245                 temp22 = simd_andc(temp19,temp21);
    246                 lex.Exclam = simd_and(temp3,temp22);
    247                 BitBlock temp23;
    248                 temp23 = simd_and(temp12,temp10);
    249                 lex.QMark = simd_and(temp8,temp23);
    250                 lex.Hyphen = simd_and(temp3,temp20);
    251                 lex.Equals = simd_and(temp8,temp20);
    252                 BitBlock temp24;
    253                 temp24 = simd_and(temp4,temp10);
    254                 lex.SQuote = simd_and(temp3,temp24);
    255                 BitBlock temp25;
    256                 temp25 = simd_andc(temp5,temp21);
    257                 lex.DQuote = simd_and(temp3,temp25);
    258                 lex.Slash = simd_and(temp3,temp23);
    259                 BitBlock temp26;
    260                 temp26 = simd_andc(temp10,temp21);
    261                 lex.Hash = simd_and(temp3,temp26);
    262                 BitBlock temp27;
    263                 temp27 = simd_and(temp16,temp7);
    264                 BitBlock temp28;
    265                 temp28 = simd_andc(temp9,temp13);
    266                 lex.x = simd_and(temp27,temp28);
    267                 BitBlock temp29;
    268                 temp29 = simd_and(temp9,temp5);
    269                 lex.Colon = simd_and(temp8,temp29);
    270                 BitBlock temp30;
    271                 temp30 = simd_and(temp18,temp23);
    272                 BitBlock temp31;
    273                 temp31 = simd_or(temp30,lex.Colon);
    274                 BitBlock temp32;
    275                 temp32 = simd_andc(temp16,basis_bits.bit_2);
    276                 BitBlock temp33;
    277                 temp33 = simd_or(basis_bits.bit_5,temp10);
    278                 BitBlock temp34;
    279                 temp34 = simd_and(basis_bits.bit_4,temp33);
    280                 BitBlock temp35;
    281                 temp35 = simd_not(temp34);
    282                 BitBlock temp36;
    283                 temp36 = simd_or(temp21,temp13);
    284                 BitBlock temp37;
    285                 temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
    286                 BitBlock temp38;
    287                 temp38 = simd_and(temp32,temp37);
    288                 BitBlock temp39;
    289                 temp39 = simd_or(temp31,temp38);
    290                 BitBlock temp40;
    291                 temp40 = simd_and(temp16,basis_bits.bit_2);
    292                 BitBlock temp41;
    293                 temp41 = simd_and(temp40,temp37);
    294                 lex.ASCII_name_start = simd_or(temp39,temp41);
    295                 BitBlock temp42;
    296                 temp42 = simd_or(temp30,lex.Hyphen);
    297                 BitBlock temp43;
    298                 temp43 = simd_and(temp3,temp15);
    299                 BitBlock temp44;
    300                 temp44 = simd_or(temp42,temp43);
    301                 BitBlock temp45;
    302                 temp45 = simd_andc(temp8,temp34);
    303                 BitBlock temp46;
    304                 temp46 = simd_or(temp44,temp45);
    305                 BitBlock temp47;
    306                 temp47 = simd_or(temp46,temp38);
    307                 lex.ASCII_name_char = simd_or(temp47,temp41);
    308                 lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
    309                 BitBlock temp48;
    310                 temp48 = simd_or(temp1,basis_bits.bit_2);
    311                 BitBlock x00_x1F;
    312                 x00_x1F = simd_not(temp48);
    313                 BitBlock temp49;
    314                 temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
    315                 BitBlock temp50;
    316                 temp50 = simd_or(temp1,temp49);
    317                 lex.CR = simd_andc(temp20,temp50);
    318                 lex.LF = simd_andc(temp29,temp50);
    319                 BitBlock temp51;
    320                 temp51 = simd_and(temp9,temp19);
    321                 lex.HT = simd_andc(temp51,temp50);
    322                 lex.SP = simd_andc(temp3,temp36);
    323                 BitBlock temp52;
    324                 temp52 = simd_or(temp20,temp29);
    325                 BitBlock temp53;
    326                 temp53 = simd_or(temp52,temp51);
    327                 BitBlock temp54;
    328                 temp54 = simd_andc(temp53,temp50);
    329                 lex.WS = simd_or(temp54,lex.SP);
    330                 BitBlock temp55;
    331                 temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
    332                 BitBlock temp56;
    333                 temp56 = simd_and(basis_bits.bit_4,temp55);
    334                 lex.Digit = simd_andc(temp8,temp56);
    335                 BitBlock temp57;
    336                 temp57 = simd_andc(temp16,temp49);
    337                 BitBlock temp58;
    338                 temp58 = simd_andc(temp57,basis_bits.bit_4);
    339                 BitBlock temp59;
    340                 temp59 = simd_not(temp10);
    341                 BitBlock temp60;
    342                 temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
    343                 BitBlock temp61;
    344                 temp61 = simd_and(temp58,temp60);
    345                 BitBlock temp62;
    346                 temp62 = simd_or(lex.Digit,temp61);
    347                 BitBlock temp63;
    348                 temp63 = simd_and(temp16,temp2);
    349                 BitBlock temp64;
    350                 temp64 = simd_andc(temp63,basis_bits.bit_4);
    351                 BitBlock temp65;
    352                 temp65 = simd_and(temp64,temp60);
    353                 lex.Hex = simd_or(temp62,temp65);
    354                 BitBlock lex_error;
    355                 lex_error = simd_andc(x00_x1F,lex.WS);
    356                 if (bitblock::any(lex_error))
    357                 {
    358                         assert_0_error(lex_error,"Error: illegal character");
    359                 }
    360                 u8.unibyte = simd_not(basis_bits.bit_0);
    361                 u8.suffix = simd<1>::constant<0>();
    362                 BitBlock u8_error;
    363                 u8_error = simd<1>::constant<0>();
    364                 BitBlock u8_FFFE_FFFF;
    365                 u8_FFFE_FFFF = simd<1>::constant<0>();
    366                 BitBlock u8anyscope;
    367                 u8anyscope = simd<1>::constant<0>();
    368                 if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
    369                 {
    370                         u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
    371                         u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
    372                         u8.prefix3 = simd_and(u8.prefix,temp2);
    373                         u8.prefix4 = simd_and(u8.prefix,temp7);
    374                         u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
    375                         BitBlock temp66;
    376                         temp66 = simd_andc(u8.prefix,temp49);
    377                         BitBlock temp67;
    378                         temp67 = simd_or(temp21,basis_bits.bit_6);
    379                         BitBlock temp68;
    380                         temp68 = simd_andc(temp66,temp67);
    381                         BitBlock temp69;
    382                         temp69 = simd_and(basis_bits.bit_5,temp13);
    383                         BitBlock temp70;
    384                         temp70 = simd_or(basis_bits.bit_4,temp69);
    385                         BitBlock temp71;
    386                         temp71 = simd_and(u8.prefix4,temp70);
    387                         u8.badprefix = simd_or(temp68,temp71);
    388                         u8_error = u8.badprefix;
    389                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
    390                         u8anyscope = u8.scope22;
    391                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    392                         {
    393                                 BitBlock xE0;
    394                                 xE0 = simd_andc(u8.prefix3,temp36);
    395                                 BitBlock xED;
    396                                 xED = simd_and(u8.prefix3,temp20);
    397                                 BitBlock xF0;
    398                                 xF0 = simd_andc(u8.prefix4,temp36);
    399                                 BitBlock temp72;
    400                                 temp72 = simd_andc(temp4,temp13);
    401                                 BitBlock xF4;
    402                                 xF4 = simd_and(u8.prefix4,temp72);
    403                                 u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
    404                                 u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
    405                                 u8.x90_xBF = simd_and(u8.suffix,temp49);
    406                                 u8.x80_x8F = simd_andc(u8.suffix,temp49);
    407                                 BitBlock xEF;
    408                                 xEF = simd_and(u8.prefix3,temp23);
    409                                 BitBlock temp73;
    410                                 temp73 = simd_and(u8.suffix,temp7);
    411                                 u8.xBF = simd_and(temp73,temp23);
    412                                 u8.xBE = simd_and(temp73,temp15);
    413                                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),u8.scope32));
    414                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),u8.scope33));
    415                                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),u8.scope42));
    416                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),u8.scope43));
    417                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),u8.scope44));
    418                                 BitBlock E0_F0_scope;
    419                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
    420                                 BitBlock ED_F4_scope;
    421                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
    422                                 u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
    423                                 u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
    424                                 u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
    425                                 u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    426                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
    427                                 BitBlock u8lastscope;
    428                                 u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    429                                 u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
    430                                 BitBlock u8error1;
    431                                 u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
    432                                 BitBlock u8error2;
    433                                 u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
    434                                 BitBlock u8error3;
    435                                 u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
    436                                 BitBlock u8error4;
    437                                 u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    438                                 u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    439                                 BitBlock EF_BF_pending;
    440                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),EF_BF_pending));
    441                                 u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    442                         }
    443                         else
    444                         {
    445                                 carry_set_0.carryDequeueEnqueue(1,9);
    446                         }
    447                         BitBlock u8mismatch;
    448                         u8mismatch = simd_xor(u8anyscope,u8.suffix);
    449                         if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    450                         {
    451                                 assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF),"UTF-8 error found");
    452                         }
    453                 }
    454                 else
    455                 {
    456                         carry_set_0.carryDequeueEnqueue(0,10);
    457                 }
    458                 carry_set_0.carryAdjust(10);
    459         }
    460        
    461         void do_final_block(struct Basis_bits & basis_bits,struct Lex & lex,struct U8 & u8,BitBlock & EOF_mask)
    462         {
    463                 BitBlock temp1;
    464                 temp1 = simd_or(basis_bits.bit_0,basis_bits.bit_1);
    465                 BitBlock temp2;
    466                 temp2 = simd_andc(basis_bits.bit_2,basis_bits.bit_3);
    467                 BitBlock temp3;
    468                 temp3 = simd_andc(temp2,temp1);
    469                 BitBlock temp4;
    470                 temp4 = simd_andc(basis_bits.bit_5,basis_bits.bit_4);
    471                 BitBlock temp5;
    472                 temp5 = simd_andc(basis_bits.bit_6,basis_bits.bit_7);
    473                 BitBlock temp6;
    474                 temp6 = simd_and(temp4,temp5);
    475                 lex.RefStart = simd_and(temp3,temp6);
    476                 BitBlock temp7;
    477                 temp7 = simd_and(basis_bits.bit_2,basis_bits.bit_3);
    478                 BitBlock temp8;
    479                 temp8 = simd_andc(temp7,temp1);
    480                 BitBlock temp9;
    481                 temp9 = simd_andc(basis_bits.bit_4,basis_bits.bit_5);
    482                 BitBlock temp10;
    483                 temp10 = simd_and(basis_bits.bit_6,basis_bits.bit_7);
    484                 BitBlock temp11;
    485                 temp11 = simd_and(temp9,temp10);
    486                 lex.Semicolon = simd_and(temp8,temp11);
    487                 BitBlock temp12;
    488                 temp12 = simd_and(basis_bits.bit_4,basis_bits.bit_5);
    489                 BitBlock temp13;
    490                 temp13 = simd_or(basis_bits.bit_6,basis_bits.bit_7);
    491                 BitBlock temp14;
    492                 temp14 = simd_andc(temp12,temp13);
    493                 lex.LAngle = simd_and(temp8,temp14);
    494                 BitBlock temp15;
    495                 temp15 = simd_and(temp12,temp5);
    496                 lex.RAngle = simd_and(temp8,temp15);
    497                 BitBlock temp16;
    498                 temp16 = simd_andc(basis_bits.bit_1,basis_bits.bit_0);
    499                 BitBlock temp17;
    500                 temp17 = simd_andc(basis_bits.bit_3,basis_bits.bit_2);
    501                 BitBlock temp18;
    502                 temp18 = simd_and(temp16,temp17);
    503                 lex.LBracket = simd_and(temp18,temp11);
    504                 BitBlock temp19;
    505                 temp19 = simd_andc(basis_bits.bit_7,basis_bits.bit_6);
    506                 BitBlock temp20;
    507                 temp20 = simd_and(temp12,temp19);
    508                 lex.RBracket = simd_and(temp18,temp20);
    509                 BitBlock temp21;
    510                 temp21 = simd_or(basis_bits.bit_4,basis_bits.bit_5);
    511                 BitBlock temp22;
    512                 temp22 = simd_andc(temp19,temp21);
    513                 lex.Exclam = simd_and(temp3,temp22);
    514                 BitBlock temp23;
    515                 temp23 = simd_and(temp12,temp10);
    516                 lex.QMark = simd_and(temp8,temp23);
    517                 lex.Hyphen = simd_and(temp3,temp20);
    518                 lex.Equals = simd_and(temp8,temp20);
    519                 BitBlock temp24;
    520                 temp24 = simd_and(temp4,temp10);
    521                 lex.SQuote = simd_and(temp3,temp24);
    522                 BitBlock temp25;
    523                 temp25 = simd_andc(temp5,temp21);
    524                 lex.DQuote = simd_and(temp3,temp25);
    525                 lex.Slash = simd_and(temp3,temp23);
    526                 BitBlock temp26;
    527                 temp26 = simd_andc(temp10,temp21);
    528                 lex.Hash = simd_and(temp3,temp26);
    529                 BitBlock temp27;
    530                 temp27 = simd_and(temp16,temp7);
    531                 BitBlock temp28;
    532                 temp28 = simd_andc(temp9,temp13);
    533                 lex.x = simd_and(temp27,temp28);
    534                 BitBlock temp29;
    535                 temp29 = simd_and(temp9,temp5);
    536                 lex.Colon = simd_and(temp8,temp29);
    537                 BitBlock temp30;
    538                 temp30 = simd_and(temp18,temp23);
    539                 BitBlock temp31;
    540                 temp31 = simd_or(temp30,lex.Colon);
    541                 BitBlock temp32;
    542                 temp32 = simd_andc(temp16,basis_bits.bit_2);
    543                 BitBlock temp33;
    544                 temp33 = simd_or(basis_bits.bit_5,temp10);
    545                 BitBlock temp34;
    546                 temp34 = simd_and(basis_bits.bit_4,temp33);
    547                 BitBlock temp35;
    548                 temp35 = simd_not(temp34);
    549                 BitBlock temp36;
    550                 temp36 = simd_or(temp21,temp13);
    551                 BitBlock temp37;
    552                 temp37 = simd_or(simd_and(basis_bits.bit_3,temp35),simd_andc(temp36,basis_bits.bit_3));
    553                 BitBlock temp38;
    554                 temp38 = simd_and(temp32,temp37);
    555                 BitBlock temp39;
    556                 temp39 = simd_or(temp31,temp38);
    557                 BitBlock temp40;
    558                 temp40 = simd_and(temp16,basis_bits.bit_2);
    559                 BitBlock temp41;
    560                 temp41 = simd_and(temp40,temp37);
    561                 lex.ASCII_name_start = simd_or(temp39,temp41);
    562                 BitBlock temp42;
    563                 temp42 = simd_or(temp30,lex.Hyphen);
    564                 BitBlock temp43;
    565                 temp43 = simd_and(temp3,temp15);
    566                 BitBlock temp44;
    567                 temp44 = simd_or(temp42,temp43);
    568                 BitBlock temp45;
    569                 temp45 = simd_andc(temp8,temp34);
    570                 BitBlock temp46;
    571                 temp46 = simd_or(temp44,temp45);
    572                 BitBlock temp47;
    573                 temp47 = simd_or(temp46,temp38);
    574                 lex.ASCII_name_char = simd_or(temp47,temp41);
    575                 lex.NameScan = simd_or(lex.ASCII_name_char,basis_bits.bit_0);
    576                 BitBlock temp48;
    577                 temp48 = simd_or(temp1,basis_bits.bit_2);
    578                 BitBlock x00_x1F;
    579                 x00_x1F = simd_not(temp48);
    580                 BitBlock temp49;
    581                 temp49 = simd_or(basis_bits.bit_2,basis_bits.bit_3);
    582                 BitBlock temp50;
    583                 temp50 = simd_or(temp1,temp49);
    584                 lex.CR = simd_andc(temp20,temp50);
    585                 lex.LF = simd_andc(temp29,temp50);
    586                 BitBlock temp51;
    587                 temp51 = simd_and(temp9,temp19);
    588                 lex.HT = simd_andc(temp51,temp50);
    589                 lex.SP = simd_andc(temp3,temp36);
    590                 BitBlock temp52;
    591                 temp52 = simd_or(temp20,temp29);
    592                 BitBlock temp53;
    593                 temp53 = simd_or(temp52,temp51);
    594                 BitBlock temp54;
    595                 temp54 = simd_andc(temp53,temp50);
    596                 lex.WS = simd_or(temp54,lex.SP);
    597                 BitBlock temp55;
    598                 temp55 = simd_or(basis_bits.bit_5,basis_bits.bit_6);
    599                 BitBlock temp56;
    600                 temp56 = simd_and(basis_bits.bit_4,temp55);
    601                 lex.Digit = simd_andc(temp8,temp56);
    602                 BitBlock temp57;
    603                 temp57 = simd_andc(temp16,temp49);
    604                 BitBlock temp58;
    605                 temp58 = simd_andc(temp57,basis_bits.bit_4);
    606                 BitBlock temp59;
    607                 temp59 = simd_not(temp10);
    608                 BitBlock temp60;
    609                 temp60 = simd_or(simd_and(basis_bits.bit_5,temp59),simd_andc(temp13,basis_bits.bit_5));
    610                 BitBlock temp61;
    611                 temp61 = simd_and(temp58,temp60);
    612                 BitBlock temp62;
    613                 temp62 = simd_or(lex.Digit,temp61);
    614                 BitBlock temp63;
    615                 temp63 = simd_and(temp16,temp2);
    616                 BitBlock temp64;
    617                 temp64 = simd_andc(temp63,basis_bits.bit_4);
    618                 BitBlock temp65;
    619                 temp65 = simd_and(temp64,temp60);
    620                 lex.Hex = simd_or(temp62,temp65);
    621                 BitBlock lex_error;
    622                 lex_error = simd_andc(x00_x1F,lex.WS);
    623                 if (bitblock::any(simd_and(lex_error,EOF_mask)))
    624                 {
    625                         assert_0_error(simd_and(lex_error,EOF_mask),"Error: illegal character");
    626                 }
    627                 u8.unibyte = simd_not(basis_bits.bit_0);
    628                 u8.suffix = simd<1>::constant<0>();
    629                 BitBlock u8_error;
    630                 u8_error = simd<1>::constant<0>();
    631                 BitBlock u8_FFFE_FFFF;
    632                 u8_FFFE_FFFF = simd<1>::constant<0>();
    633                 BitBlock u8anyscope;
    634                 u8anyscope = simd<1>::constant<0>();
    635                 if (bitblock::any(simd_or(basis_bits.bit_0,carry_set_0.carryRange(0,10))))
    636                 {
    637                         u8.prefix = simd_and(basis_bits.bit_0,basis_bits.bit_1);
    638                         u8.prefix2 = simd_andc(u8.prefix,basis_bits.bit_2);
    639                         u8.prefix3 = simd_and(u8.prefix,temp2);
    640                         u8.prefix4 = simd_and(u8.prefix,temp7);
    641                         u8.suffix = simd_andc(basis_bits.bit_0,basis_bits.bit_1);
    642                         BitBlock temp66;
    643                         temp66 = simd_andc(u8.prefix,temp49);
    644                         BitBlock temp67;
    645                         temp67 = simd_or(temp21,basis_bits.bit_6);
    646                         BitBlock temp68;
    647                         temp68 = simd_andc(temp66,temp67);
    648                         BitBlock temp69;
    649                         temp69 = simd_and(basis_bits.bit_5,temp13);
    650                         BitBlock temp70;
    651                         temp70 = simd_or(basis_bits.bit_4,temp69);
    652                         BitBlock temp71;
    653                         temp71 = simd_and(u8.prefix4,temp70);
    654                         u8.badprefix = simd_or(temp68,temp71);
    655                         u8_error = u8.badprefix;
    656                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix2,carry_set_0.getCarry(0),u8.scope22));
    657                         u8anyscope = u8.scope22;
    658                         if (bitblock::any(simd_or(simd_or(u8.prefix3,u8.prefix4),carry_set_0.carryRange(1,9))))
    659                         {
    660                                 BitBlock xE0;
    661                                 xE0 = simd_andc(u8.prefix3,temp36);
    662                                 BitBlock xED;
    663                                 xED = simd_and(u8.prefix3,temp20);
    664                                 BitBlock xF0;
    665                                 xF0 = simd_andc(u8.prefix4,temp36);
    666                                 BitBlock temp72;
    667                                 temp72 = simd_andc(temp4,temp13);
    668                                 BitBlock xF4;
    669                                 xF4 = simd_and(u8.prefix4,temp72);
    670                                 u8.xA0_xBF = simd_and(u8.suffix,basis_bits.bit_2);
    671                                 u8.x80_x9F = simd_andc(u8.suffix,basis_bits.bit_2);
    672                                 u8.x90_xBF = simd_and(u8.suffix,temp49);
    673                                 u8.x80_x8F = simd_andc(u8.suffix,temp49);
    674                                 BitBlock xEF;
    675                                 xEF = simd_and(u8.prefix3,temp23);
    676                                 BitBlock temp73;
    677                                 temp73 = simd_and(u8.suffix,temp7);
    678                                 u8.xBF = simd_and(temp73,temp23);
    679                                 u8.xBE = simd_and(temp73,temp15);
    680                                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix3,carry_set_0.getCarry(1),u8.scope32));
    681                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(u8.scope32,carry_set_0.getCarry(2),u8.scope33));
    682                                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(u8.prefix4,carry_set_0.getCarry(3),u8.scope42));
    683                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(u8.scope42,carry_set_0.getCarry(4),u8.scope43));
    684                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(u8.scope43,carry_set_0.getCarry(5),u8.scope44));
    685                                 BitBlock E0_F0_scope;
    686                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xE0,xF0),carry_set_0.getCarry(6),E0_F0_scope));
    687                                 BitBlock ED_F4_scope;
    688                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(simd_or(xED,xF4),carry_set_0.getCarry(7),ED_F4_scope));
    689                                 u8.xE0_scope = simd_and(u8.scope32,E0_F0_scope);
    690                                 u8.xED_scope = simd_and(u8.scope32,ED_F4_scope);
    691                                 u8.xF0_scope = simd_and(u8.scope42,E0_F0_scope);
    692                                 u8.xF4_scope = simd_and(u8.scope42,ED_F4_scope);
    693                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(xEF,carry_set_0.getCarry(8),u8.xEF_scope));
    694                                 BitBlock u8lastscope;
    695                                 u8lastscope = simd_or(simd_or(u8.scope22,u8.scope33),u8.scope44);
    696                                 u8anyscope = simd_or(simd_or(simd_or(u8lastscope,u8.scope32),u8.scope42),u8.scope43);
    697                                 BitBlock u8error1;
    698                                 u8error1 = simd_and(u8.xE0_scope,u8.x80_x9F);
    699                                 BitBlock u8error2;
    700                                 u8error2 = simd_and(u8.xED_scope,u8.xA0_xBF);
    701                                 BitBlock u8error3;
    702                                 u8error3 = simd_and(u8.xF0_scope,u8.x80_x8F);
    703                                 BitBlock u8error4;
    704                                 u8error4 = simd_and(u8.xF4_scope,u8.x90_xBF);
    705                                 u8_error = simd_or(u8_error,simd_or(simd_or(simd_or(u8error1,u8error2),u8error3),u8error4));
    706                                 BitBlock EF_BF_pending;
    707                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(u8.xEF_scope,u8.xBF),carry_set_0.getCarry(9),EF_BF_pending));
    708                                 u8_FFFE_FFFF = simd_and(EF_BF_pending,simd_or(u8.xBE,u8.xBF));
    709                         }
    710                         else
    711                         {
    712                                 carry_set_0.carryDequeueEnqueue(1,9);
    713                         }
    714                         BitBlock u8mismatch;
    715                         u8mismatch = simd_xor(u8anyscope,u8.suffix);
    716                         if (bitblock::any(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF)))
    717                         {
    718                                 assert_0_error(simd_or(simd_or(u8_error,u8mismatch),u8_FFFE_FFFF),"UTF-8 error found");
    719                         }
    720                 }
    721                 else
    722                 {
    723                         carry_set_0.carryDequeueEnqueue(0,10);
    724                 }
    725         }
    726        
    727         void clear()
    728         {
    729                
    730         }
    731        
    732         CarryDeclare(carry_set_0,10,0);
    733 };
    734  
    735 struct Parse_CtCDPI
    736 {
    737         Parse_CtCDPI()
    738         {
    739                 carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    740         }
    741        
    742         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams)
    743         {
    744                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    745                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    746                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    747                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    748                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    749                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    750                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    751                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    752                 BitBlock CtCDPI_starts;
    753                 CtCDPI_starts = simd<1>::constant<0>();
    754                 BitBlock CtCDPI_ends;
    755                 CtCDPI_ends = simd<1>::constant<0>();
    756                 BitBlock ctCDPI_mask;
    757                 ctCDPI_mask = simd<1>::constant<0>();
    758                 BitBlock v;
    759                 v = simd_or(lex.LAngle,lex.Hyphen);
    760                 BitBlock w;
    761                 w = simd_or(lex.Hyphen,lex.QMark);
    762                 BitBlock v1;
    763                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
    764                 BitBlock w1;
    765                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
    766                 BitBlock LAngle_scope;
    767                 LAngle_scope = simd_andc(v1,w1);
    768                 BitBlock PI_opener;
    769                 PI_opener = simd_and(LAngle_scope,lex.QMark);
    770                 BitBlock CtCD_opener;
    771                 CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    772                 BitBlock CtCDPI_opener;
    773                 CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    774                 BitBlock CD_closer;
    775                 CD_closer = simd<1>::constant<0>();
    776                 BitBlock DoubleHyphen;
    777                 DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    778                 if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
    779                 {
    780                         BitBlock DoubleRBracket;
    781                         BitBlock _temp0;
    782                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
    783                         DoubleRBracket = simd_and(_temp0,lex.RBracket);
    784                         BitBlock _temp1;
    785                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
    786                         CD_closer = simd_and(_temp1,lex.RAngle);
    787                 }
    788                 else
    789                 {
    790                         carry_set_0.carryDequeueEnqueue(0,2);
    791                 }
    792                 BitBlock PI_closer;
    793                 PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    794                 BitBlock CtCDPI_Cursor;
    795                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(CtCDPI_opener,carry_set_0.getCarry(2),CtCDPI_Cursor));
    796                 if (bitblock::any(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13))))
    797                 {
    798                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    799                         BitBlock PI_Cursor;
    800                         PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    801                         BitBlock CD_Ct_Cursor;
    802                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),CD_Ct_Cursor));
    803                         BitBlock CD_Cursor;
    804                         CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    805                         BitBlock Ct_Cursor;
    806                         Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    807                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
    808                         {
    809                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    810                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
    811                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    812                                 BitBlock PI_name_end;
    813                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
    814                                 BitBlock PI_error;
    815                                 PI_error = simd_and(PI_Cursor,PI_name_end);
    816                                 BitBlock PI_noWS;
    817                                 PI_noWS = simd_andc(PI_name_end,lex.WS);
    818                                 BitBlock _temp2;
    819                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
    820                                 PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    821                                 if (bitblock::any(PI_error))
    822                                 {
    823                                         assert_0_error(PI_error,"Error in PI syntax");
    824                                 }
    825                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    826                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_0.getCarry(7),PI_Cursor));
    827                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    828                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    829                         }
    830                         else
    831                         {
    832                                 carry_set_0.carryDequeueEnqueue(4,4);
    833                         }
    834                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
    835                         {
    836                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    837                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_0.getCarry(8),CD_Cursor));
    838                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    839                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    840                         }
    841                         else
    842                         {
    843                                 carry_set_0.carryDequeueEnqueue(8,1);
    844                         }
    845                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
    846                         {
    847                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    848                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
    849                                 BitBlock Ct_error;
    850                                 Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    851                                 BitBlock _temp3;
    852                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
    853                                 carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
    854                                 BitBlock _temp4;
    855                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    856                                 carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
    857                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    858                                 {
    859                                         assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
    860                                 }
    861                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    862                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    863                         }
    864                         else
    865                         {
    866                                 carry_set_0.carryDequeueEnqueue(9,5);
    867                         }
    868                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    869                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
    870                         if (bitblock::any(simd<1>::constant<0>()))
    871                         {
    872                                 assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
    873                         }
    874                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
    875                         while (bitblock::any(CtCDPI_Cursor))
    876                         {
    877                                 CarryDeclare(carry_set_1,13,0);
    878                                 CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    879                                 BitBlock PI_Cursor;
    880                                 PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    881                                 BitBlock CD_Ct_Cursor;
    882                                 carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
    883                                 BitBlock CD_Cursor;
    884                                 CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    885                                 BitBlock Ct_Cursor;
    886                                 Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    887                                 if (bitblock::any(PI_Cursor))
    888                                 {
    889                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    890                                         carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
    891                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    892                                         BitBlock PI_name_end;
    893                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
    894                                         BitBlock PI_error;
    895                                         PI_error = simd_and(PI_Cursor,PI_name_end);
    896                                         BitBlock PI_noWS;
    897                                         PI_noWS = simd_andc(PI_name_end,lex.WS);
    898                                         BitBlock _temp2;
    899                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
    900                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    901                                         if (bitblock::any(PI_error))
    902                                         {
    903                                                 assert_0_error(PI_error,"Error in PI syntax");
    904                                         }
    905                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    906                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_not(PI_closer),carry_set_1.getCarry(4),PI_Cursor));
    907                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    908                                         CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    909                                 }
    910                                 if (bitblock::any(CD_Cursor))
    911                                 {
    912                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    913                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_not(CD_closer),carry_set_1.getCarry(5),CD_Cursor));
    914                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    915                                         CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    916                                 }
    917                                 if (bitblock::any(Ct_Cursor))
    918                                 {
    919                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    920                                         carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
    921                                         BitBlock Ct_error;
    922                                         Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    923                                         BitBlock _temp3;
    924                                         carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
    925                                         carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
    926                                         BitBlock _temp4;
    927                                         carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_not(DoubleHyphen),carry_set_1.getCarry(9),_temp4));
    928                                         carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
    929                                         if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    930                                         {
    931                                                 assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
    932                                         }
    933                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    934                                         CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    935                                 }
    936                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    937                                 carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
    938                                 if (bitblock::any(simd<1>::constant<0>()))
    939                                 {
    940                                         assert_0_error(simd<1>::constant<0>(),"Error in comment, CDATA or processing instruction syntax");
    941                                 }
    942                                 carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_not(CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
    943                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    944                         }
    945                 }
    946                 else
    947                 {
    948                         carry_set_0.carryDequeueEnqueue(3,13);
    949                 }
    950                 BitBlock _temp5;
    951                 carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.getCarry(16),_temp5));
    952                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
    953                 marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    954                 marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    955                 marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    956                 carry_set_0.carryAdjust(17);
    957         }
    958        
    959         void do_final_block(struct Lex & lex,struct Marker & marker,struct CtCDPI_Callouts & ctCDPI_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
    960         {
    961                 ctCDPI_Callouts.Ct_starts = simd<1>::constant<0>();
    962                 ctCDPI_Callouts.Ct_ends = simd<1>::constant<0>();
    963                 ctCDPI_Callouts.CD_starts = simd<1>::constant<0>();
    964                 ctCDPI_Callouts.CD_ends = simd<1>::constant<0>();
    965                 ctCDPI_Callouts.PI_starts = simd<1>::constant<0>();
    966                 ctCDPI_Callouts.PI_name_starts = simd<1>::constant<0>();
    967                 ctCDPI_Callouts.PI_name_ends = simd<1>::constant<0>();
    968                 ctCDPI_Callouts.PI_ends = simd<1>::constant<0>();
    969                 BitBlock CtCDPI_starts;
    970                 CtCDPI_starts = simd<1>::constant<0>();
    971                 BitBlock CtCDPI_ends;
    972                 CtCDPI_ends = simd<1>::constant<0>();
    973                 BitBlock ctCDPI_mask;
    974                 ctCDPI_mask = simd<1>::constant<0>();
    975                 BitBlock v;
    976                 v = simd_or(lex.LAngle,lex.Hyphen);
    977                 BitBlock w;
    978                 w = simd_or(lex.Hyphen,lex.QMark);
    979                 BitBlock v1;
    980                 carry_set_0.getPending64(0) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(v,carry_set_0.getPending64(0),v1));
    981                 BitBlock w1;
    982                 carry_set_0.getPending64(1) = bitblock::srli<127>(pablo_blk_Advance_n_<1>(w,carry_set_0.getPending64(1),w1));
    983                 BitBlock LAngle_scope;
    984                 LAngle_scope = simd_andc(v1,w1);
    985                 BitBlock PI_opener;
    986                 PI_opener = simd_and(LAngle_scope,lex.QMark);
    987                 BitBlock CtCD_opener;
    988                 CtCD_opener = simd_and(LAngle_scope,lex.Exclam);
    989                 BitBlock CtCDPI_opener;
    990                 CtCDPI_opener = simd_or(PI_opener,CtCD_opener);
    991                 BitBlock CD_closer;
    992                 CD_closer = simd<1>::constant<0>();
    993                 BitBlock DoubleHyphen;
    994                 DoubleHyphen = simd_and(simd_and(v1,w1),lex.Hyphen);
    995                 if (bitblock::any(simd_or(lex.RBracket,carry_set_0.carryRange(0,2))))
    996                 {
    997                         BitBlock DoubleRBracket;
    998                         BitBlock _temp0;
    999                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(lex.RBracket,carry_set_0.getCarry(0),_temp0));
    1000                         DoubleRBracket = simd_and(_temp0,lex.RBracket);
    1001                         BitBlock _temp1;
    1002                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(DoubleRBracket,carry_set_0.getCarry(1),_temp1));
    1003                         CD_closer = simd_and(_temp1,lex.RAngle);
    1004                 }
    1005                 else
    1006                 {
    1007                         carry_set_0.carryDequeueEnqueue(0,2);
    1008                 }
    1009                 BitBlock PI_closer;
    1010                 PI_closer = simd_and(simd_andc(w1,v1),lex.RAngle);
    1011                 BitBlock CtCDPI_Cursor;
    1012                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanToFirst(simd_or(CtCDPI_opener,simd_not(EOF_mask)),carry_set_0.getCarry(2),CtCDPI_Cursor));
    1013                 if (bitblock::any(simd_and(simd_or(CtCDPI_Cursor,carry_set_0.carryRange(3,13)),EOF_mask)))
    1014                 {
    1015                         CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1016                         BitBlock PI_Cursor;
    1017                         PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1018                         BitBlock CD_Ct_Cursor;
    1019                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_0.getCarry(3),CD_Ct_Cursor));
    1020                         BitBlock CD_Cursor;
    1021                         CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1022                         BitBlock Ct_Cursor;
    1023                         Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1024                         if (bitblock::any(simd_or(PI_Cursor,carry_set_0.carryRange(4,4))))
    1025                         {
    1026                                 ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1027                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_0.getCarry(4),PI_Cursor));
    1028                                 ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1029                                 BitBlock PI_name_end;
    1030                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_0.getCarry(5),PI_name_end));
    1031                                 BitBlock PI_error;
    1032                                 PI_error = simd_and(PI_Cursor,PI_name_end);
    1033                                 BitBlock PI_noWS;
    1034                                 PI_noWS = simd_andc(PI_name_end,lex.WS);
    1035                                 BitBlock _temp2;
    1036                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_0.getCarry(6),_temp2));
    1037                                 PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    1038                                 if (bitblock::any(PI_error))
    1039                                 {
    1040                                         assert_0_error(PI_error,"Error in PI syntax");
    1041                                 }
    1042                                 ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1043                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_0.getCarry(7),PI_Cursor));
    1044                                 ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1045                                 CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1046                         }
    1047                         else
    1048                         {
    1049                                 carry_set_0.carryDequeueEnqueue(4,4);
    1050                         }
    1051                         if (bitblock::any(simd_or(CD_Cursor,carry_set_0.carryRange(8,1))))
    1052                         {
    1053                                 ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1054                                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_0.getCarry(8),CD_Cursor));
    1055                                 ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1056                                 CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1057                         }
    1058                         else
    1059                         {
    1060                                 carry_set_0.carryDequeueEnqueue(8,1);
    1061                         }
    1062                         if (bitblock::any(simd_or(Ct_Cursor,carry_set_0.carryRange(9,5))))
    1063                         {
    1064                                 ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1065                                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(9),Ct_Cursor));
    1066                                 BitBlock Ct_error;
    1067                                 Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1068                                 BitBlock _temp3;
    1069                                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_0.getCarry(10),_temp3));
    1070                                 carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_0.getCarry(11),Ct_Cursor));
    1071                                 BitBlock _temp4;
    1072                                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_0.getCarry(12),_temp4));
    1073                                 carry_set_0.getCarry(13) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_0.getCarry(13),Ct_Cursor));
    1074                                 if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1075                                 {
    1076                                         assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
    1077                                 }
    1078                                 ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1079                                 CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1080                         }
    1081                         else
    1082                         {
    1083                                 carry_set_0.carryDequeueEnqueue(9,5);
    1084                         }
    1085                         CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1086                         carry_set_0.getCarry(14) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_0.getCarry(14),ctCDPI_mask));
    1087                         if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    1088                         {
    1089                                 assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    1090                         }
    1091                         carry_set_0.getCarry(15) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_0.getCarry(15),CtCDPI_Cursor));
    1092                         while (bitblock::any(simd_and(CtCDPI_Cursor,EOF_mask)))
    1093                         {
    1094                                 CarryDeclare(carry_set_1,13,0);
    1095                                 CtCDPI_starts = simd_or(CtCDPI_starts,CtCDPI_Cursor);
    1096                                 BitBlock PI_Cursor;
    1097                                 PI_Cursor = simd_and(CtCDPI_Cursor,PI_opener);
    1098                                 BitBlock CD_Ct_Cursor;
    1099                                 carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(simd_andc(CtCDPI_Cursor,PI_Cursor),carry_set_1.getCarry(0),CD_Ct_Cursor));
    1100                                 BitBlock CD_Cursor;
    1101                                 CD_Cursor = simd_and(CD_Ct_Cursor,lex.LBracket);
    1102                                 BitBlock Ct_Cursor;
    1103                                 Ct_Cursor = simd_and(CD_Ct_Cursor,lex.Hyphen);
    1104                                 if (bitblock::any(PI_Cursor))
    1105                                 {
    1106                                         ctCDPI_Callouts.PI_starts = simd_or(ctCDPI_Callouts.PI_starts,PI_Cursor);
    1107                                         carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(PI_Cursor,carry_set_1.getCarry(1),PI_Cursor));
    1108                                         ctCDPI_Callouts.PI_name_starts = simd_or(ctCDPI_Callouts.PI_name_starts,PI_Cursor);
    1109                                         BitBlock PI_name_end;
    1110                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(PI_Cursor,lex.NameScan,carry_set_1.getCarry(2),PI_name_end));
    1111                                         BitBlock PI_error;
    1112                                         PI_error = simd_and(PI_Cursor,PI_name_end);
    1113                                         BitBlock PI_noWS;
    1114                                         PI_noWS = simd_andc(PI_name_end,lex.WS);
    1115                                         BitBlock _temp2;
    1116                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_Advance(PI_noWS,carry_set_1.getCarry(3),_temp2));
    1117                                         PI_error = simd_or(PI_error,simd_or(simd_andc(PI_noWS,lex.QMark),simd_andc(_temp2,PI_closer)));
    1118                                         if (bitblock::any(PI_error))
    1119                                         {
    1120                                                 assert_0_error(PI_error,"Error in PI syntax");
    1121                                         }
    1122                                         ctCDPI_Callouts.PI_name_ends = simd_or(ctCDPI_Callouts.PI_name_ends,PI_name_end);
    1123                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(PI_name_end,simd_andc(EOF_mask,PI_closer),carry_set_1.getCarry(4),PI_Cursor));
    1124                                         ctCDPI_Callouts.PI_ends = simd_or(ctCDPI_Callouts.PI_ends,PI_Cursor);
    1125                                         CtCDPI_ends = simd_or(CtCDPI_ends,PI_Cursor);
    1126                                 }
    1127                                 if (bitblock::any(CD_Cursor))
    1128                                 {
    1129                                         ctCDPI_Callouts.CD_starts = simd_or(ctCDPI_Callouts.CD_starts,CD_Cursor);
    1130                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(CD_Cursor,simd_andc(EOF_mask,CD_closer),carry_set_1.getCarry(5),CD_Cursor));
    1131                                         ctCDPI_Callouts.CD_ends = simd_or(ctCDPI_Callouts.CD_ends,CD_Cursor);
    1132                                         CtCDPI_ends = simd_or(CtCDPI_ends,CD_Cursor);
    1133                                 }
    1134                                 if (bitblock::any(Ct_Cursor))
    1135                                 {
    1136                                         ctCDPI_Callouts.Ct_starts = simd_or(ctCDPI_Callouts.Ct_starts,Ct_Cursor);
    1137                                         carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(6),Ct_Cursor));
    1138                                         BitBlock Ct_error;
    1139                                         Ct_error = simd_andc(Ct_Cursor,lex.Hyphen);
    1140                                         BitBlock _temp3;
    1141                                         carry_set_1.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(Ct_Cursor,carry_set_1.getCarry(7),_temp3));
    1142                                         carry_set_1.getCarry(8) = bitblock::srli<127>(pablo_blk_Advance(_temp3,carry_set_1.getCarry(8),Ct_Cursor));
    1143                                         BitBlock _temp4;
    1144                                         carry_set_1.getCarry(9) = bitblock::srli<127>(pablo_blk_ScanThru(Ct_Cursor,simd_andc(EOF_mask,DoubleHyphen),carry_set_1.getCarry(9),_temp4));
    1145                                         carry_set_1.getCarry(10) = bitblock::srli<127>(pablo_blk_Advance(_temp4,carry_set_1.getCarry(10),Ct_Cursor));
    1146                                         if (bitblock::any(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle))))
    1147                                         {
    1148                                                 assert_0_error(simd_or(Ct_error,simd_andc(Ct_Cursor,lex.RAngle)),"Error in comment syntax");
    1149                                         }
    1150                                         ctCDPI_Callouts.Ct_ends = simd_or(ctCDPI_Callouts.Ct_ends,Ct_Cursor);
    1151                                         CtCDPI_ends = simd_or(CtCDPI_ends,Ct_Cursor);
    1152                                 }
    1153                                 CtCDPI_Cursor = simd_or(simd_or(PI_Cursor,CD_Cursor),Ct_Cursor);
    1154                                 carry_set_1.getCarry(11) = bitblock::srli<127>(pablo_blk_InclusiveSpan(CtCDPI_starts,CtCDPI_ends,carry_set_1.getCarry(11),ctCDPI_mask));
    1155                                 if (bitblock::any(simd_andc(ctCDPI_mask,EOF_mask)))
    1156                                 {
    1157                                         assert_0_error(simd_andc(ctCDPI_mask,EOF_mask),"Error in comment, CDATA or processing instruction syntax");
    1158                                 }
    1159                                 carry_set_1.getCarry(12) = bitblock::srli<127>(pablo_blk_ScanThru(CtCDPI_Cursor,simd_andc(EOF_mask,CtCDPI_opener),carry_set_1.getCarry(12),CtCDPI_Cursor));
    1160                                 LocalCarryCombine(carry_set_0,carry_set_1,3,13);
    1161                         }
    1162                 }
    1163                 else
    1164                 {
    1165                         carry_set_0.carryDequeueEnqueue(3,13);
    1166                 }
    1167                 BitBlock _temp5;
    1168                 carry_set_0.getCarry(16) = bitblock::srli<127>(pablo_blk_InclusiveSpan(simd_or(ctCDPI_Callouts.Ct_starts,ctCDPI_Callouts.PI_starts),simd_or(ctCDPI_Callouts.Ct_ends,ctCDPI_Callouts.PI_ends),carry_set_0.getCarry(16),_temp5));
    1169                 check_streams.misc_mask = simd_and(simd_or(simd_or(simd_or(lex.WS,lex.LAngle),_temp5),CtCDPI_starts),EOF_mask);
    1170                 marker.LAngle_scope = simd_andc(LAngle_scope,ctCDPI_mask);
    1171                 marker.Ref_opener = simd_andc(lex.RefStart,ctCDPI_mask);
    1172                 marker.CD_closer = simd_andc(CD_closer,ctCDPI_mask);
    1173         }
    1174        
    1175         void clear()
    1176         {
    1177                 carry_set_0.setCarry(carry_set_0.carryFlip(2),2);
    1178         }
    1179        
    1180         CarryDeclare(carry_set_0,17,2);
    1181 };
    1182  
    1183 struct Parse_tags
    1184 {
    1185         Parse_tags()
    1186         {
    1187         }
    1188        
    1189         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts)
    1190         {
    1191                 BitBlock EqExpected;
    1192                 EqExpected = simd<1>::constant<0>();
    1193                 BitBlock AttListEnd;
    1194                 AttListEnd = simd<1>::constant<0>();
    1195                 BitBlock DQuoteDelim;
    1196                 DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
    1197                 BitBlock SQuoteDelim;
    1198                 SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
    1199                 BitBlock AttListDelim;
    1200                 AttListDelim = simd_or(lex.Slash,lex.RAngle);
    1201                 tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
    1202                 tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    1203                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),tag_Callouts.ElemName_ends));
    1204                 BitBlock ParseError;
    1205                 ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    1206                 tag_Callouts.AttName_starts = simd<1>::constant<0>();
    1207                 tag_Callouts.AttName_ends = simd<1>::constant<0>();
    1208                 tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    1209                 tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1210                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
    1211                 {
    1212                         BitBlock AfterWS;
    1213                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
    1214                         AttListEnd = simd_and(AfterWS,AttListDelim);
    1215                         BitBlock AttNameStart;
    1216                         AttNameStart = simd_andc(AfterWS,AttListDelim);
    1217                         if (bitblock::any(simd_or(AttNameStart,carry_set_0.carryRange(2,7))))
    1218                         {
    1219                                 ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1220                                 tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1221                                 BitBlock AttNameFollow;
    1222                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
    1223                                 tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1224                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    1225                                 {
    1226                                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
    1227                                 }
    1228                                 else
    1229                                 {
    1230                                         EqExpected = AttNameFollow;
    1231                                         carry_set_0.carryDequeueEnqueue(3,1);
    1232                                 }
    1233                                 ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1234                                 BitBlock AttValPos;
    1235                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
    1236                                 tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1237                                 BitBlock DQuoteAttVal;
    1238                                 DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1239                                 BitBlock SQuoteAttVal;
    1240                                 SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1241                                 BitBlock DQuoteAttEnd;
    1242                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
    1243                                 BitBlock SQuoteAttEnd;
    1244                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
    1245                                 BitBlock AttValEnd;
    1246                                 AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1247                                 ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1248                                 BitBlock AttValFollow;
    1249                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
    1250                                 tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1251                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    1252                                 {
    1253                                         carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
    1254                                         AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1255                                         AttNameStart = simd_andc(AfterWS,AttListDelim);
    1256                                 }
    1257                                 else
    1258                                 {
    1259                                         AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1260                                         AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1261                                         carry_set_0.carryDequeueEnqueue(8,1);
    1262                                 }
    1263                                 ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1264                                 while (bitblock::any(AttNameStart))
    1265                                 {
    1266                                         CarryDeclare(carry_set_1,7,0);
    1267                                         ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1268                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1269                                         BitBlock AttNameFollow;
    1270                                         carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
    1271                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1272                                         if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    1273                                         {
    1274                                                 carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
    1275                                         }
    1276                                         else
    1277                                         {
    1278                                                 EqExpected = AttNameFollow;
    1279                                         }
    1280                                         ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1281                                         BitBlock AttValPos;
    1282                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
    1283                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1284                                         BitBlock DQuoteAttVal;
    1285                                         DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1286                                         BitBlock SQuoteAttVal;
    1287                                         SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1288                                         BitBlock DQuoteAttEnd;
    1289                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_not(DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
    1290                                         BitBlock SQuoteAttEnd;
    1291                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_not(SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
    1292                                         BitBlock AttValEnd;
    1293                                         AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1294                                         ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1295                                         BitBlock AttValFollow;
    1296                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
    1297                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1298                                         if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    1299                                         {
    1300                                                 carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
    1301                                                 AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1302                                                 AttNameStart = simd_andc(AfterWS,AttListDelim);
    1303                                         }
    1304                                         else
    1305                                         {
    1306                                                 AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1307                                                 AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1308                                         }
    1309                                         ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1310                                         LocalCarryCombine(carry_set_0,carry_set_1,2,7);
    1311                                 }
    1312                         }
    1313                         else
    1314                         {
    1315                                 carry_set_0.carryDequeueEnqueue(2,7);
    1316                         }
    1317                 }
    1318                 else
    1319                 {
    1320                         AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    1321                         ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1322                         carry_set_0.carryDequeueEnqueue(1,8);
    1323                 }
    1324                 BitBlock STagEnds;
    1325                 STagEnds = simd_and(AttListEnd,lex.RAngle);
    1326                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),tag_Callouts.EmptyTag_marks));
    1327                 ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    1328                 BitBlock EndTagEnds;
    1329                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
    1330                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
    1331                 {
    1332                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
    1333                 }
    1334                 else
    1335                 {
    1336                         carry_set_0.carryDequeueEnqueue(11,1);
    1337                 }
    1338                 ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
    1339                 if (bitblock::any(ParseError))
    1340                 {
    1341                         assert_0_error(ParseError,"Tag parsing error found");
    1342                 }
    1343                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
    1344                 carry_set_0.carryAdjust(13);
    1345         }
    1346        
    1347         void do_final_block(struct Lex & lex,struct Marker & marker,struct Tag_Callouts & tag_Callouts,BitBlock & EOF_mask)
    1348         {
    1349                 BitBlock EqExpected;
    1350                 EqExpected = simd<1>::constant<0>();
    1351                 BitBlock AttListEnd;
    1352                 AttListEnd = simd<1>::constant<0>();
    1353                 BitBlock DQuoteDelim;
    1354                 DQuoteDelim = simd_or(lex.DQuote,lex.LAngle);
    1355                 BitBlock SQuoteDelim;
    1356                 SQuoteDelim = simd_or(lex.SQuote,lex.LAngle);
    1357                 BitBlock AttListDelim;
    1358                 AttListDelim = simd_or(lex.Slash,lex.RAngle);
    1359                 tag_Callouts.ElemName_starts = simd_andc(marker.LAngle_scope,lex.Slash);
    1360                 tag_Callouts.EndTag_marks = simd_and(marker.LAngle_scope,lex.Slash);
    1361                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_starts,lex.NameScan,carry_set_0.getCarry(0),tag_Callouts.ElemName_ends));
    1362                 BitBlock ParseError;
    1363                 ParseError = simd_and(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends);
    1364                 tag_Callouts.AttName_starts = simd<1>::constant<0>();
    1365                 tag_Callouts.AttName_ends = simd<1>::constant<0>();
    1366                 tag_Callouts.AttVal_starts = simd<1>::constant<0>();
    1367                 tag_Callouts.AttVal_ends = simd<1>::constant<0>();
    1368                 if (bitblock::any(simd_or(simd_and(tag_Callouts.ElemName_ends,lex.WS),carry_set_0.carryRange(1,8))))
    1369                 {
    1370                         BitBlock AfterWS;
    1371                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(tag_Callouts.ElemName_ends,lex.WS,carry_set_0.getCarry(1),AfterWS));
    1372                         AttListEnd = simd_and(AfterWS,AttListDelim);
    1373                         BitBlock AttNameStart;
    1374                         AttNameStart = simd_andc(AfterWS,AttListDelim);
    1375                         if (bitblock::any(simd_and(simd_or(AttNameStart,carry_set_0.carryRange(2,7)),EOF_mask)))
    1376                         {
    1377                                 ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1378                                 tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1379                                 BitBlock AttNameFollow;
    1380                                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_0.getCarry(2),AttNameFollow));
    1381                                 tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1382                                 if (bitblock::any(simd_or(simd_and(AttNameFollow,lex.WS),carry_set_0.carryRange(3,1))))
    1383                                 {
    1384                                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_0.getCarry(3),EqExpected));
    1385                                 }
    1386                                 else
    1387                                 {
    1388                                         EqExpected = AttNameFollow;
    1389                                         carry_set_0.carryDequeueEnqueue(3,1);
    1390                                 }
    1391                                 ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1392                                 BitBlock AttValPos;
    1393                                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_0.getCarry(4),AttValPos));
    1394                                 tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1395                                 BitBlock DQuoteAttVal;
    1396                                 DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1397                                 BitBlock SQuoteAttVal;
    1398                                 SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1399                                 BitBlock DQuoteAttEnd;
    1400                                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_0.getCarry(5),DQuoteAttEnd));
    1401                                 BitBlock SQuoteAttEnd;
    1402                                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_0.getCarry(6),SQuoteAttEnd));
    1403                                 BitBlock AttValEnd;
    1404                                 AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1405                                 ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1406                                 BitBlock AttValFollow;
    1407                                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_0.getCarry(7),AttValFollow));
    1408                                 tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1409                                 if (bitblock::any(simd_or(simd_and(AttValFollow,lex.WS),carry_set_0.carryRange(8,1))))
    1410                                 {
    1411                                         carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_0.getCarry(8),AfterWS));
    1412                                         AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1413                                         AttNameStart = simd_andc(AfterWS,AttListDelim);
    1414                                 }
    1415                                 else
    1416                                 {
    1417                                         AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1418                                         AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1419                                         carry_set_0.carryDequeueEnqueue(8,1);
    1420                                 }
    1421                                 ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1422                                 while (bitblock::any(simd_and(AttNameStart,EOF_mask)))
    1423                                 {
    1424                                         CarryDeclare(carry_set_1,7,0);
    1425                                         ParseError = simd_or(ParseError,simd_andc(AttNameStart,lex.NameScan));
    1426                                         tag_Callouts.AttName_starts = simd_or(tag_Callouts.AttName_starts,AttNameStart);
    1427                                         BitBlock AttNameFollow;
    1428                                         carry_set_1.getCarry(0) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameStart,lex.NameScan,carry_set_1.getCarry(0),AttNameFollow));
    1429                                         tag_Callouts.AttName_ends = simd_or(tag_Callouts.AttName_ends,AttNameFollow);
    1430                                         if (bitblock::any(simd_and(AttNameFollow,lex.WS)))
    1431                                         {
    1432                                                 carry_set_1.getCarry(1) = bitblock::srli<127>(pablo_blk_ScanThru(AttNameFollow,lex.WS,carry_set_1.getCarry(1),EqExpected));
    1433                                         }
    1434                                         else
    1435                                         {
    1436                                                 EqExpected = AttNameFollow;
    1437                                         }
    1438                                         ParseError = simd_or(ParseError,simd_andc(EqExpected,lex.Equals));
    1439                                         BitBlock AttValPos;
    1440                                         carry_set_1.getCarry(2) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(EqExpected,lex.WS,carry_set_1.getCarry(2),AttValPos));
    1441                                         tag_Callouts.AttVal_starts = simd_or(tag_Callouts.AttVal_starts,AttValPos);
    1442                                         BitBlock DQuoteAttVal;
    1443                                         DQuoteAttVal = simd_and(AttValPos,lex.DQuote);
    1444                                         BitBlock SQuoteAttVal;
    1445                                         SQuoteAttVal = simd_and(AttValPos,lex.SQuote);
    1446                                         BitBlock DQuoteAttEnd;
    1447                                         carry_set_1.getCarry(3) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(DQuoteAttVal,simd_andc(EOF_mask,DQuoteDelim),carry_set_1.getCarry(3),DQuoteAttEnd));
    1448                                         BitBlock SQuoteAttEnd;
    1449                                         carry_set_1.getCarry(4) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(SQuoteAttVal,simd_andc(EOF_mask,SQuoteDelim),carry_set_1.getCarry(4),SQuoteAttEnd));
    1450                                         BitBlock AttValEnd;
    1451                                         AttValEnd = simd_or(DQuoteAttEnd,SQuoteAttEnd);
    1452                                         ParseError = simd_or(ParseError,simd_andc(simd_or(AttValPos,AttValEnd),simd_or(lex.DQuote,lex.SQuote)));
    1453                                         BitBlock AttValFollow;
    1454                                         carry_set_1.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(AttValEnd,carry_set_1.getCarry(5),AttValFollow));
    1455                                         tag_Callouts.AttVal_ends = simd_or(tag_Callouts.AttVal_ends,AttValFollow);
    1456                                         if (bitblock::any(simd_and(AttValFollow,lex.WS)))
    1457                                         {
    1458                                                 carry_set_1.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(AttValFollow,lex.WS,carry_set_1.getCarry(6),AfterWS));
    1459                                                 AttListEnd = simd_or(AttListEnd,simd_and(AfterWS,AttListDelim));
    1460                                                 AttNameStart = simd_andc(AfterWS,AttListDelim);
    1461                                         }
    1462                                         else
    1463                                         {
    1464                                                 AttListEnd = simd_or(AttListEnd,simd_and(AttValFollow,AttListDelim));
    1465                                                 AttNameStart = simd_andc(AttValFollow,AttListDelim);
    1466                                         }
    1467                                         ParseError = simd_or(ParseError,simd_and(AttValFollow,AttNameStart));
    1468                                         LocalCarryCombine(carry_set_0,carry_set_1,2,7);
    1469                                 }
    1470                         }
    1471                         else
    1472                         {
    1473                                 carry_set_0.carryDequeueEnqueue(2,7);
    1474                         }
    1475                 }
    1476                 else
    1477                 {
    1478                         AttListEnd = simd_and(tag_Callouts.ElemName_ends,AttListDelim);
    1479                         ParseError = simd_or(ParseError,simd_andc(tag_Callouts.ElemName_ends,AttListDelim));
    1480                         carry_set_0.carryDequeueEnqueue(1,8);
    1481                 }
    1482                 BitBlock STagEnds;
    1483                 STagEnds = simd_and(AttListEnd,lex.RAngle);
    1484                 carry_set_0.getCarry(9) = bitblock::srli<127>(pablo_blk_Advance(simd_and(AttListEnd,lex.Slash),carry_set_0.getCarry(9),tag_Callouts.EmptyTag_marks));
    1485                 ParseError = simd_or(ParseError,simd_andc(tag_Callouts.EmptyTag_marks,lex.RAngle));
    1486                 BitBlock EndTagEnds;
    1487                 carry_set_0.getCarry(10) = bitblock::srli<127>(pablo_blk_AdvanceThenScanThru(tag_Callouts.EndTag_marks,lex.NameScan,carry_set_0.getCarry(10),EndTagEnds));
    1488                 if (bitblock::any(simd_or(simd_and(EndTagEnds,lex.WS),carry_set_0.carryRange(11,1))))
    1489                 {
    1490                         carry_set_0.getCarry(11) = bitblock::srli<127>(pablo_blk_ScanThru(EndTagEnds,lex.WS,carry_set_0.getCarry(11),EndTagEnds));
    1491                 }
    1492                 else
    1493                 {
    1494                         carry_set_0.carryDequeueEnqueue(11,1);
    1495                 }
    1496                 ParseError = simd_or(ParseError,simd_andc(EndTagEnds,lex.RAngle));
    1497                 if (bitblock::any(ParseError))
    1498                 {
    1499                         assert_0_error(ParseError,"Tag parsing error found");
    1500                 }
    1501                 carry_set_0.getCarry(12) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttVal_starts,tag_Callouts.AttVal_ends,carry_set_0.getCarry(12),tag_Callouts.AttVal_spans));
    1502         }
    1503        
    1504         void clear()
    1505         {
    1506                
    1507         }
    1508        
    1509         CarryDeclare(carry_set_0,13,0);
    1510 };
    1511  
    1512 struct Parse_refs
    1513 {
    1514         Parse_refs()
    1515         {
    1516         }
    1517        
    1518         IDISA_INLINE void do_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts)
    1519         {
    1520                 ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    1521                 ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    1522                 ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    1523                 ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    1524                 ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    1525                 ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    1526                 BitBlock ref_error;
    1527                 ref_error = simd<1>::constant<0>();
    1528                 if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
    1529                 {
    1530                         BitBlock Ref_scope;
    1531                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
    1532                         BitBlock NumRef2;
    1533                         NumRef2 = simd_and(Ref_scope,lex.Hash);
    1534                         ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    1535                         BitBlock NumRef3;
    1536                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
    1537                         BitBlock HexRef3;
    1538                         HexRef3 = simd_and(NumRef3,lex.x);
    1539                         ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    1540                         carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
    1541                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),ref_Callouts.GenRef_ends));
    1542                         carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),ref_Callouts.DecRef_ends));
    1543                         carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),ref_Callouts.HexRef_ends));
    1544                         BitBlock ref_error1;
    1545                         ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
    1546                         BitBlock ref_error2;
    1547                         ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
    1548                         BitBlock ref_ends;
    1549                         ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
    1550                         BitBlock ref_error3;
    1551                         ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    1552                         if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    1553                         {
    1554                                 assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
    1555                         }
    1556                 }
    1557                 else
    1558                 {
    1559                         carry_set_0.carryDequeueEnqueue(0,6);
    1560                 }
    1561                 carry_set_0.carryAdjust(6);
    1562         }
    1563        
    1564         void do_final_block(struct Lex & lex,struct Marker & marker,struct Ref_Callouts & ref_Callouts,BitBlock & EOF_mask)
    1565         {
    1566                 ref_Callouts.GenRef_starts = simd<1>::constant<0>();
    1567                 ref_Callouts.GenRef_ends = simd<1>::constant<0>();
    1568                 ref_Callouts.DecRef_starts = simd<1>::constant<0>();
    1569                 ref_Callouts.DecRef_ends = simd<1>::constant<0>();
    1570                 ref_Callouts.HexRef_starts = simd<1>::constant<0>();
    1571                 ref_Callouts.HexRef_ends = simd<1>::constant<0>();
    1572                 BitBlock ref_error;
    1573                 ref_error = simd<1>::constant<0>();
    1574                 if (bitblock::any(simd_or(marker.Ref_opener,carry_set_0.carryRange(0,6))))
    1575                 {
    1576                         BitBlock Ref_scope;
    1577                         carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_Advance(marker.Ref_opener,carry_set_0.getCarry(0),Ref_scope));
    1578                         BitBlock NumRef2;
    1579                         NumRef2 = simd_and(Ref_scope,lex.Hash);
    1580                         ref_Callouts.GenRef_starts = simd_andc(Ref_scope,lex.Hash);
    1581                         BitBlock NumRef3;
    1582                         carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_Advance(NumRef2,carry_set_0.getCarry(1),NumRef3));
    1583                         BitBlock HexRef3;
    1584                         HexRef3 = simd_and(NumRef3,lex.x);
    1585                         ref_Callouts.DecRef_starts = simd_andc(NumRef3,lex.x);
    1586                         carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_Advance(HexRef3,carry_set_0.getCarry(2),ref_Callouts.HexRef_starts));
    1587                         carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.GenRef_starts,lex.NameScan,carry_set_0.getCarry(3),ref_Callouts.GenRef_ends));
    1588                         carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.DecRef_starts,lex.Digit,carry_set_0.getCarry(4),ref_Callouts.DecRef_ends));
    1589                         carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_ScanThru(ref_Callouts.HexRef_starts,lex.Hex,carry_set_0.getCarry(5),ref_Callouts.HexRef_ends));
    1590                         BitBlock ref_error1;
    1591                         ref_error1 = simd_andc(ref_Callouts.DecRef_starts,lex.Digit);
    1592                         BitBlock ref_error2;
    1593                         ref_error2 = simd_andc(ref_Callouts.HexRef_starts,lex.Hex);
    1594                         BitBlock ref_ends;
    1595                         ref_ends = simd_or(simd_or(ref_Callouts.GenRef_ends,ref_Callouts.DecRef_ends),ref_Callouts.HexRef_ends);
    1596                         BitBlock ref_error3;
    1597                         ref_error3 = simd_andc(ref_ends,lex.Semicolon);
    1598                         if (bitblock::any(simd_or(simd_or(ref_error1,ref_error2),ref_error3)))
    1599                         {
    1600                                 assert_0_error(simd_or(simd_or(ref_error1,ref_error2),ref_error3),"Reference error found");
    1601                         }
    1602                 }
    1603                 else
    1604                 {
    1605                         carry_set_0.carryDequeueEnqueue(0,6);
    1606                 }
    1607         }
    1608        
    1609         void clear()
    1610         {
    1611                
    1612         }
    1613        
    1614         CarryDeclare(carry_set_0,6,0);
    1615 };
    1616  
    1617 struct Validate_xml_names
    1618 {
    1619         Validate_xml_names()
    1620         {
    1621         }
    1622        
    1623         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)
    1624         {
    1625                 BitBlock PI_names;
    1626                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),PI_names));
    1627                 BitBlock GenRefs;
    1628                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),GenRefs));
    1629                 BitBlock ElemNames;
    1630                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),ElemNames));
    1631                 BitBlock AttNames;
    1632                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),AttNames));
    1633                 BitBlock qname_stream;
    1634                 qname_stream = simd_or(ElemNames,AttNames);
    1635                 BitBlock ncname_stream;
    1636                 ncname_stream = simd_or(PI_names,GenRefs);
    1637                 BitBlock name_stream;
    1638                 name_stream = simd_or(qname_stream,ncname_stream);
    1639                 BitBlock name_start;
    1640                 BitBlock _temp0;
    1641                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
    1642                 name_start = simd_andc(name_stream,_temp0);
    1643                 BitBlock name_cursor;
    1644                 BitBlock _temp1;
    1645                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
    1646                 name_cursor = simd_andc(name_stream,_temp1);
    1647                 BitBlock void_prefix_err;
    1648                 void_prefix_err = simd_and(name_cursor,lex.Colon);
    1649                 BitBlock namespace_sep;
    1650                 BitBlock _temp2;
    1651                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),_temp2));
    1652                 namespace_sep = simd_and(_temp2,lex.Colon);
    1653                 BitBlock local_part_start;
    1654                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
    1655                 BitBlock local_part_err;
    1656                 local_part_err = simd_andc(local_part_start,lex.NameScan);
    1657                 BitBlock colon2_err;
    1658                 BitBlock _temp3;
    1659                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),_temp3));
    1660                 colon2_err = simd_and(_temp3,lex.Colon);
    1661                 BitBlock ncname_err;
    1662                 ncname_err = simd_and(ncname_stream,lex.Colon);
    1663                 if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    1664                 {
    1665                         assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
    1666                 }
    1667                 check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
    1668                 check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
    1669                 carry_set_0.carryAdjust(9);
    1670         }
    1671        
    1672         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)
    1673         {
    1674                 BitBlock PI_names;
    1675                 carry_set_0.getCarry(0) = bitblock::srli<127>(pablo_blk_SpanUpTo(ctCDPI_Callouts.PI_name_starts,ctCDPI_Callouts.PI_name_ends,carry_set_0.getCarry(0),PI_names));
    1676                 BitBlock GenRefs;
    1677                 carry_set_0.getCarry(1) = bitblock::srli<127>(pablo_blk_SpanUpTo(ref_Callouts.GenRef_starts,ref_Callouts.GenRef_ends,carry_set_0.getCarry(1),GenRefs));
    1678                 BitBlock ElemNames;
    1679                 carry_set_0.getCarry(2) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.ElemName_starts,tag_Callouts.ElemName_ends,carry_set_0.getCarry(2),ElemNames));
    1680                 BitBlock AttNames;
    1681                 carry_set_0.getCarry(3) = bitblock::srli<127>(pablo_blk_SpanUpTo(tag_Callouts.AttName_starts,tag_Callouts.AttName_ends,carry_set_0.getCarry(3),AttNames));
    1682                 BitBlock qname_stream;
    1683                 qname_stream = simd_or(ElemNames,AttNames);
    1684                 BitBlock ncname_stream;
    1685                 ncname_stream = simd_or(PI_names,GenRefs);
    1686                 BitBlock name_stream;
    1687                 name_stream = simd_or(qname_stream,ncname_stream);
    1688                 BitBlock name_start;
    1689                 BitBlock _temp0;
    1690                 carry_set_0.getCarry(4) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(4),_temp0));
    1691                 name_start = simd_andc(name_stream,_temp0);
    1692                 BitBlock name_cursor;
    1693                 BitBlock _temp1;
    1694                 carry_set_0.getCarry(5) = bitblock::srli<127>(pablo_blk_Advance(name_stream,carry_set_0.getCarry(5),_temp1));
    1695                 name_cursor = simd_andc(name_stream,_temp1);
    1696                 BitBlock void_prefix_err;
    1697                 void_prefix_err = simd_and(name_cursor,lex.Colon);
    1698                 BitBlock namespace_sep;
    1699                 BitBlock _temp2;
    1700                 carry_set_0.getCarry(6) = bitblock::srli<127>(pablo_blk_ScanThru(name_cursor,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(6),_temp2));
    1701                 namespace_sep = simd_and(_temp2,lex.Colon);
    1702                 BitBlock local_part_start;
    1703                 carry_set_0.getCarry(7) = bitblock::srli<127>(pablo_blk_Advance(namespace_sep,carry_set_0.getCarry(7),local_part_start));
    1704                 BitBlock local_part_err;
    1705                 local_part_err = simd_andc(local_part_start,lex.NameScan);
    1706                 BitBlock colon2_err;
    1707                 BitBlock _temp3;
    1708                 carry_set_0.getCarry(8) = bitblock::srli<127>(pablo_blk_ScanThru(local_part_start,simd_andc(lex.NameScan,lex.Colon),carry_set_0.getCarry(8),_temp3));
    1709                 colon2_err = simd_and(_temp3,lex.Colon);
    1710                 BitBlock ncname_err;
    1711                 ncname_err = simd_and(ncname_stream,lex.Colon);
    1712                 if (bitblock::any(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err)))
    1713                 {
    1714                         assert_0_error(simd_or(simd_or(simd_or(void_prefix_err,local_part_err),colon2_err),ncname_err),"name syntax error");
    1715                 }
    1716                 check_streams.non_ascii_name_starts = simd_andc(name_start,lex.ASCII_name_start);
    1717                 check_streams.non_ascii_names = simd_andc(simd_andc(simd_andc(name_stream,name_start),lex.ASCII_name_char),u8.suffix);
    1718         }
    1719        
    1720         void clear()
    1721         {
    1722                
    1723         }
    1724        
    1725         CarryDeclare(carry_set_0,9,0);
    1726 };
    1727  
    1728 struct Do_check_streams
    1729 {
    1730         Do_check_streams()
    1731         {
    1732         }
    1733        
    1734         IDISA_INLINE void do_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams)
    1735         {
    1736                 if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
    1737                 {
    1738                         assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
    1739                 }
    1740                 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);
    1741                 check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
    1742                 check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
    1743         }
    1744        
    1745         void do_final_block(struct Marker & marker,struct Tag_Callouts & tag_Callouts,struct Check_streams & check_streams,BitBlock & EOF_mask)
    1746         {
    1747                 if (bitblock::any(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans)))
    1748                 {
    1749                         assert_0_error(simd_andc(marker.CD_closer,tag_Callouts.AttVal_spans),"Error: ]]> in text");
    1750                 }
    1751                 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);
    1752                 check_streams.name_follows = simd_or(tag_Callouts.ElemName_ends,tag_Callouts.AttName_ends);
    1753                 check_streams.att_refs = simd_and(tag_Callouts.AttVal_spans,marker.Ref_opener);
    1754         }
    1755        
    1756         void clear()
    1757         {
    1758                
    1759         }
    1760        
    1761         CarryDeclare(carry_set_0,0,0);
    1762 };
    1763  
    1764188
    1765189// }
  • proto/s2k/trunk/framework/src/s2k/lexicalAnalyzer/Lextant.java

    r3764 r3767  
    3838        IF("if", "main"),
    3939        WHILE("while", "main"),
     40        FILTER("filter", "main"),
    4041        RETURN("return", "main"),
    4142        DIVIDE_ASSIGN("/=", "main"),
    4243        ELSE("else", "main"),
    43         FUNCTION("function", "main"),
    4444        LCURLY("{", "main"),
    4545        AND("&", "main"),
  • proto/s2k/trunk/framework/src/s2k/parser/Parser.java

    r3764 r3767  
    5555                result.setProductionTag(1);
    5656                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    57                 while( nowReading.isLextant(Lextant.FUNCTION, Lextant.STRUCT) ) {
     57                while( nowReading.isLextant(Lextant.FILTER, Lextant.STRUCT) ) {
    5858                        if( nowReading.isLextant(Lextant.STRUCT) ) {
    5959                                {
     
    6363                                }
    6464                        }
    65                         else if( nowReading.isLextant(Lextant.FUNCTION) ) {
     65                        else if( nowReading.isLextant(Lextant.FILTER) ) {
    6666                                {
    6767                                        ASTNode child = parseFuncDef();
     
    7171                        }
    7272                        else {
    73                                 return syntaxErrorNode("[FUNCTION¹, STRUCT¹]");
     73                                return syntaxErrorNode("[FILTER¹, STRUCT¹]");
    7474                        }
    7575                }
     
    200200         
    201201        public ASTNode parseFuncDef() {
    202                 if( !(nowReading.isLextant(Lextant.FUNCTION)) ) {
    203                         return syntaxErrorNode("funcDef² [FUNCTION¹]");
     202                if( !(nowReading.isLextant(Lextant.FILTER)) ) {
     203                        return syntaxErrorNode("funcDef² [FILTER¹]");
    204204                }
    205205       
     
    208208                result.setProductionTag(7);
    209209                RevList<ASTNode> allChildren = new ReverseAccessibleArrayList<ASTNode>();
    210                 expect(Lextant.FUNCTION);
     210                expect(Lextant.FILTER);
    211211                {
    212212                        ASTNode child = parseFuncName();
Note: See TracChangeset for help on using the changeset viewer.