Changeset 1440


Ignore:
Timestamp:
Sep 14, 2011, 12:05:49 PM (8 years ago)
Author:
cameron
Message:

Use 'pablo.' in place of 'bitutil.' for Pablo built-ins.

Location:
proto
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/Compiler/pablo.py

    r1439 r1440  
    1111name_substitution_map = {}
    1212
    13 def is_BuiltIn_Call(fncall, builtin_fnname, builtin_arg_cnt, builtin_fnmod_noprefix='bitutil'):
     13def is_BuiltIn_Call(fncall, builtin_fnname, builtin_arg_cnt, builtin_fnmod_noprefix='pablo'):
    1414        if isinstance(fncall.func, ast.Name): iscall = fncall.func.id == builtin_fnname
    1515        elif isinstance(fncall.func, ast.Attribute) and isinstance(fncall.func.value, ast.Name):
  • proto/Xerces/parabix2_xerces.py

    r1439 r1440  
    186186        lex.Hex = (temp62 | temp65);
    187187        lex_error = x00_x1F &~ lex.WS
    188         if bitutil.inFile(lex_error):
     188        if pablo.inFile(lex_error):
    189189                error_tracker.NoteError("Error: illegal character", lex_error)
    190190               
     
    210210                u8.badprefix = (temp68 | temp71);
    211211                u8_error = u8.badprefix
    212                 u8.scope22 = bitutil.Advance(u8.prefix2)
     212                u8.scope22 = pablo.Advance(u8.prefix2)
    213213                u8anyscope = u8.scope22
    214214                if u8.prefix3 | u8.prefix4:
     
    228228#
    229229
    230 #                       scope3_32 = bitutil.Advance32(u8.prefix3)
    231 #                       scope4_32 = bitutil.Advance32(u8.prefix4)
     230#                       scope3_32 = pablo.Advance32(u8.prefix3)
     231#                       scope4_32 = pablo.Advance32(u8.prefix4)
    232232#                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    233233#                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
     
    236236#                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    237237#
    238                         u8.scope32 = bitutil.Advance(u8.prefix3)
    239                         u8.scope33 = bitutil.Advance(u8.scope32)
    240                         u8.scope42 = bitutil.Advance(u8.prefix4)
    241                         u8.scope43 = bitutil.Advance(u8.scope42)
    242                         u8.scope44 = bitutil.Advance(u8.scope43)
     238                        u8.scope32 = pablo.Advance(u8.prefix3)
     239                        u8.scope33 = pablo.Advance(u8.scope32)
     240                        u8.scope42 = pablo.Advance(u8.prefix4)
     241                        u8.scope43 = pablo.Advance(u8.scope42)
     242                        u8.scope44 = pablo.Advance(u8.scope43)
    243243#
    244 #                       u8.xE0_scope = bitutil.Advance(xE0);
    245 #                       u8.xED_scope = bitutil.Advance(xED);
    246 #                       u8.xF0_scope = bitutil.Advance(xF0);
    247 #                       u8.xF4_scope = bitutil.Advance(xF4);
    248                         E0_F0_scope = bitutil.Advance(xE0 | xF0)
    249                         ED_F4_scope = bitutil.Advance(xED | xF4)
     244#                       u8.xE0_scope = pablo.Advance(xE0);
     245#                       u8.xED_scope = pablo.Advance(xED);
     246#                       u8.xF0_scope = pablo.Advance(xF0);
     247#                       u8.xF4_scope = pablo.Advance(xF4);
     248                        E0_F0_scope = pablo.Advance(xE0 | xF0)
     249                        ED_F4_scope = pablo.Advance(xED | xF4)
    250250                        u8.xE0_scope = u8.scope32 & E0_F0_scope
    251251                        u8.xED_scope = u8.scope32 & ED_F4_scope
    252252                        u8.xF0_scope = u8.scope42 & E0_F0_scope
    253253                        u8.xF4_scope = u8.scope42 & ED_F4_scope
    254                         u8.xEF_scope = bitutil.Advance(xEF);
     254                        u8.xEF_scope = pablo.Advance(xEF);
    255255
    256256                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
     
    264264                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4
    265265
    266                         EF_BF_pending = bitutil.Advance(u8.xEF_scope & u8.xBF)
     266                        EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF)
    267267
    268268                        u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
     
    284284        v = lex.LAngle | lex.Hyphen
    285285        w = lex.Hyphen | lex.QMark
    286         v1 = bitutil.Advance(v)
    287         w1 = bitutil.Advance(w)
    288        
    289         LAngle_scope = v1 &~ w1  #bitutil.Advance(lex.LAngle)
     286        v1 = pablo.Advance(v)
     287        w1 = pablo.Advance(w)
     288       
     289        LAngle_scope = v1 &~ w1  #pablo.Advance(lex.LAngle)
    290290        PI_opener = LAngle_scope & lex.QMark
    291291        CtCD_opener= LAngle_scope & lex.Exclam
     
    296296        #PI_closer = 0
    297297       
    298         #if lex.Hyphen: DoubleHyphen = bitutil.Advance(lex.Hyphen) & lex.Hyphen
     298        #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    299299        DoubleHyphen = v1 & w1 & lex.Hyphen
    300300        if lex.RBracket:
    301                 DoubleRBracket = bitutil.Advance(lex.RBracket) & lex.RBracket
    302                 CD_closer = bitutil.Advance(DoubleRBracket) & lex.RAngle
    303         #if lex.QMark: PI_closer = bitutil.Advance(lex.QMark) & lex.RAngle
     301                DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket
     302                CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle
     303        #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    304304        PI_closer = w1 & ~v1 & lex.RAngle
    305305
    306306        #
    307307        # Initiate the scan
    308         CtCDPI_Cursor = bitutil.ScanToFirst(CtCDPI_opener)
     308        CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener)
    309309        while CtCDPI_Cursor:
    310310                CtCDPI_starts |= CtCDPI_Cursor
    311311                PI_Cursor = CtCDPI_Cursor & PI_opener
    312                 CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
     312                CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor)
    313313                CD_Cursor = CD_Ct_Cursor & lex.LBracket
    314314                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
     
    316316                if PI_Cursor:
    317317                        callouts.Symbol_starts |= PI_Cursor
    318                         PI_Cursor = bitutil.Advance(PI_Cursor)
     318                        PI_Cursor = pablo.Advance(PI_Cursor)
    319319                        # Check
    320320                        # ctCDPI_Callouts.PI_name_starts |= PI_Cursor
    321                         PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
     321                        PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan)
    322322                        PI_error = PI_Cursor & PI_name_end
    323                         PI_error |= bitutil.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
     323                        PI_error |= pablo.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
    324324                        if PI_error:
    325325                                error_tracker.NoteError("Error in PI syntax", PI_name_end)
    326326                        callouts.Symbol_ends |= PI_name_end
    327327                        callouts.Transition_marks |= PI_name_end
    328                         PI_Cursor = bitutil.ScanTo(PI_name_end, PI_closer)
     328                        PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer)
    329329                        CtCDPI_ends |= PI_Cursor
    330330
    331331                # CDATA section processing
    332332                if CD_Cursor:
    333                         CD_Cursor = bitutil.ScanTo(CD_Cursor, CD_closer)
     333                        CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer)
    334334                        CtCDPI_ends |= CD_Cursor
    335335
    336336                # Comment processing
    337337                if Ct_Cursor:
    338                         Ct_Cursor = bitutil.Advance(Ct_Cursor) 
     338                        Ct_Cursor = pablo.Advance(Ct_Cursor) 
    339339                        Ct_error = Ct_Cursor & ~ lex.Hyphen
    340340                        # Advance twice past <!--, so that we don't treat <!---
    341341                        # as being a terminated comment.
    342                         Ct_Cursor = bitutil.Advance(bitutil.Advance(Ct_Cursor))
    343                         Ct_Cursor = bitutil.Advance(bitutil.ScanTo(Ct_Cursor, DoubleHyphen))
     342                        Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor))
     343                        Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen))
    344344                        Ct_error |= Ct_Cursor & ~ lex.RAngle   
    345345                        CtCDPI_ends |= Ct_Cursor
     
    349349                # Common processing
    350350                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
    351                 CtCDPI_Cursor = bitutil.ScanTo(CtCDPI_Cursor, CtCDPI_opener)   
     351                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)     
    352352                ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends             
    353353                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    354                 ctCDPI_error = bitutil.atEOF(ctCDPI_mask)
     354                ctCDPI_error = pablo.atEOF(ctCDPI_mask)
    355355       
    356356                if ctCDPI_error:
     
    384384        # Advance all cursors by scanning through the tag name.
    385385        callouts.Symbol_starts |= ElemName_starts
    386         elem_name_ends = bitutil.ScanThru(ElemName_starts, lex.NameScan)
     386        elem_name_ends = pablo.ScanThru(ElemName_starts, lex.NameScan)
    387387        callouts.Symbol_ends = elem_name_ends
    388388        # Must have at least one name character for a legal start tag.
     
    392392        # After the element name, there may or may not be an attlist.
    393393        if elem_name_ends & lex.WS:
    394                 AfterWS = bitutil.ScanThru(elem_name_ends, lex.WS)
     394                AfterWS = pablo.ScanThru(elem_name_ends, lex.WS)
    395395                AttListEnd = AfterWS & AttListDelim
    396396                AttNameStart = AfterWS & ~AttListDelim
     
    403403                        ParseError |= AttNameStart &~ lex.NameScan
    404404                        callouts.Symbol_starts |= AttNameStart
    405                         AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
     405                        AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan)
    406406                        callouts.Symbol_ends |= AttNameFollow
    407407                        # Mark the position from which the AttName may be retrieved.
    408408                        callouts.Transition_marks |= AttNameFollow
    409409                        # Scan through WS to the expected '=' delimiter.
    410                         # EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     410                        # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    411411                        # But use if test to optimize.
    412412                        if AttNameFollow & lex.WS:
    413                                 EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     413                                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    414414                        else: EqExpected = AttNameFollow
    415415                        ParseError |= EqExpected &~ lex.Equals
    416                         AttValPos = bitutil.ScanThru(EqExpected, EqExpected | lex.WS)
     416                        AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    417417                        callouts.Transition_marks |= AttValPos
    418418                        DQuoteAttVal = AttValPos & lex.DQuote
    419419                        SQuoteAttVal = AttValPos & lex.SQuote
    420                         DQuoteAttEnd = bitutil.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    421                         SQuoteAttEnd = bitutil.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
     420                        DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
     421                        SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    422422                        AttValEnd = DQuoteAttEnd | SQuoteAttEnd
    423423                        ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote)
    424                         AttValFollow = bitutil.Advance(AttValEnd)
     424                        AttValFollow = pablo.Advance(AttValEnd)
    425425                        callouts.Transition_marks |= AttValEnd
    426                         #  AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
     426                        #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    427427                        if AttValFollow & lex.WS:
    428                                 AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
     428                                AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
    429429                                AttListEnd |= AfterWS & AttListDelim
    430430                                AttNameStart = AfterWS & ~AttListDelim
     
    440440        STagEnds = AttListEnd & lex.RAngle
    441441        # Mark any "/" characters found as the ends of empty element tags.
    442         EmptyTag_marks = bitutil.Advance(AttListEnd & lex.Slash)
     442        EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash)
    443443
    444444        #  TODO - Check         
     
    450450       
    451451        #  TODO - Check
    452         # EndTagEnds = bitutil.ScanThru(tag_Callouts.EndTag_marks, tag_Callouts.EndTag_marks | lex.NameScan)
    453         EndTagEnds = bitutil.ScanThru(EndTag_marks, EndTag_marks | lex.NameScan)
     452        # EndTagEnds = pablo.ScanThru(tag_Callouts.EndTag_marks, tag_Callouts.EndTag_marks | lex.NameScan)
     453        EndTagEnds = pablo.ScanThru(EndTag_marks, EndTag_marks | lex.NameScan)
    454454        if EndTagEnds & lex.WS:
    455                 EndTagEnds = bitutil.ScanThru(EndTagEnds, lex.WS)
     455                EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS)
    456456        ParseError |= EndTagEnds & ~lex.RAngle
    457457        if ParseError:
     
    470470                # ScanThru from next including all Name characters as well as # for
    471471                # either general or numeric references.   Symbol table will validate.
    472                 ref_ends = bitutil.ScanThru(marker.Ref_opener, lex.NameScan | marker.Ref_opener | lex.Hash)
     472                ref_ends = pablo.ScanThru(marker.Ref_opener, lex.NameScan | marker.Ref_opener | lex.Hash)
    473473                ref_error = ref_ends &~ lex.Semicolon
    474474                if ref_error:
  • proto/parabix2/parabix2_pablo.py

    r1439 r1440  
    222222        lex.Hex = (temp62 | temp65);
    223223        lex_error = x00_x1F &~ lex.WS
    224         if bitutil.inFile(lex_error):
     224        if pablo.inFile(lex_error):
    225225                error_tracker.NoteError("Error: illegal character", lex_error)
    226226               
     
    246246                u8.badprefix = (temp68 | temp71);
    247247                u8_error = u8.badprefix
    248                 u8.scope22 = bitutil.Advance(u8.prefix2)
     248                u8.scope22 = pablo.Advance(u8.prefix2)
    249249                u8anyscope = u8.scope22
    250250                if u8.prefix3 | u8.prefix4:
     
    264264#
    265265
    266 #                       scope3_32 = bitutil.Advance32(u8.prefix3)
    267 #                       scope4_32 = bitutil.Advance32(u8.prefix4)
     266#                       scope3_32 = pablo.Advance32(u8.prefix3)
     267#                       scope4_32 = pablo.Advance32(u8.prefix4)
    268268#                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
    269269#                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
     
    272272#                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
    273273#
    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)
     274                        u8.scope32 = pablo.Advance(u8.prefix3)
     275                        u8.scope33 = pablo.Advance(u8.scope32)
     276                        u8.scope42 = pablo.Advance(u8.prefix4)
     277                        u8.scope43 = pablo.Advance(u8.scope42)
     278                        u8.scope44 = pablo.Advance(u8.scope43)
     279#
     280#                       u8.xE0_scope = pablo.Advance(xE0);
     281#                       u8.xED_scope = pablo.Advance(xED);
     282#                       u8.xF0_scope = pablo.Advance(xF0);
     283#                       u8.xF4_scope = pablo.Advance(xF4);
     284                        E0_F0_scope = pablo.Advance(xE0 | xF0)
     285                        ED_F4_scope = pablo.Advance(xED | xF4)
    286286                        u8.xE0_scope = u8.scope32 & E0_F0_scope
    287287                        u8.xED_scope = u8.scope32 & ED_F4_scope
    288288                        u8.xF0_scope = u8.scope42 & E0_F0_scope
    289289                        u8.xF4_scope = u8.scope42 & ED_F4_scope
    290                         u8.xEF_scope = bitutil.Advance(xEF);
     290                        u8.xEF_scope = pablo.Advance(xEF);
    291291
    292292                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
     
    300300                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4
    301301
    302                         EF_BF_pending = bitutil.Advance(u8.xEF_scope & u8.xBF)
     302                        EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF)
    303303
    304304                        u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
     
    324324        v = lex.LAngle | lex.Hyphen
    325325        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)
     326        v1 = pablo.Advance(v)
     327        w1 = pablo.Advance(w)
     328       
     329        LAngle_scope = v1 &~ w1  #pablo.Advance(lex.LAngle)
    330330        PI_opener = LAngle_scope & lex.QMark
    331331        CtCD_opener= LAngle_scope & lex.Exclam
     
    336336        #PI_closer = 0
    337337       
    338         #if lex.Hyphen: DoubleHyphen = bitutil.Advance(lex.Hyphen) & lex.Hyphen
     338        #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
    339339        DoubleHyphen = v1 & w1 & lex.Hyphen
    340340        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
     341                DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket
     342                CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle
     343        #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
    344344        PI_closer = w1 & ~v1 & lex.RAngle
    345345
    346346        #
    347347        # Initiate the scan
    348         CtCDPI_Cursor = bitutil.ScanToFirst(CtCDPI_opener)
     348        CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener)
    349349        while CtCDPI_Cursor:
    350350                CtCDPI_starts |= CtCDPI_Cursor
    351351                PI_Cursor = CtCDPI_Cursor & PI_opener
    352                 CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
     352                CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor)
    353353                CD_Cursor = CD_Ct_Cursor & lex.LBracket
    354354                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
     
    356356                if PI_Cursor:
    357357                        ctCDPI_Callouts.PI_starts |= PI_Cursor
    358                         PI_Cursor = bitutil.Advance(PI_Cursor)
     358                        PI_Cursor = pablo.Advance(PI_Cursor)
    359359                        ctCDPI_Callouts.PI_name_starts |= PI_Cursor
    360                         PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
     360                        PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan)
    361361                        PI_error = PI_Cursor & PI_name_end
    362                         PI_error |= bitutil.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
     362                        PI_error |= pablo.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
    363363                        if PI_error:
    364364                                error_tracker.NoteError("Error in PI syntax", PI_name_end)
    365365                        ctCDPI_Callouts.PI_name_ends |= PI_name_end
    366                         PI_Cursor = bitutil.ScanTo(PI_name_end, PI_closer)
     366                        PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer)
    367367                        ctCDPI_Callouts.PI_ends |= PI_Cursor
    368368                        CtCDPI_ends |= PI_Cursor
     
    371371                if CD_Cursor:
    372372                        ctCDPI_Callouts.CD_starts |= CD_Cursor
    373                         CD_Cursor = bitutil.ScanTo(CD_Cursor, CD_closer)
     373                        CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer)
    374374                        ctCDPI_Callouts.CD_ends |= CD_Cursor
    375375                        CtCDPI_ends |= CD_Cursor
     
    378378                if Ct_Cursor:
    379379                        ctCDPI_Callouts.Ct_starts |= Ct_Cursor
    380                         Ct_Cursor = bitutil.Advance(Ct_Cursor) 
     380                        Ct_Cursor = pablo.Advance(Ct_Cursor) 
    381381                        Ct_error = Ct_Cursor & ~ lex.Hyphen
    382382                        # Advance twice past <!--, so that we don't treat <!---
    383383                        # as being a terminated comment.
    384                         Ct_Cursor = bitutil.Advance(bitutil.Advance(Ct_Cursor))
    385                         Ct_Cursor = bitutil.Advance(bitutil.ScanTo(Ct_Cursor, DoubleHyphen))
     384                        Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor))
     385                        Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen))
    386386                        Ct_error |= Ct_Cursor & ~ lex.RAngle   
    387387                        ctCDPI_Callouts.Ct_ends |= Ct_Cursor
     
    392392                # Common processing
    393393                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
    394                 CtCDPI_Cursor = bitutil.ScanTo(CtCDPI_Cursor, CtCDPI_opener)   
     394                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)     
    395395                ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends             
    396396                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    397                 ctCDPI_error = bitutil.atEOF(ctCDPI_mask)
     397                ctCDPI_error = pablo.atEOF(ctCDPI_mask)
    398398       
    399399                if ctCDPI_error:
    400400                        error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
    401401               
    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
     402        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
    403403
    404404
     
    423423
    424424        # Advance all cursors by scanning through the tag name.
    425         tag_Callouts.ElemName_ends = bitutil.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
     425        tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
    426426        # Must have at least one name character for a legal start tag.
    427427        # Mark any occurrences of null names as errors.
     
    436436        # After the element name, there may or may not be an attlist.
    437437        if tag_Callouts.ElemName_ends & lex.WS:
    438                 AfterWS = bitutil.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
     438                AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
    439439                AttListEnd = AfterWS & AttListDelim
    440440                AttNameStart = AfterWS & ~AttListDelim
     
    447447                        ParseError |= AttNameStart &~ lex.NameScan
    448448                        tag_Callouts.AttName_starts |= AttNameStart
    449                         AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
     449                        AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan)
    450450                        tag_Callouts.AttName_ends |= AttNameFollow
    451451                        # Scan through WS to the expected '=' delimiter.
    452                         # EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     452                        # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    453453                        # But use if test to optimize.
    454454                        if AttNameFollow & lex.WS:
    455                                 EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     455                                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
    456456                        else: EqExpected = AttNameFollow
    457457                        ParseError |= EqExpected &~ lex.Equals
    458                         AttValPos = bitutil.ScanThru(EqExpected, EqExpected | lex.WS)
     458                        AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
    459459                        tag_Callouts.AttVal_starts |= AttValPos
    460460                        DQuoteAttVal = AttValPos & lex.DQuote
    461461                        SQuoteAttVal = AttValPos & lex.SQuote
    462                         DQuoteAttEnd = bitutil.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    463                         SQuoteAttEnd = bitutil.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
     462                        DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
     463                        SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    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
     
    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.ScanThru(tag_Callouts.EndTag_marks, 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
    494494        if ParseError:
     
    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.
     
    541541        ncname_stream = PI_names | GenRefs
    542542        name_stream = qname_stream | ncname_stream
    543         name_start = name_stream &~ bitutil.Advance(name_stream)
    544         name_cursor = name_stream & ~bitutil.Advance(name_stream)
     543        name_start = name_stream &~ pablo.Advance(name_stream)
     544        name_cursor = name_stream & ~pablo.Advance(name_stream)
    545545        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)
     546        namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon
     547        local_part_start = pablo.Advance(namespace_sep)
    548548        local_part_err = local_part_start &~ lex.NameScan
    549         colon2_err = bitutil.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
     549        colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
    550550        ncname_err = ncname_stream & lex.Colon
    551551        namespace_error = void_prefix_err | local_part_err | colon2_err | ncname_err
Note: See TracChangeset for help on using the changeset viewer.