Changeset 1440 for proto/Xerces


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.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • 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:
Note: See TracChangeset for help on using the changeset viewer.