Changeset 1443


Ignore:
Timestamp:
Sep 14, 2011, 6:41:16 PM (8 years ago)
Author:
cameron
Message:

Transition mark at elem name end; error_tracker_NoteError as simple name

Location:
proto/Xerces
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • proto/Xerces/parabix2_xerces.py

    r1440 r1443  
    187187        lex_error = x00_x1F &~ lex.WS
    188188        if pablo.inFile(lex_error):
    189                 error_tracker.NoteError("Error: illegal character", lex_error)
     189                error_tracker_NoteError("Error: illegal character", lex_error)
    190190               
    191191       
     
    270270                u8_error |= u8mismatch | u8_FFFE_FFFF
    271271                if u8_error:
    272                         error_tracker.NoteError("UTF-8 error found", (u8_error))
     272                        error_tracker_NoteError("UTF-8 error found", (u8_error))
    273273                       
    274274       
     
    323323                        PI_error |= pablo.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
    324324                        if PI_error:
    325                                 error_tracker.NoteError("Error in PI syntax", PI_name_end)
     325                                error_tracker_NoteError("Error in PI syntax", PI_name_end)
    326326                        callouts.Symbol_ends |= PI_name_end
    327327                        callouts.Transition_marks |= PI_name_end
     
    345345                        CtCDPI_ends |= Ct_Cursor
    346346                        if Ct_error:
    347                                 error_tracker.NoteError("Error in comment syntax", Ct_error)
     347                                error_tracker_NoteError("Error in comment syntax", Ct_error)
    348348
    349349                # Common processing
     
    355355       
    356356                if ctCDPI_error:
    357                         error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
     357                        error_tracker_NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
    358358               
    359359        callouts.Transition_marks = CtCDPI_starts | CtCDPI_ends
     
    386386        elem_name_ends = pablo.ScanThru(ElemName_starts, lex.NameScan)
    387387        callouts.Symbol_ends = elem_name_ends
     388        callouts.Transition_marks |= elem_name_ends
    388389        # Must have at least one name character for a legal start tag.
    389390        # Mark any occurrences of null names as errors.
     
    456457        ParseError |= EndTagEnds & ~lex.RAngle
    457458        if ParseError:
    458                 error_tracker.NoteError("Tag parsing error found", (ParseError))
     459                error_tracker_NoteError("Tag parsing error found", (ParseError))
    459460
    460461        callouts.Transition_marks |= STagEnds | EmptyTag_marks | EndTagEnds
     
    473474                ref_error = ref_ends &~ lex.Semicolon
    474475                if ref_error:
    475                         error_tracker.NoteError("Reference error found", ref_error)
     476                        error_tracker_NoteError("Reference error found", ref_error)
    476477                callouts.Symbol_ends |= ref_ends
    477478
     
    480481        CD_end_error = marker.CD_closer
    481482        if CD_end_error:
    482                 error_tracker.NoteError("Error: ]]> in text", CD_end_error)
     483                error_tracker_NoteError("Error: ]]> in text", CD_end_error)
    483484        callouts.Nonplain = u8.prefix | u8.suffix | lex.CR | marker.Ref_opener | marker.LAngle
    484485     
  • proto/Xerces/src/xmlwf.cpp

    r1437 r1443  
    440440        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
    441441        if (bitblock_has_bit(ParseError)) {
    442           error_tracker.NoteError("Tag parsing error found", ParseError);
     442          error_tracker_NoteError("Tag parsing error found", ParseError);
     443          MoreStuff();
    443444        }
    444445        callouts.Transition_marks = simd_or(callouts.Transition_marks, simd_or(simd_or(STagEnds, EmptyTag_marks), EndTagEnds));
     
    559560        ParseError = simd_or(ParseError, simd_andc(EndTagEnds, lex.RAngle));
    560561        if (bitblock_has_bit(ParseError)) {
    561           error_tracker.NoteError("Tag parsing error found", ParseError);
     562          error_tracker_NoteError("Tag parsing error found", ParseError);
     563          MoreStuff();
    562564        }
    563565        callouts.Transition_marks = simd_or(callouts.Transition_marks, simd_or(simd_or(STagEnds, EmptyTag_marks), EndTagEnds));
     
    576578CarryInit(carryQ, 10); }
    577579  void do_block(Basis_bits & basis_bits, Lex & lex, U8 & u8) {
     580                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
     581                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
     582                BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
     583                BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
     584                BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
     585                BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
     586                BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
     587                BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
     588                BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
     589                BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
     590                BitBlock E0_F0_scope, ED_F4_scope, u8lastscope, u8error1, u8error2, u8error3;
     591                BitBlock u8error4, EF_BF_pending, u8mismatch;
     592
     593
     594        temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
     595        temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
     596        temp3 = simd_andc(temp2, temp1);
     597        temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
     598        temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
     599        temp6 = simd_and(temp4, temp5);
     600        lex.RefStart = simd_and(temp3, temp6);
     601        temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
     602        temp8 = simd_andc(temp7, temp1);
     603        temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
     604        temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
     605        temp11 = simd_and(temp9, temp10);
     606        lex.Semicolon = simd_and(temp8, temp11);
     607        temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
     608        temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
     609        temp14 = simd_andc(temp12, temp13);
     610        lex.LAngle = simd_and(temp8, temp14);
     611        temp15 = simd_and(temp12, temp5);
     612        lex.RAngle = simd_and(temp8, temp15);
     613        temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
     614        temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
     615        temp18 = simd_and(temp16, temp17);
     616        lex.LBracket = simd_and(temp18, temp11);
     617        temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
     618        temp20 = simd_and(temp12, temp19);
     619        lex.RBracket = simd_and(temp18, temp20);
     620        temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
     621        temp22 = simd_andc(temp19, temp21);
     622        lex.Exclam = simd_and(temp3, temp22);
     623        temp23 = simd_and(temp12, temp10);
     624        lex.QMark = simd_and(temp8, temp23);
     625        lex.Hyphen = simd_and(temp3, temp20);
     626        lex.Equals = simd_and(temp8, temp20);
     627        temp24 = simd_and(temp4, temp10);
     628        lex.SQuote = simd_and(temp3, temp24);
     629        temp25 = simd_andc(temp5, temp21);
     630        lex.DQuote = simd_and(temp3, temp25);
     631        lex.Slash = simd_and(temp3, temp23);
     632        temp26 = simd_andc(temp10, temp21);
     633        lex.Hash = simd_and(temp3, temp26);
     634        temp27 = simd_and(temp16, temp7);
     635        temp28 = simd_andc(temp9, temp13);
     636        lex.x = simd_and(temp27, temp28);
     637        temp29 = simd_and(temp9, temp5);
     638        lex.Colon = simd_and(temp8, temp29);
     639        temp30 = simd_and(temp18, temp23);
     640        temp31 = simd_or(temp30, lex.Colon);
     641        temp32 = simd_andc(temp16, basis_bits.bit_2);
     642        temp33 = simd_or(basis_bits.bit_5, temp10);
     643        temp34 = simd_and(basis_bits.bit_4, temp33);
     644        temp35 = simd_not(temp34);
     645        temp36 = simd_or(temp21, temp13);
     646        temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
     647        temp38 = simd_and(temp32, temp37);
     648        temp39 = simd_or(temp31, temp38);
     649        temp40 = simd_and(temp16, basis_bits.bit_2);
     650        temp41 = simd_and(temp40, temp37);
     651        lex.ASCII_name_start = simd_or(temp39, temp41);
     652        temp42 = simd_or(temp30, lex.Hyphen);
     653        temp43 = simd_and(temp3, temp15);
     654        temp44 = simd_or(temp42, temp43);
     655        temp45 = simd_andc(temp8, temp34);
     656        temp46 = simd_or(temp44, temp45);
     657        temp47 = simd_or(temp46, temp38);
     658        lex.ASCII_name_char = simd_or(temp47, temp41);
     659        lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
     660        temp48 = simd_or(temp1, basis_bits.bit_2);
     661        x00_x1F = simd_not(temp48);
     662        temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
     663        temp50 = simd_or(temp1, temp49);
     664        lex.CR = simd_andc(temp20, temp50);
     665        lex.LF = simd_andc(temp29, temp50);
     666        temp51 = simd_and(temp9, temp19);
     667        lex.HT = simd_andc(temp51, temp50);
     668        lex.SP = simd_andc(temp3, temp36);
     669        temp52 = simd_or(temp20, temp29);
     670        temp53 = simd_or(temp52, temp51);
     671        temp54 = simd_andc(temp53, temp50);
     672        lex.WS = simd_or(temp54, lex.SP);
     673        temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
     674        temp56 = simd_and(basis_bits.bit_4, temp55);
     675        lex.Digit = simd_andc(temp8, temp56);
     676        temp57 = simd_andc(temp16, temp49);
     677        temp58 = simd_andc(temp57, basis_bits.bit_4);
     678        temp59 = simd_not(temp10);
     679        temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
     680        temp61 = simd_and(temp58, temp60);
     681        temp62 = simd_or(lex.Digit, temp61);
     682        temp63 = simd_and(temp16, temp2);
     683        temp64 = simd_andc(temp63, basis_bits.bit_4);
     684        temp65 = simd_and(temp64, temp60);
     685        lex.Hex = simd_or(temp62, temp65);
     686        lex_error = simd_andc(x00_x1F, lex.WS);
     687        if (bitblock_has_bit(lex_error)) {
     688          error_tracker_NoteError("Error: illegal character", lex_error);
     689        }
     690        u8.unibyte = simd_not(basis_bits.bit_0);
     691        u8.suffix = simd_const_1(0);
     692        u8_error = simd_const_1(0);
     693        u8_FFFE_FFFF = simd_const_1(0);
     694        u8anyscope = simd_const_1(0);
     695        if ((bitblock_has_bit(basis_bits.bit_0) || CarryTest(carryQ, 0, 10))) {
     696          u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
     697          u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
     698          u8.prefix3 = simd_and(u8.prefix, temp2);
     699          u8.prefix4 = simd_and(u8.prefix, temp7);
     700          u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
     701          temp66 = simd_andc(u8.prefix, temp49);
     702          temp67 = simd_or(temp21, basis_bits.bit_6);
     703          temp68 = simd_andc(temp66, temp67);
     704          temp69 = simd_and(basis_bits.bit_5, temp13);
     705          temp70 = simd_or(basis_bits.bit_4, temp69);
     706          temp71 = simd_and(u8.prefix4, temp70);
     707          u8.badprefix = simd_or(temp68, temp71);
     708          u8_error = u8.badprefix;
     709          u8.scope22 = BitBlock_advance_ci_co(u8.prefix2, carryQ, 0);
     710          u8anyscope = u8.scope22;
     711          if ((bitblock_has_bit(simd_or(u8.prefix3, u8.prefix4)) || CarryTest(carryQ, 1, 9))) {
     712            xE0 = simd_andc(u8.prefix3, temp36);
     713            xED = simd_and(u8.prefix3, temp20);
     714            xF0 = simd_andc(u8.prefix4, temp36);
     715            temp72 = simd_andc(temp4, temp13);
     716            xF4 = simd_and(u8.prefix4, temp72);
     717            u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
     718            u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
     719            u8.x90_xBF = simd_and(u8.suffix, temp49);
     720            u8.x80_x8F = simd_andc(u8.suffix, temp49);
     721            xEF = simd_and(u8.prefix3, temp23);
     722            temp73 = simd_and(u8.suffix, temp7);
     723            u8.xBF = simd_and(temp73, temp23);
     724            u8.xBE = simd_and(temp73, temp15);
     725            u8.scope32 = BitBlock_advance_ci_co(u8.prefix3, carryQ, 1);
     726            u8.scope33 = BitBlock_advance_ci_co(u8.scope32, carryQ, 2);
     727            u8.scope42 = BitBlock_advance_ci_co(u8.prefix4, carryQ, 3);
     728            u8.scope43 = BitBlock_advance_ci_co(u8.scope42, carryQ, 4);
     729            u8.scope44 = BitBlock_advance_ci_co(u8.scope43, carryQ, 5);
     730            E0_F0_scope = BitBlock_advance_ci_co(simd_or(xE0, xF0), carryQ, 6);
     731            ED_F4_scope = BitBlock_advance_ci_co(simd_or(xED, xF4), carryQ, 7);
     732            u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
     733            u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
     734            u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
     735            u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
     736            u8.xEF_scope = BitBlock_advance_ci_co(xEF, carryQ, 8);
     737            u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
     738            u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
     739            u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
     740            u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
     741            u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
     742            u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
     743            u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
     744            EF_BF_pending = BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ, 9);
     745            u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
     746          }
     747          else {
     748            CarryDequeueEnqueue(carryQ, 1, 9);
     749          }
     750          u8mismatch = simd_xor(u8anyscope, u8.suffix);
     751          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
     752          if (bitblock_has_bit(u8_error)) {
     753            error_tracker_NoteError("UTF-8 error found", u8_error);
     754          }
     755        }
     756        else {
     757          CarryDequeueEnqueue(carryQ, 0, 10);
     758        }
     759        CarryQ_Adjust(carryQ, 10);
     760  }
     761  void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
    578762                BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
    579763                BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
     
    684868        lex_error = simd_andc(x00_x1F, lex.WS);
    685869        if (bitblock_has_bit(simd_and(lex_error, EOF_mask))) {
    686           error_tracker.NoteError("Error: illegal character", lex_error);
    687         }
    688         u8.unibyte = simd_not(basis_bits.bit_0);
    689         u8.suffix = simd_const_1(0);
    690         u8_error = simd_const_1(0);
    691         u8_FFFE_FFFF = simd_const_1(0);
    692         u8anyscope = simd_const_1(0);
    693         if ((bitblock_has_bit(basis_bits.bit_0) || CarryTest(carryQ, 0, 10))) {
    694           u8.prefix = simd_and(basis_bits.bit_0, basis_bits.bit_1);
    695           u8.prefix2 = simd_andc(u8.prefix, basis_bits.bit_2);
    696           u8.prefix3 = simd_and(u8.prefix, temp2);
    697           u8.prefix4 = simd_and(u8.prefix, temp7);
    698           u8.suffix = simd_andc(basis_bits.bit_0, basis_bits.bit_1);
    699           temp66 = simd_andc(u8.prefix, temp49);
    700           temp67 = simd_or(temp21, basis_bits.bit_6);
    701           temp68 = simd_andc(temp66, temp67);
    702           temp69 = simd_and(basis_bits.bit_5, temp13);
    703           temp70 = simd_or(basis_bits.bit_4, temp69);
    704           temp71 = simd_and(u8.prefix4, temp70);
    705           u8.badprefix = simd_or(temp68, temp71);
    706           u8_error = u8.badprefix;
    707           u8.scope22 = BitBlock_advance_ci_co(u8.prefix2, carryQ, 0);
    708           u8anyscope = u8.scope22;
    709           if ((bitblock_has_bit(simd_or(u8.prefix3, u8.prefix4)) || CarryTest(carryQ, 1, 9))) {
    710             xE0 = simd_andc(u8.prefix3, temp36);
    711             xED = simd_and(u8.prefix3, temp20);
    712             xF0 = simd_andc(u8.prefix4, temp36);
    713             temp72 = simd_andc(temp4, temp13);
    714             xF4 = simd_and(u8.prefix4, temp72);
    715             u8.xA0_xBF = simd_and(u8.suffix, basis_bits.bit_2);
    716             u8.x80_x9F = simd_andc(u8.suffix, basis_bits.bit_2);
    717             u8.x90_xBF = simd_and(u8.suffix, temp49);
    718             u8.x80_x8F = simd_andc(u8.suffix, temp49);
    719             xEF = simd_and(u8.prefix3, temp23);
    720             temp73 = simd_and(u8.suffix, temp7);
    721             u8.xBF = simd_and(temp73, temp23);
    722             u8.xBE = simd_and(temp73, temp15);
    723             u8.scope32 = BitBlock_advance_ci_co(u8.prefix3, carryQ, 1);
    724             u8.scope33 = BitBlock_advance_ci_co(u8.scope32, carryQ, 2);
    725             u8.scope42 = BitBlock_advance_ci_co(u8.prefix4, carryQ, 3);
    726             u8.scope43 = BitBlock_advance_ci_co(u8.scope42, carryQ, 4);
    727             u8.scope44 = BitBlock_advance_ci_co(u8.scope43, carryQ, 5);
    728             E0_F0_scope = BitBlock_advance_ci_co(simd_or(xE0, xF0), carryQ, 6);
    729             ED_F4_scope = BitBlock_advance_ci_co(simd_or(xED, xF4), carryQ, 7);
    730             u8.xE0_scope = simd_and(u8.scope32, E0_F0_scope);
    731             u8.xED_scope = simd_and(u8.scope32, ED_F4_scope);
    732             u8.xF0_scope = simd_and(u8.scope42, E0_F0_scope);
    733             u8.xF4_scope = simd_and(u8.scope42, ED_F4_scope);
    734             u8.xEF_scope = BitBlock_advance_ci_co(xEF, carryQ, 8);
    735             u8lastscope = simd_or(simd_or(u8.scope22, u8.scope33), u8.scope44);
    736             u8anyscope = simd_or(simd_or(simd_or(u8lastscope, u8.scope32), u8.scope42), u8.scope43);
    737             u8error1 = simd_and(u8.xE0_scope, u8.x80_x9F);
    738             u8error2 = simd_and(u8.xED_scope, u8.xA0_xBF);
    739             u8error3 = simd_and(u8.xF0_scope, u8.x80_x8F);
    740             u8error4 = simd_and(u8.xF4_scope, u8.x90_xBF);
    741             u8_error = simd_or(u8_error, simd_or(simd_or(simd_or(u8error1, u8error2), u8error3), u8error4));
    742             EF_BF_pending = BitBlock_advance_ci_co(simd_and(u8.xEF_scope, u8.xBF), carryQ, 9);
    743             u8_FFFE_FFFF = simd_and(EF_BF_pending, simd_or(u8.xBE, u8.xBF));
    744           }
    745           else {
    746             CarryDequeueEnqueue(carryQ, 1, 9);
    747           }
    748           u8mismatch = simd_xor(u8anyscope, u8.suffix);
    749           u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
    750           if (bitblock_has_bit(u8_error)) {
    751             error_tracker.NoteError("UTF-8 error found", u8_error);
    752           }
    753         }
    754         else {
    755           CarryDequeueEnqueue(carryQ, 0, 10);
    756         }
    757         CarryQ_Adjust(carryQ, 10);
    758   }
    759   void do_final_block(Basis_bits & basis_bits, Lex & lex, U8 & u8, BitBlock EOF_mask) {
    760                 BitBlock temp1, temp2, temp3, temp4, temp5, temp6, temp7, temp8, temp9, temp10;
    761                 BitBlock temp11, temp12, temp13, temp14, temp15, temp16, temp17, temp18;
    762                 BitBlock temp19, temp20, temp21, temp22, temp23, temp24, temp25, temp26;
    763                 BitBlock temp27, temp28, temp29, temp30, temp31, temp32, temp33, temp34;
    764                 BitBlock temp35, temp36, temp37, temp38, temp39, temp40, temp41, temp42;
    765                 BitBlock temp43, temp44, temp45, temp46, temp47, temp48, x00_x1F, temp49;
    766                 BitBlock temp50, temp51, temp52, temp53, temp54, temp55, temp56, temp57;
    767                 BitBlock temp58, temp59, temp60, temp61, temp62, temp63, temp64, temp65;
    768                 BitBlock lex_error, u8_error, u8_FFFE_FFFF, u8anyscope, temp66, temp67, temp68;
    769                 BitBlock temp69, temp70, temp71, xE0, xED, xF0, temp72, xF4, xEF, temp73;
    770                 BitBlock E0_F0_scope, ED_F4_scope, u8lastscope, u8error1, u8error2, u8error3;
    771                 BitBlock u8error4, EF_BF_pending, u8mismatch;
    772 
    773 
    774         temp1 = simd_or(basis_bits.bit_0, basis_bits.bit_1);
    775         temp2 = simd_andc(basis_bits.bit_2, basis_bits.bit_3);
    776         temp3 = simd_andc(temp2, temp1);
    777         temp4 = simd_andc(basis_bits.bit_5, basis_bits.bit_4);
    778         temp5 = simd_andc(basis_bits.bit_6, basis_bits.bit_7);
    779         temp6 = simd_and(temp4, temp5);
    780         lex.RefStart = simd_and(temp3, temp6);
    781         temp7 = simd_and(basis_bits.bit_2, basis_bits.bit_3);
    782         temp8 = simd_andc(temp7, temp1);
    783         temp9 = simd_andc(basis_bits.bit_4, basis_bits.bit_5);
    784         temp10 = simd_and(basis_bits.bit_6, basis_bits.bit_7);
    785         temp11 = simd_and(temp9, temp10);
    786         lex.Semicolon = simd_and(temp8, temp11);
    787         temp12 = simd_and(basis_bits.bit_4, basis_bits.bit_5);
    788         temp13 = simd_or(basis_bits.bit_6, basis_bits.bit_7);
    789         temp14 = simd_andc(temp12, temp13);
    790         lex.LAngle = simd_and(temp8, temp14);
    791         temp15 = simd_and(temp12, temp5);
    792         lex.RAngle = simd_and(temp8, temp15);
    793         temp16 = simd_andc(basis_bits.bit_1, basis_bits.bit_0);
    794         temp17 = simd_andc(basis_bits.bit_3, basis_bits.bit_2);
    795         temp18 = simd_and(temp16, temp17);
    796         lex.LBracket = simd_and(temp18, temp11);
    797         temp19 = simd_andc(basis_bits.bit_7, basis_bits.bit_6);
    798         temp20 = simd_and(temp12, temp19);
    799         lex.RBracket = simd_and(temp18, temp20);
    800         temp21 = simd_or(basis_bits.bit_4, basis_bits.bit_5);
    801         temp22 = simd_andc(temp19, temp21);
    802         lex.Exclam = simd_and(temp3, temp22);
    803         temp23 = simd_and(temp12, temp10);
    804         lex.QMark = simd_and(temp8, temp23);
    805         lex.Hyphen = simd_and(temp3, temp20);
    806         lex.Equals = simd_and(temp8, temp20);
    807         temp24 = simd_and(temp4, temp10);
    808         lex.SQuote = simd_and(temp3, temp24);
    809         temp25 = simd_andc(temp5, temp21);
    810         lex.DQuote = simd_and(temp3, temp25);
    811         lex.Slash = simd_and(temp3, temp23);
    812         temp26 = simd_andc(temp10, temp21);
    813         lex.Hash = simd_and(temp3, temp26);
    814         temp27 = simd_and(temp16, temp7);
    815         temp28 = simd_andc(temp9, temp13);
    816         lex.x = simd_and(temp27, temp28);
    817         temp29 = simd_and(temp9, temp5);
    818         lex.Colon = simd_and(temp8, temp29);
    819         temp30 = simd_and(temp18, temp23);
    820         temp31 = simd_or(temp30, lex.Colon);
    821         temp32 = simd_andc(temp16, basis_bits.bit_2);
    822         temp33 = simd_or(basis_bits.bit_5, temp10);
    823         temp34 = simd_and(basis_bits.bit_4, temp33);
    824         temp35 = simd_not(temp34);
    825         temp36 = simd_or(temp21, temp13);
    826         temp37 = simd_or(simd_and(basis_bits.bit_3, temp35), simd_andc(temp36, basis_bits.bit_3));
    827         temp38 = simd_and(temp32, temp37);
    828         temp39 = simd_or(temp31, temp38);
    829         temp40 = simd_and(temp16, basis_bits.bit_2);
    830         temp41 = simd_and(temp40, temp37);
    831         lex.ASCII_name_start = simd_or(temp39, temp41);
    832         temp42 = simd_or(temp30, lex.Hyphen);
    833         temp43 = simd_and(temp3, temp15);
    834         temp44 = simd_or(temp42, temp43);
    835         temp45 = simd_andc(temp8, temp34);
    836         temp46 = simd_or(temp44, temp45);
    837         temp47 = simd_or(temp46, temp38);
    838         lex.ASCII_name_char = simd_or(temp47, temp41);
    839         lex.NameScan = simd_or(lex.ASCII_name_char, basis_bits.bit_0);
    840         temp48 = simd_or(temp1, basis_bits.bit_2);
    841         x00_x1F = simd_not(temp48);
    842         temp49 = simd_or(basis_bits.bit_2, basis_bits.bit_3);
    843         temp50 = simd_or(temp1, temp49);
    844         lex.CR = simd_andc(temp20, temp50);
    845         lex.LF = simd_andc(temp29, temp50);
    846         temp51 = simd_and(temp9, temp19);
    847         lex.HT = simd_andc(temp51, temp50);
    848         lex.SP = simd_andc(temp3, temp36);
    849         temp52 = simd_or(temp20, temp29);
    850         temp53 = simd_or(temp52, temp51);
    851         temp54 = simd_andc(temp53, temp50);
    852         lex.WS = simd_or(temp54, lex.SP);
    853         temp55 = simd_or(basis_bits.bit_5, basis_bits.bit_6);
    854         temp56 = simd_and(basis_bits.bit_4, temp55);
    855         lex.Digit = simd_andc(temp8, temp56);
    856         temp57 = simd_andc(temp16, temp49);
    857         temp58 = simd_andc(temp57, basis_bits.bit_4);
    858         temp59 = simd_not(temp10);
    859         temp60 = simd_or(simd_and(basis_bits.bit_5, temp59), simd_andc(temp13, basis_bits.bit_5));
    860         temp61 = simd_and(temp58, temp60);
    861         temp62 = simd_or(lex.Digit, temp61);
    862         temp63 = simd_and(temp16, temp2);
    863         temp64 = simd_andc(temp63, basis_bits.bit_4);
    864         temp65 = simd_and(temp64, temp60);
    865         lex.Hex = simd_or(temp62, temp65);
    866         lex_error = simd_andc(x00_x1F, lex.WS);
    867         if (bitblock_has_bit(simd_and(lex_error, EOF_mask))) {
    868           error_tracker.NoteError("Error: illegal character", lex_error);
     870          error_tracker_NoteError("Error: illegal character", lex_error);
    869871        }
    870872        u8.unibyte = simd_not(basis_bits.bit_0);
     
    931933          u8_error = simd_or(u8_error, simd_or(u8mismatch, u8_FFFE_FFFF));
    932934          if (bitblock_has_bit(u8_error)) {
    933             error_tracker.NoteError("UTF-8 error found", u8_error);
     935            error_tracker_NoteError("UTF-8 error found", u8_error);
    934936          }
    935937        }
     
    958960          ref_error = simd_andc(ref_ends, lex.Semicolon);
    959961          if (bitblock_has_bit(ref_error)) {
    960             error_tracker.NoteError("Reference error found", ref_error);
     962            error_tracker_NoteError("Reference error found", ref_error);
    961963          }
    962964          callouts.Symbol_ends = simd_or(callouts.Symbol_ends, ref_ends);
     
    976978          ref_error = simd_andc(ref_ends, lex.Semicolon);
    977979          if (bitblock_has_bit(ref_error)) {
    978             error_tracker.NoteError("Reference error found", ref_error);
     980            error_tracker_NoteError("Reference error found", ref_error);
    979981          }
    980982          callouts.Symbol_ends = simd_or(callouts.Symbol_ends, ref_ends);
     
    10391041            PI_error = simd_or(PI_error, simd_andc(BitBlock_advance_ci_co(simd_andc(PI_name_end, lex.WS), carryQ, 8), PI_closer));
    10401042            if (bitblock_has_bit(PI_error)) {
    1041               error_tracker.NoteError("Error in PI syntax", PI_name_end);
     1043              error_tracker_NoteError("Error in PI syntax", PI_name_end);
    10421044            }
    10431045            callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
     
    10641066            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    10651067            if (bitblock_has_bit(Ct_error)) {
    1066               error_tracker.NoteError("Error in comment syntax", Ct_error);
     1068              error_tracker_NoteError("Error in comment syntax", Ct_error);
    10671069            }
    10681070          }
     
    10731075          CtCDPI_Cursor = BitBlock_scanto_ci_co(CtCDPI_Cursor, CtCDPI_opener, carryQ, 16);
    10741076          ctCDPI_mask = simd_or(ctCDPI_mask, simd_or(BitBlock_sub_ci_co(CtCDPI_ends, CtCDPI_starts, carryQ, 17), CtCDPI_ends));
    1075           ctCDPI_error = simd_andc(ctCDPI_mask, EOF_mask);
     1077          ctCDPI_error = simd_const_1(0);
    10761078          if (bitblock_has_bit(ctCDPI_error)) {
    1077             error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
     1079            error_tracker_NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
    10781080          }
    10791081          while (bitblock_has_bit(CtCDPI_Cursor)) {
     
    10921094              PI_error = simd_or(PI_error, simd_andc(BitBlock_advance_co(simd_andc(PI_name_end, lex.WS), subcarryQ, 3), PI_closer));
    10931095              if (bitblock_has_bit(PI_error)) {
    1094                 error_tracker.NoteError("Error in PI syntax", PI_name_end);
     1096                error_tracker_NoteError("Error in PI syntax", PI_name_end);
    10951097              }
    10961098              callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
     
    11111113              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    11121114              if (bitblock_has_bit(Ct_error)) {
    1113                 error_tracker.NoteError("Error in comment syntax", Ct_error);
     1115                error_tracker_NoteError("Error in comment syntax", Ct_error);
    11141116              }
    11151117            }
     
    11171119            CtCDPI_Cursor = BitBlock_scanto_co(CtCDPI_Cursor, CtCDPI_opener, subcarryQ, 11);
    11181120            ctCDPI_mask = simd_or(ctCDPI_mask, simd_or(BitBlock_sub_co(CtCDPI_ends, CtCDPI_starts, subcarryQ, 12), CtCDPI_ends));
    1119             ctCDPI_error = simd_andc(ctCDPI_mask, EOF_mask);
     1121            ctCDPI_error = simd_const_1(0);
    11201122            if (bitblock_has_bit(ctCDPI_error)) {
    1121               error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
     1123              error_tracker_NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
    11221124            }
    11231125            CarryCombine(carryQ, subcarryQ, 5, 13);
     
    11781180            PI_error = simd_or(PI_error, simd_andc(BitBlock_advance_ci(simd_andc(PI_name_end, lex.WS), carryQ, 8), PI_closer));
    11791181            if (bitblock_has_bit(PI_error)) {
    1180               error_tracker.NoteError("Error in PI syntax", PI_name_end);
     1182              error_tracker_NoteError("Error in PI syntax", PI_name_end);
    11811183            }
    11821184            callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
     
    12031205            CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    12041206            if (bitblock_has_bit(Ct_error)) {
    1205               error_tracker.NoteError("Error in comment syntax", Ct_error);
     1207              error_tracker_NoteError("Error in comment syntax", Ct_error);
    12061208            }
    12071209          }
     
    12141216          ctCDPI_error = simd_andc(ctCDPI_mask, EOF_mask);
    12151217          if (bitblock_has_bit(ctCDPI_error)) {
    1216             error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
     1218            error_tracker_NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
    12171219          }
    12181220          while (bitblock_has_bit(simd_and(CtCDPI_Cursor, EOF_mask))) {
     
    12291231              PI_error = simd_or(PI_error, simd_andc(BitBlock_advance(simd_andc(PI_name_end, lex.WS)), PI_closer));
    12301232              if (bitblock_has_bit(PI_error)) {
    1231                 error_tracker.NoteError("Error in PI syntax", PI_name_end);
     1233                error_tracker_NoteError("Error in PI syntax", PI_name_end);
    12321234              }
    12331235              callouts.Symbol_ends = simd_or(callouts.Symbol_ends, PI_name_end);
     
    12481250              CtCDPI_ends = simd_or(CtCDPI_ends, Ct_Cursor);
    12491251              if (bitblock_has_bit(Ct_error)) {
    1250                 error_tracker.NoteError("Error in comment syntax", Ct_error);
     1252                error_tracker_NoteError("Error in comment syntax", Ct_error);
    12511253              }
    12521254            }
     
    12561258            ctCDPI_error = simd_andc(ctCDPI_mask, EOF_mask);
    12571259            if (bitblock_has_bit(ctCDPI_error)) {
    1258               error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
     1260              error_tracker_NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error);
    12591261            }
    12601262          }
     
    12851287        CD_end_error = marker.CD_closer;
    12861288        if (bitblock_has_bit(CD_end_error)) {
    1287           error_tracker.NoteError("Error: ]]> in text", CD_end_error);
     1289          error_tracker_NoteError("Error: ]]> in text", CD_end_error);
    12881290        }
    12891291        callouts.Nonplain = simd_or(simd_or(simd_or(simd_or(u8.prefix, u8.suffix), lex.CR), marker.Ref_opener), marker.LAngle);
     
    12951297        CD_end_error = marker.CD_closer;
    12961298        if (bitblock_has_bit(CD_end_error)) {
    1297           error_tracker.NoteError("Error: ]]> in text", CD_end_error);
     1299          error_tracker_NoteError("Error: ]]> in text", CD_end_error);
    12981300        }
    12991301        callouts.Nonplain = simd_or(simd_or(simd_or(simd_or(u8.prefix, u8.suffix), lex.CR), marker.Ref_opener), marker.LAngle);
Note: See TracChangeset for help on using the changeset viewer.