Changeset 3221


Ignore:
Timestamp:
May 29, 2013, 12:51:10 PM (5 years ago)
Author:
shiyangy
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/xmlschema/parabix2_pablo.py

    r2219 r3221  
    2626
    2727
    28 class u8 ():
     28class U8 ():
    2929  unibyte = 0
    3030  prefix = 0
     
    222222        lex.Hex = (temp62 | temp65);
    223223        lex_error = x00_x1F &~ lex.WS
    224         if lex_error & EOF_mask:
    225                 error_tracker.NoteError("Error: illegal character", lex_error)
     224        pablo.assert_0(pablo.inFile(lex_error), "Error: illegal character")
    226225               
    227226       
     
    246245                u8.badprefix = (temp68 | temp71);
    247246                u8_error = u8.badprefix
    248                 u8.scope22 = bitutil.Advance(u8.prefix2)
     247                u8.scope22 = pablo.Advance(u8.prefix2)
    249248                u8anyscope = u8.scope22
    250249                if u8.prefix3 | u8.prefix4:
     
    264263#
    265264
    266 #                       scope3_32 = bitutil.Advance32(u8.prefix3)
    267 #                       scope4_32 = bitutil.Advance32(u8.prefix4)
     265#                       scope3_32 = pablo.Advance32(u8.prefix3)
     266#                       scope4_32 = pablo.Advance32(u8.prefix4)
    268267#                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    269268#                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
     
    272271#                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    273272#
    274                         u8.scope32 = bitutil.Advance(u8.prefix3)
    275                         u8.scope33 = bitutil.Advance(u8.scope32)
    276                         u8.scope42 = bitutil.Advance(u8.prefix4)
    277                         u8.scope43 = bitutil.Advance(u8.scope42)
    278                         u8.scope44 = bitutil.Advance(u8.scope43)
    279 #
    280 #                       u8.xE0_scope = bitutil.Advance(xE0);
    281 #                       u8.xED_scope = bitutil.Advance(xED);
    282 #                       u8.xF0_scope = bitutil.Advance(xF0);
    283 #                       u8.xF4_scope = bitutil.Advance(xF4);
    284                         E0_F0_scope = bitutil.Advance(xE0 | xF0)
    285                         ED_F4_scope = bitutil.Advance(xED | xF4)
     273                        u8.scope32 = pablo.Advance(u8.prefix3)
     274                        u8.scope33 = pablo.Advance(u8.scope32)
     275                        u8.scope42 = pablo.Advance(u8.prefix4)
     276                        u8.scope43 = pablo.Advance(u8.scope42)
     277                        u8.scope44 = pablo.Advance(u8.scope43)
     278#
     279#                       u8.xE0_scope = pablo.Advance(xE0);
     280#                       u8.xED_scope = pablo.Advance(xED);
     281#                       u8.xF0_scope = pablo.Advance(xF0);
     282#                       u8.xF4_scope = pablo.Advance(xF4);
     283                        E0_F0_scope = pablo.Advance(xE0 | xF0)
     284                        ED_F4_scope = pablo.Advance(xED | xF4)
    286285                        u8.xE0_scope = u8.scope32 & E0_F0_scope
    287286                        u8.xED_scope = u8.scope32 & ED_F4_scope
    288287                        u8.xF0_scope = u8.scope42 & E0_F0_scope
    289288                        u8.xF4_scope = u8.scope42 & ED_F4_scope
    290                         u8.xEF_scope = bitutil.Advance(xEF);
     289                        u8.xEF_scope = pablo.Advance(xEF);
    291290
    292291                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
     
    300299                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4
    301300
    302                         EF_BF_pending = bitutil.Advance(u8.xEF_scope & u8.xBF)
     301                        EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF)
    303302
    304303                        u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
    305304                u8mismatch = u8anyscope ^ u8.suffix
    306                 u8_error |= u8mismatch | u8_FFFE_FFFF
    307                 if u8_error:
    308                         error_tracker.NoteError("UTF-8 error found", (u8_error))
     305                pablo.assert_0(u8_error | u8mismatch | u8_FFFE_FFFF, "UTF-8 error found")
    309306                       
    310307       
     
    324321        v = lex.LAngle | lex.Hyphen
    325322        w = lex.Hyphen | lex.QMark
    326         v1 = bitutil.Advance(v)
    327         w1 = bitutil.Advance(w)
    328        
    329         LAngle_scope = v1 &~ w1  #bitutil.Advance(lex.LAngle)
     323        v1 = pablo.Advance(v,1)
     324        w1 = pablo.Advance(w,1)
     325       
     326        LAngle_scope = v1 &~ w1  #pablo.Advance(lex.LAngle)
    330327        PI_opener = LAngle_scope & lex.QMark
    331328        CtCD_opener= LAngle_scope & lex.Exclam
     
    336333        #PI_closer = 0
    337334       
    338         #if lex.Hyphen: DoubleHyphen = bitutil.Advance(lex.Hyphen) & lex.Hyphen
     335        #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    339336        DoubleHyphen = v1 & w1 & lex.Hyphen
    340337        if lex.RBracket:
    341                 DoubleRBracket = bitutil.Advance(lex.RBracket) & lex.RBracket
    342                 CD_closer = bitutil.Advance(DoubleRBracket) & lex.RAngle
    343         #if lex.QMark: PI_closer = bitutil.Advance(lex.QMark) & lex.RAngle
     338                DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket
     339                CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle
     340        #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    344341        PI_closer = w1 & ~v1 & lex.RAngle
    345342
    346343        #
    347344        # Initiate the scan
    348         CtCDPI_Cursor = bitutil.ScanToFirst(CtCDPI_opener)
     345        CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener)
    349346        while CtCDPI_Cursor:
    350347                CtCDPI_starts |= CtCDPI_Cursor
    351348                PI_Cursor = CtCDPI_Cursor & PI_opener
    352                 CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
     349                CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor)
    353350                CD_Cursor = CD_Ct_Cursor & lex.LBracket
    354351                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
     
    356353                if PI_Cursor:
    357354                        ctCDPI_Callouts.PI_starts |= PI_Cursor
    358                         PI_Cursor = bitutil.Advance(PI_Cursor)
     355                        PI_Cursor = pablo.Advance(PI_Cursor)
    359356                        ctCDPI_Callouts.PI_name_starts |= PI_Cursor
    360                         PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
     357                        PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan)
    361358                        PI_error = PI_Cursor & PI_name_end
    362                         PI_error |= bitutil.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
    363                         if PI_error:
    364                                 error_tracker.NoteError("Error in PI syntax", PI_name_end)
     359                        PI_noWS = PI_name_end & ~ lex.WS
     360                        PI_error |= PI_noWS &~ lex.QMark | pablo.Advance(PI_noWS) &~ PI_closer
     361                        pablo.assert_0(PI_error, "Error in PI syntax")
    365362                        ctCDPI_Callouts.PI_name_ends |= PI_name_end
    366                         PI_Cursor = bitutil.ScanTo(PI_name_end, PI_closer)
     363                        PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer)
    367364                        ctCDPI_Callouts.PI_ends |= PI_Cursor
    368365                        CtCDPI_ends |= PI_Cursor
     
    371368                if CD_Cursor:
    372369                        ctCDPI_Callouts.CD_starts |= CD_Cursor
    373                         CD_Cursor = bitutil.ScanTo(CD_Cursor, CD_closer)
     370                        CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer)
    374371                        ctCDPI_Callouts.CD_ends |= CD_Cursor
    375372                        CtCDPI_ends |= CD_Cursor
     
    378375                if Ct_Cursor:
    379376                        ctCDPI_Callouts.Ct_starts |= Ct_Cursor
    380                         Ct_Cursor = bitutil.Advance(Ct_Cursor) 
     377                        Ct_Cursor = pablo.Advance(Ct_Cursor) 
    381378                        Ct_error = Ct_Cursor & ~ lex.Hyphen
    382379                        # Advance twice past <!--, so that we don't treat <!---
    383380                        # as being a terminated comment.
    384                         Ct_Cursor = bitutil.Advance(bitutil.Advance(Ct_Cursor))
    385                         Ct_Cursor = bitutil.Advance(bitutil.ScanTo(Ct_Cursor, DoubleHyphen))
    386                         Ct_error |= Ct_Cursor & ~ lex.RAngle   
     381                        Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor))
     382                        Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen))
     383                        pablo.assert_0(Ct_error | Ct_Cursor & ~ lex.RAngle, "Error in comment syntax")
    387384                        ctCDPI_Callouts.Ct_ends |= Ct_Cursor
    388385                        CtCDPI_ends |= Ct_Cursor
    389                         if Ct_error:
    390                                 error_tracker.NoteError("Error in comment syntax", Ct_error)
    391386
    392387                # Common processing
    393388                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
    394                 CtCDPI_Cursor = bitutil.ScanTo(CtCDPI_Cursor, CtCDPI_opener)   
    395                 ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends             
     389                ctCDPI_mask = pablo.InclusiveSpan(CtCDPI_starts, CtCDPI_ends)
     390#               ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends
    396391                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    397                 ctCDPI_error = ctCDPI_mask &~ EOF_mask
    398        
    399                 if ctCDPI_error:
    400                         error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
    401                
    402         check_streams.misc_mask = (lex.WS | lex.LAngle | (bitutil.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) - (ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
     392                pablo.assert_0(pablo.atEOF(ctCDPI_mask), "Error in comment, CDATA or processing instruction syntax")
     393                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)     
     394               
     395#       check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends)  -(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
     396#  Following is slow
     397        check_streams.misc_mask = (lex.WS | lex.LAngle | pablo.InclusiveSpan(ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts, ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) | CtCDPI_starts) & EOF_mask
    403398
    404399
     
    410405def Parse_tags(lex, marker, tag_Callouts):
    411406       
     407        EqExpected = 0
     408        AttListEnd = 0
     409       
    412410        # Delimiters for scans.
    413411        DQuoteDelim = lex.DQuote | lex.LAngle
     
    423421
    424422        # Advance all cursors by scanning through the tag name.
    425         tag_Callouts.ElemName_ends = bitutil.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
     423        tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
    426424        # Must have at least one name character for a legal start tag.
    427425        # Mark any occurrences of null names as errors.
     
    433431        tag_Callouts.AttVal_starts = 0
    434432        tag_Callouts.AttVal_ends = 0
    435 
    436433        # After the element name, there may or may not be an attlist.
    437434        if tag_Callouts.ElemName_ends & lex.WS:
    438                 AfterWS = bitutil.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
     435                AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
    439436                AttListEnd = AfterWS & AttListDelim
    440437                AttNameStart = AfterWS & ~AttListDelim
     
    447444                        ParseError |= AttNameStart &~ lex.NameScan
    448445                        tag_Callouts.AttName_starts |= AttNameStart
    449                         AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
     446                        AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan)
    450447                        tag_Callouts.AttName_ends |= AttNameFollow
    451448                        # Scan through WS to the expected '=' delimiter.
    452                         # EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     449                        # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    453450                        # But use if test to optimize.
    454451                        if AttNameFollow & lex.WS:
    455                                 EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     452                                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    456453                        else: EqExpected = AttNameFollow
    457454                        ParseError |= EqExpected &~ lex.Equals
    458                         AttValPos = bitutil.ScanThru(EqExpected, EqExpected | lex.WS)
     455                        AttValPos = pablo.AdvanceThenScanThru(EqExpected, lex.WS)
     456#                       AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    459457                        tag_Callouts.AttVal_starts |= AttValPos
    460458                        DQuoteAttVal = AttValPos & lex.DQuote
    461459                        SQuoteAttVal = AttValPos & lex.SQuote
    462                         DQuoteAttEnd = bitutil.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    463                         SQuoteAttEnd = bitutil.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
     460#                       DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
     461#                       SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
     462                        DQuoteAttEnd = pablo.AdvanceThenScanTo(DQuoteAttVal, DQuoteDelim)
     463                        SQuoteAttEnd = pablo.AdvanceThenScanTo(SQuoteAttVal, SQuoteDelim)
    464464                        AttValEnd = DQuoteAttEnd | SQuoteAttEnd
    465465                        ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote)
    466                         AttValFollow = bitutil.Advance(AttValEnd)
     466                        AttValFollow = pablo.Advance(AttValEnd)
    467467                        tag_Callouts.AttVal_ends |= AttValFollow
    468                         #  AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
     468                        #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    469469                        if AttValFollow & lex.WS:
    470                                 AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
     470                                AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    471471                                AttListEnd |= AfterWS & AttListDelim
    472472                                AttNameStart = AfterWS & ~AttListDelim
    473473                        else:
    474474                                AttListEnd |= AttValFollow & AttListDelim       
    475                                 AttNameStart = 0
    476                                 ParseError |= AttValFollow & ~AttListDelim
     475                                AttNameStart = AttValFollow & ~AttListDelim
     476                        ParseError |= AttValFollow & AttNameStart
    477477        else:
    478478                # No WS character after ElemName; must be at the end
     
    482482        STagEnds = AttListEnd & lex.RAngle
    483483        # Mark any "/" characters found as the ends of empty element tags.
    484         tag_Callouts.EmptyTag_marks = bitutil.Advance(AttListEnd & lex.Slash)
     484        tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash)
    485485       
    486486        ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle
     
    488488        # End Tag Parsing
    489489
    490         EndTagEnds = bitutil.ScanThru(tag_Callouts.EndTag_marks, tag_Callouts.EndTag_marks | lex.NameScan)
     490        EndTagEnds = pablo.AdvanceThenScanThru(tag_Callouts.EndTag_marks, lex.NameScan)
    491491        if EndTagEnds & lex.WS:
    492                 EndTagEnds = bitutil.ScanThru(EndTagEnds, lex.WS)
     492                EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS)
    493493        ParseError |= EndTagEnds & ~lex.RAngle
    494         if ParseError:
    495                 error_tracker.NoteError("Tag parsing error found", (ParseError))
     494        pablo.assert_0(ParseError, "Tag parsing error found")
    496495               
    497496               
    498497        # Attribute value spans
    499         tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
     498#       tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
     499        tag_Callouts.AttVal_spans = pablo.SpanUpTo(tag_Callouts.AttVal_starts, tag_Callouts.AttVal_ends)
    500500
    501501def Parse_refs(lex, marker, ref_Callouts):
     
    510510        # All remaining "&" must be reference start characters; parse them.
    511511        if marker.Ref_opener:
    512                 Ref_scope = bitutil.Advance(marker.Ref_opener)
     512                Ref_scope = pablo.Advance(marker.Ref_opener)
    513513                NumRef2 = Ref_scope & lex.Hash
    514514                ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash
    515                 NumRef3 = bitutil.Advance(NumRef2)
     515                NumRef3 = pablo.Advance(NumRef2)
    516516                HexRef3 = NumRef3 & lex.x
    517517                ref_Callouts.DecRef_starts = NumRef3 &~ lex.x
    518                 ref_Callouts.HexRef_starts = bitutil.Advance(HexRef3)
    519                 ref_Callouts.GenRef_ends = bitutil.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan)
    520                 ref_Callouts.DecRef_ends = bitutil.ScanThru(ref_Callouts.DecRef_starts, lex.Digit)
    521                 ref_Callouts.HexRef_ends = bitutil.ScanThru(ref_Callouts.HexRef_starts, lex.Hex)
     518                ref_Callouts.HexRef_starts = pablo.Advance(HexRef3)
     519                ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan)
     520                ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit)
     521                ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex)
    522522                # Error checks
    523523                # At least one digit required for DecRef, one hex digit for HexRef.
     
    527527                ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends
    528528                ref_error3 = ref_ends &~ lex.Semicolon
    529                 ref_error = ref_error1 | ref_error2 | ref_error3
    530                 if ref_error:
    531                         error_tracker.NoteError("Reference error found", (ref_error))
     529                pablo.assert_0(ref_error1 | ref_error2 | ref_error3, "Reference error found")
    532530                       
    533531
    534532
    535533def Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams):
    536         PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
    537         GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
    538         ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
    539         AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
     534#       PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
     535#       GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
     536#       ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
     537#       AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
     538        PI_names = pablo.SpanUpTo(ctCDPI_Callouts.PI_name_starts, ctCDPI_Callouts.PI_name_ends)
     539        GenRefs = pablo.SpanUpTo(ref_Callouts.GenRef_starts, ref_Callouts.GenRef_ends)
     540        ElemNames = pablo.SpanUpTo(tag_Callouts.ElemName_starts, tag_Callouts.ElemName_ends)
     541        AttNames = pablo.SpanUpTo(tag_Callouts.AttName_starts, tag_Callouts.AttName_ends)
    540542        qname_stream =  ElemNames | AttNames
    541543        ncname_stream = PI_names | GenRefs
    542544        name_stream = qname_stream | ncname_stream
    543         name_start = name_stream &~ bitutil.Advance(name_stream)
    544         name_cursor = name_stream & ~bitutil.Advance(name_stream)
     545        name_start = name_stream &~ pablo.Advance(name_stream)
     546        name_cursor = name_stream & ~pablo.Advance(name_stream)
    545547        void_prefix_err = name_cursor & lex.Colon
    546         namespace_sep = bitutil.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon
    547         local_part_start = bitutil.Advance(namespace_sep)
     548        namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon
     549        local_part_start = pablo.Advance(namespace_sep)
    548550        local_part_err = local_part_start &~ lex.NameScan
    549         colon2_err = bitutil.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
     551        colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
    550552        ncname_err = ncname_stream & lex.Colon
    551         namespace_error = void_prefix_err | local_part_err | colon2_err | ncname_err
    552         if namespace_error:
    553                 error_tracker.NoteError("error found", namespace_error)
     553        pablo.assert_0(void_prefix_err | local_part_err | colon2_err | ncname_err, "name syntax error")
    554554               
    555555                       
     
    558558   
    559559def Do_check_streams(marker, tag_Callouts, check_streams):
    560         CD_end_error = marker.CD_closer & ~tag_Callouts.AttVal_spans
    561         if CD_end_error:
    562                 error_tracker.NoteError("Error: ]]> in text", CD_end_error)
     560        pablo.assert_0(marker.CD_closer & ~tag_Callouts.AttVal_spans, "Error: ]]> in text")
    563561        check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts
    564562        check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends
Note: See TracChangeset for help on using the changeset viewer.