Changeset 1440 for proto/parabix2


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/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.