Changeset 1276 for proto/Xerces


Ignore:
Timestamp:
Aug 4, 2011, 9:37:48 AM (8 years ago)
Author:
cameron
Message:

Updated Pablo prototypes for Xerces.

Location:
proto/Xerces
Files:
2 deleted
1 edited

Legend:

Unmodified
Added
Removed
  • proto/Xerces/parabix_xerces.py

    r1223 r1276  
    99# Robert D. Cameron
    1010
    11 class Lex():
     11class Basis_bits():     
     12        bit_0 = 0
     13        bit_1 = 0
     14        bit_2 = 0
     15        bit_3 = 0
     16        bit_4 = 0
     17        bit_5 = 0
     18        bit_6 = 0
     19        bit_7 = 0
     20
     21
     22class u8 ():
     23  unibyte = 0
     24  prefix = 0
     25  prefix2 = 0
     26  prefix3 = 0
     27  prefix4 = 0
     28  suffix = 0
     29  badprefix = 0
     30  xE0 = 0
     31  xED = 0
     32  xF0 = 0
     33  xF4 = 0
     34  xA0_xBF = 0
     35  x80_x9F = 0
     36  x90_xBF = 0
     37  x80_x8F = 0
     38  xEF = 0
     39  xBF = 0
     40  xBE = 0
     41  scope22 = 0
     42  scope32 = 0
     43  scope33 = 0
     44  scope42 = 0
     45  scope43 = 0
     46  scope44 = 0
     47  xE0_scope = 0
     48  xED_scope = 0
     49  xF0_scope = 0
     50  xF4_scope = 0
     51  xEF_scope = 0
     52
     53class Lex ():
     54        CR = 0
     55        LF = 0
     56        HT = 0
     57        SP = 0
     58        CRLF = 0
    1259        RefStart = 0
    1360        Semicolon = 0 
     
    3380        WS = 0
    3481
    35 class Control():
    36 # The delmask marks bit stream positions that should be
    37 # considered deleted, i.e., positions at no corresponding
    38 # character data should be produced.
    39         delmask = 0
    40         XML_error = 0  # 0x0-0x1F except HT, LF CR, 0xFFFE, 0xFFFF
    41         ch_error = 0   # Bad UTF8 characters
    42         normalized_LF = 0
    43         HT = 0
    44         pseudo_bit0 = 0
    45 
    46 class Scope1 ():
    47         RefStart = 0
     82class Marker ():
    4883        LAngle = 0
    49         Hyphen = 0
    50         QMark = 0
    51         RBracket = 0
    52 
    53 class CtCDPI_Callouts():
    54         CD_end = 0
    55         Ct_starts = 0
    56         Ct_ends = 0
    57         CD_starts = 0
    58         CD_ends = 0
    59         PI_starts = 0
    60         PI_name_starts = 0
    61         PI_name_ends = 0
    62         PI_ends = 0
    63         CtCDPI_mask = 0
    64         error = 0
    65 
    66 class Ref_Callouts():
    67         GenRef_starts = 0
    68         GenRef_ends = 0
    69         DecRef_starts = 0
    70         DecRef_ends = 0
    71         HexRef_starts = 0
    72         HexRef_ends = 0
    73         error = 0
    74 
    75 class Tag_Callouts():
    76         ElemName_starts = 0
    77         ElemName_ends = 0
    78         AttName_starts = 0
    79         AttName_ends = 0
    80         AttVal_starts = 0
    81         AttVal_ends = 0
    82         AttVal_spans = 0
    83         EmptyTag_marks = 0
    84         EndTag_marks = 0
    85         error = 0
     84        Tag_opener = 0
     85        Ref_opener = 0
     86        CD_closer = 0
     87
     88class Callouts():
     89        Symbol_starts = 0
     90        Symbol_ends = 0
     91        Transition_marks = 0
     92        Nonplain = 0
     93
     94def Classify_bytes_Validate_utf8(basis_bits, lex, u8): 
     95        temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
     96        temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
     97        temp3 = (temp2 &~ temp1);
     98        temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
     99        temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
     100        temp6 = (temp4 & temp5);
     101        lex.RefStart = (temp3 & temp6);
     102        temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
     103        temp8 = (temp7 &~ temp1);
     104        temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
     105        temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
     106        temp11 = (temp9 & temp10);
     107        lex.Semicolon = (temp8 & temp11);
     108        temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
     109        temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
     110        temp14 = (temp12 &~ temp13);
     111        lex.LAngle = (temp8 & temp14);
     112        temp15 = (temp12 & temp5);
     113        lex.RAngle = (temp8 & temp15);
     114        temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
     115        temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
     116        temp18 = (temp16 & temp17);
     117        lex.LBracket = (temp18 & temp11);
     118        temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
     119        temp20 = (temp12 & temp19);
     120        lex.RBracket = (temp18 & temp20);
     121        temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
     122        temp22 = (temp19 &~ temp21);
     123        lex.Exclam = (temp3 & temp22);
     124        temp23 = (temp12 & temp10);
     125        lex.QMark = (temp8 & temp23);
     126        lex.Hyphen = (temp3 & temp20);
     127        lex.Equals = (temp8 & temp20);
     128        temp24 = (temp4 & temp10);
     129        lex.SQuote = (temp3 & temp24);
     130        temp25 = (temp5 &~ temp21);
     131        lex.DQuote = (temp3 & temp25);
     132        lex.Slash = (temp3 & temp23);
     133        temp26 = (temp10 &~ temp21);
     134        lex.Hash = (temp3 & temp26);
     135        temp27 = (temp16 & temp7);
     136        temp28 = (temp9 &~ temp13);
     137        lex.x = (temp27 & temp28);
     138        temp29 = (temp9 & temp5);
     139        lex.Colon = (temp8 & temp29);
     140        temp30 = (temp18 & temp23);
     141        temp31 = (temp30 | lex.Colon);
     142        temp32 = (temp16 &~ basis_bits.bit_2);
     143        temp33 = (basis_bits.bit_5 | temp10);
     144        temp34 = (basis_bits.bit_4 & temp33);
     145        temp35 = (~temp34);
     146        temp36 = (temp21 | temp13);
     147        temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
     148        temp38 = (temp32 & temp37);
     149        temp39 = (temp31 | temp38);
     150        temp40 = (temp16 & basis_bits.bit_2);
     151        temp41 = (temp40 & temp37);
     152        lex.ASCII_name_start = (temp39 | temp41);
     153        temp42 = (temp30 | lex.Hyphen);
     154        temp43 = (temp3 & temp15);
     155        temp44 = (temp42 | temp43);
     156        temp45 = (temp8 &~ temp34);
     157        temp46 = (temp44 | temp45);
     158        temp47 = (temp46 | temp38);
     159        lex.ASCII_name_char = (temp47 | temp41);
     160        lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
     161        temp48 = (temp1 | basis_bits.bit_2);
     162        x00_x1F = (~temp48);
     163        temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
     164        temp50 = (temp1 | temp49);
     165        lex.CR = (temp20 &~ temp50);
     166        lex.LF = (temp29 &~ temp50);
     167        temp51 = (temp9 & temp19);
     168        lex.HT = (temp51 &~ temp50);
     169        lex.SP = (temp3 &~ temp36);
     170        temp52 = (temp20 | temp29);
     171        temp53 = (temp52 | temp51);
     172        temp54 = (temp53 &~ temp50);
     173        lex.WS = (temp54 | lex.SP);
     174        temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
     175        temp56 = (basis_bits.bit_4 & temp55);
     176        lex.Digit = (temp8 &~ temp56);
     177        temp57 = (temp16 &~ temp49);
     178        temp58 = (temp57 &~ basis_bits.bit_4);
     179        temp59 = (~temp10);
     180        temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
     181        temp61 = (temp58 & temp60);
     182        temp62 = (lex.Digit | temp61);
     183        temp63 = (temp16 & temp2);
     184        temp64 = (temp63 &~ basis_bits.bit_4);
     185        temp65 = (temp64 & temp60);
     186        lex.Hex = (temp62 | temp65);
     187        lex_error = x00_x1F &~ lex.WS
     188        if lex_error & EOF_mask:
     189                error_tracker.NoteError("Error: illegal character", lex_error)
    86190               
    87 class Check_streams():
    88         non_ascii_name_starts = 0
    89         non_ascii_names = 0
    90         tag_marks = 0
    91         name_follows = 0
    92         att_refs = 0
    93         error_mask = 0
    94 
    95 class Xml_names():
    96         namespace_error = 0
    97 
    98        
    99 def Add_scope_streams(lex, scope1):
    100         #scope1.LAngle = bitutil.Advance(lex.LAngle)
    101         #scope1.Hyphen = bitutil.Advance(lex.Hyphen)
    102         #scope1.QMark = bitutil.Advance(lex.QMark)
     191       
     192        ### Validate_utf8(basis_bits, u8):
     193        u8.unibyte = (~basis_bits.bit_0);
     194        u8.suffix = 0
     195        u8_error = 0
     196        u8_FFFE_FFFF = 0
     197        u8anyscope = 0 #local
     198        if basis_bits.bit_0:
     199                u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
     200                u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
     201                u8.prefix3 = (u8.prefix & temp2);
     202                u8.prefix4 = (u8.prefix & temp7);
     203                u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
     204                temp66 = (u8.prefix &~ temp49);
     205                temp67 = (temp21 | basis_bits.bit_6);
     206                temp68 = (temp66 &~ temp67);
     207                temp69 = (basis_bits.bit_5 & temp13);
     208                temp70 = (basis_bits.bit_4 | temp69);
     209                temp71 = (u8.prefix4 & temp70);
     210                u8.badprefix = (temp68 | temp71);
     211                u8_error = u8.badprefix
     212                u8.scope22 = bitutil.Advance(u8.prefix2)
     213                u8anyscope = u8.scope22
     214                if u8.prefix3 | u8.prefix4:
     215                        xE0 = (u8.prefix3 &~ temp36);
     216                        xED = (u8.prefix3 & temp20);
     217                        xF0 = (u8.prefix4 &~ temp36);
     218                        temp72 = (temp4 &~ temp13);
     219                        xF4 = (u8.prefix4 & temp72);
     220                        u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
     221                        u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
     222                        u8.x90_xBF = (u8.suffix & temp49);
     223                        u8.x80_x8F = (u8.suffix &~ temp49);
     224                        xEF = (u8.prefix3 & temp23);
     225                        temp73 = (u8.suffix & temp7);
     226                        u8.xBF = (temp73 & temp23);
     227                        u8.xBE = (temp73 & temp15);
     228#
     229
     230#                       scope3_32 = bitutil.Advance32(u8.prefix3)
     231#                       scope4_32 = bitutil.Advance32(u8.prefix4)
     232#                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
     233#                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
     234#                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
     235#                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
     236#                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
     237#
     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)
     243#
     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)
     250                        u8.xE0_scope = u8.scope32 & E0_F0_scope
     251                        u8.xED_scope = u8.scope32 & ED_F4_scope
     252                        u8.xF0_scope = u8.scope42 & E0_F0_scope
     253                        u8.xF4_scope = u8.scope42 & ED_F4_scope
     254                        u8.xEF_scope = bitutil.Advance(xEF);
     255
     256                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
     257                        u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43
     258               
     259                        u8error1 = u8.xE0_scope & u8.x80_x9F
     260                        u8error2 = u8.xED_scope & u8.xA0_xBF
     261                        u8error3 = u8.xF0_scope & u8.x80_x8F
     262                        u8error4 = u8.xF4_scope & u8.x90_xBF
     263       
     264                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4
     265
     266                        EF_BF_pending = bitutil.Advance(u8.xEF_scope & u8.xBF)
     267
     268                        u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
     269                u8mismatch = u8anyscope ^ u8.suffix
     270                u8_error |= u8mismatch | u8_FFFE_FFFF
     271                if u8_error:
     272                        error_tracker.NoteError("UTF-8 error found", (u8_error))
     273                       
     274       
     275def Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams):
     276        callouts.Symbol_starts = 0
     277        callouts.Symbol_ends = 0
     278
     279
     280        CtCDPI_starts = 0
     281        CtCDPI_ends = 0
     282        ctCDPI_mask = 0
     283
    103284        v = lex.LAngle | lex.Hyphen
    104285        w = lex.Hyphen | lex.QMark
    105286        v1 = bitutil.Advance(v)
    106         w1 = bitutil.Advance(w)
    107         scope1.LAngle = v1 &~ w1
    108         scope1.Hyphen = v1 & w1
    109         scope1.QMark = w1 &~ v1
    110 
    111 def Parse_CtCDPI(ctCDPI_Callouts, lex, scope1, check_streams):
    112         ctCDPI_Callouts.CD_end = 0
    113         ctCDPI_Callouts.Ct_starts = 0
    114         ctCDPI_Callouts.Ct_ends = 0
    115         ctCDPI_Callouts.CD_starts = 0
    116         ctCDPI_Callouts.CD_ends = 0
    117         ctCDPI_Callouts.PI_starts = 0
    118         ctCDPI_Callouts.PI_name_starts = 0
    119         ctCDPI_Callouts.PI_name_ends = 0
    120         ctCDPI_Callouts.PI_ends = 0
    121         ctCDPI_Callouts.CtCDPI_mask = 0
    122         ctCDPI_Callouts.error = 0
    123         CtCDPI_starts = 0
    124         Ct_errors = 0
    125 
     287        w1 = bitutil.Advance(w)
     288       
     289        LAngle_scope = v1 &~ w1  #bitutil.Advance(lex.LAngle)
     290        PI_opener = LAngle_scope & lex.QMark
     291        CtCD_opener= LAngle_scope & lex.Exclam
     292        CtCDPI_opener = PI_opener | CtCD_opener
     293
     294        #DoubleHyphen = 0
     295        CD_closer = 0
     296        #PI_closer = 0
     297       
     298        #if lex.Hyphen: DoubleHyphen = bitutil.Advance(lex.Hyphen) & lex.Hyphen
     299        DoubleHyphen = v1 & w1 & lex.Hyphen
    126300        if lex.RBracket:
    127                 scope1.RBracket = bitutil.Advance(lex.RBracket)
    128                 ctCDPI_Callouts.CD_end = bitutil.Advance(scope1.RBracket & lex.RBracket) & lex.RAngle
    129         PI_start = scope1.LAngle & lex.QMark
    130         CtCD_start = scope1.LAngle & lex.Exclam
    131         CtCDPI_start = PI_start | CtCD_start
    132 
    133         DoubleHyphen = scope1.Hyphen & lex.Hyphen
    134         PI_end = scope1.QMark & lex.RAngle
     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
     304        PI_closer = w1 & ~v1 & lex.RAngle
    135305
    136306        #
    137307        # Initiate the scan
    138         CtCDPI_Cursor = bitutil.ScanToFirst(CtCDPI_start)
     308        CtCDPI_Cursor = bitutil.ScanToFirst(CtCDPI_opener)
    139309        while CtCDPI_Cursor:
    140310                CtCDPI_starts |= CtCDPI_Cursor
    141                 PI_Cursor = CtCDPI_Cursor & PI_start
     311                PI_Cursor = CtCDPI_Cursor & PI_opener
    142312                CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
    143313                CD_Cursor = CD_Ct_Cursor & lex.LBracket
    144314                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
    145                 ctCDPI_Callouts.PI_starts |= PI_Cursor
    146                 ctCDPI_Callouts.CD_starts |= CD_Cursor
    147                 ctCDPI_Callouts.Ct_starts |= Ct_Cursor
    148                 Ct_Cursor = bitutil.Advance(Ct_Cursor) 
    149                 Ct_errors |= Ct_Cursor & ~ lex.Hyphen
    150                 # Advance twice past <!--, so that we don't treat <!---
    151                 # as being a terminated comment.
    152                 Ct_Cursor = bitutil.Advance(bitutil.Advance(Ct_Cursor))
    153                 PI_Cursor = bitutil.Advance(PI_Cursor)
    154                 ctCDPI_Callouts.PI_name_starts |= PI_Cursor
    155                 PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
    156                 ctCDPI_Callouts.PI_name_ends |= PI_name_end
    157                 PI_Cursor = bitutil.ScanTo(PI_name_end, PI_end)
    158                 CD_Cursor = bitutil.ScanTo(CD_Cursor, ctCDPI_Callouts.CD_end)
    159                 Ct_Cursor = bitutil.Advance(bitutil.ScanTo(Ct_Cursor, DoubleHyphen))
    160                 ctCDPI_Callouts.PI_ends |= PI_Cursor
    161                 ctCDPI_Callouts.CD_ends |= CD_Cursor
    162                 ctCDPI_Callouts.Ct_ends |= Ct_Cursor
     315                # PI processing
     316                if PI_Cursor:
     317                        callouts.Symbol_starts |= PI_Cursor
     318                        PI_Cursor = bitutil.Advance(PI_Cursor)
     319                        ctCDPI_Callouts.PI_name_starts |= PI_Cursor
     320                        PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
     321                        PI_error = PI_Cursor & PI_name_end
     322                        PI_error |= bitutil.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
     323                        if PI_error:
     324                                error_tracker.NoteError("Error in PI syntax", PI_name_end)
     325                        callouts.Symbol_ends |= PI_name_end
     326                        PI_Cursor = bitutil.ScanTo(PI_name_end, PI_closer)
     327                        CtCDPI_ends |= PI_Cursor
     328
     329                # CDATA section processing
     330                if CD_Cursor:
     331                        CD_Cursor = bitutil.ScanTo(CD_Cursor, CD_closer)
     332                        CtCDPI_ends |= CD_Cursor
     333
     334                # Comment processing
     335                if Ct_Cursor:
     336                        Ct_Cursor = bitutil.Advance(Ct_Cursor) 
     337                        Ct_error = Ct_Cursor & ~ lex.Hyphen
     338                        # Advance twice past <!--, so that we don't treat <!---
     339                        # as being a terminated comment.
     340                        Ct_Cursor = bitutil.Advance(bitutil.Advance(Ct_Cursor))
     341                        Ct_Cursor = bitutil.Advance(bitutil.ScanTo(Ct_Cursor, DoubleHyphen))
     342                        Ct_error |= Ct_Cursor & ~ lex.RAngle   
     343                        CtCDPI_ends |= Ct_Cursor
     344                        if Ct_error:
     345                                error_tracker.NoteError("Error in comment syntax", Ct_error)
     346
     347                # Common processing
    163348                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
    164                 CtCDPI_Cursor = bitutil.ScanTo(CtCDPI_Cursor, CtCDPI_start)
    165        
    166                 ctCDPI_Callouts.CtCDPI_mask = bitutil.Advance(ctCDPI_Callouts.CD_ends | ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) - CtCDPI_starts             
    167                 #ctCDPI_Callouts.error = Ct_ends & ~lex.RAngle | Ct_starts & ~ lex.Hyphen
    168                 ctCDPI_Callouts.error = Ct_errors | ctCDPI_Callouts.Ct_ends & ~lex.RAngle
    169                 ctCDPI_Callouts.error |= bitutil.Advance(ctCDPI_Callouts.PI_name_ends & ~ lex.WS) & ~ PI_end
    170                 ctCDPI_Callouts.error |= ctCDPI_Callouts.PI_name_starts & ctCDPI_Callouts.PI_name_ends
     349                CtCDPI_Cursor = bitutil.ScanTo(CtCDPI_Cursor, CtCDPI_opener)   
     350                ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends             
    171351                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    172                 ctCDPI_Callouts.error |= ctCDPI_Callouts.CtCDPI_mask &~ EOF_mask
     352                ctCDPI_error = ctCDPI_mask &~ EOF_mask
     353       
     354                if ctCDPI_error:
     355                        error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
    173356               
    174 
    175 def Parse_tags(lex, scope1, ctCDPI_Callouts, tag_Callouts):
    176 
     357        callouts.Transition_marks = CtCDPI_starts | CtCDPI_ends
     358
     359        # Identify the remaining significant markers for XML processing.
     360        marker.LAngle = lex.LAngle &~ ctCDPI_mask
     361        marker.Tag_opener = LAngle_scope &~ ctCDPI_mask
     362        marker.Ref_opener = lex.RefStart &~ ctCDPI_mask
     363        marker.CD_closer = CD_closer &~ ctCDPI_mask
     364
     365def Parse_tags(lex, marker, callouts):
    177366       
    178367        # Delimiters for scans.
     
    180369        SQuoteDelim = lex.SQuote | lex.LAngle
    181370        AttListDelim = lex.Slash | lex.RAngle
     371
     372        # Marks 2nd character of start, empty and end tags
     373        callouts.Transition_marks = marker.Tag_opener
    182374       
    183375        # Start the parallel parsing by inspecting the character
    184376        # after the opening "<" of a tag.
    185         LAngleFollow = scope1.LAngle &~ ctCDPI_Callouts.CtCDPI_mask
    186         tag_Callouts.ElemName_starts = LAngleFollow & ~lex.Slash
    187         tag_Callouts.EndTag_marks = LAngleFollow & lex.Slash
     377        elem_name_starts = marker.Tag_opener & ~lex.Slash
     378        end_tag_marks = marker.Tag_opener & lex.Slash
    188379       
    189380        # Start Tag/Empty Element Tag Parsing
    190381
    191382        # Advance all cursors by scanning through the tag name.
    192         tag_Callouts.ElemName_ends = bitutil.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
     383        callouts.Symbol_starts |= elem_name_starts
     384        elem_name_ends = bitutil.ScanThru(elem_name_starts, lex.NameScan)
     385        callouts.Symbol_ends = elem_name_ends
    193386        # Must have at least one name character for a legal start tag.
    194387        # Mark any occurrences of null names as errors.
    195         ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends
    196        
    197         # Initialize the accumulators for attribute name and value positions.
    198         tag_Callouts.AttName_starts = 0 
    199         tag_Callouts.AttName_ends = 0
    200         EqToCheck = 0
    201         tag_Callouts.AttVal_starts = 0
    202         AttValEnds = 0
    203         tag_Callouts.AttVal_ends = 0
    204 
     388        ParseError = elem_name_starts & elem_name_ends
     389       
    205390        # After the element name, there may or may not be an attlist.
    206         AfterWS = bitutil.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
    207         AttListEnd = AfterWS & AttListDelim
    208         AttNameStart = AfterWS & ~AttListDelim
    209         # At least one WS character is required between ElemNames and AttNames.
    210         ParseError |= tag_Callouts.ElemName_ends & AttNameStart
    211 
    212         #
    213         # The following loop iterates through attributes within a start tag.
    214         # Because all start tags are processed in parallel, the number of
    215         # iterations is the maximum number of attributes found in any one
    216         # start tag, plus one.
    217         while AttNameStart:
    218                 tag_Callouts.AttName_starts |= AttNameStart
    219                 AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
    220                 tag_Callouts.AttName_ends |= AttNameFollow
    221                 # Scan through WS to the expected '=' delimiter.
    222                 # EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
    223                 # But use if test to optimize.
    224                 if AttNameFollow & lex.WS:
    225                         EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
    226                 else: EqExpected = AttNameFollow
    227                 EqToCheck |= EqExpected
    228                 AttValPos = bitutil.ScanThru(EqExpected, EqExpected | lex.WS)
    229                 tag_Callouts.AttVal_starts |= AttValPos
    230                 DQuoteAttVal = AttValPos & lex.DQuote
    231                 SQuoteAttVal = AttValPos & lex.SQuote
    232                 DQuoteAttEnd = bitutil.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
    233                 SQuoteAttEnd = bitutil.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
    234                 AttValEnd = DQuoteAttEnd | SQuoteAttEnd
    235                 AttValEnds |= AttValEnd
    236                 AttValFollow = bitutil.Advance(AttValEnd)
    237                 tag_Callouts.AttVal_ends |= AttValFollow
    238                 #  AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
    239                 if AttValFollow & lex.WS:
    240                         AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
    241                 else: AfterWS = AttValFollow
    242                 AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
    243                 AttListEnd |= AfterWS & AttListDelim
     391        if elem_name_ends & lex.WS:
     392                AfterWS = bitutil.ScanThru(elem_name_ends, lex.WS)
     393                AttListEnd = AfterWS & AttListDelim
    244394                AttNameStart = AfterWS & ~AttListDelim
    245 
    246         # No more attribute values to process when AttNameStart == 0.
     395                #
     396                # The following loop iterates through attributes within a start tag.
     397                # Because all start tags are processed in parallel, the number of
     398                # iterations is the maximum number of attributes found in any one
     399                # start tag, plus one.
     400                while AttNameStart:
     401                        ParseError |= AttNameStart &~ lex.NameScan
     402                        callouts.symbol_starts |= AttNameStart
     403                        AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
     404                        callouts.symbol_ends |= AttNameFollow
     405                        # Scan through WS to the expected '=' delimiter.
     406                        # EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     407                        # But use if test to optimize.
     408                        if AttNameFollow & lex.WS:
     409                                EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
     410                        else: EqExpected = AttNameFollow
     411                        ParseError |= EqExpected &~ lex.Equals
     412                        AttValPos = bitutil.ScanThru(EqExpected, EqExpected | lex.WS)
     413                        callouts.Transition_marks |= AttValPos
     414                        DQuoteAttVal = AttValPos & lex.DQuote
     415                        SQuoteAttVal = AttValPos & lex.SQuote
     416                        DQuoteAttEnd = bitutil.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
     417                        SQuoteAttEnd = bitutil.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
     418                        AttValEnd = DQuoteAttEnd | SQuoteAttEnd
     419                        ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote)
     420                        AttValFollow = bitutil.Advance(AttValEnd)
     421                        callouts.Transition_marks |= AttValEnd
     422                        #  AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
     423                        if AttValFollow & lex.WS:
     424                                AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
     425                                AttListEnd |= AfterWS & AttListDelim
     426                                AttNameStart = AfterWS & ~AttListDelim
     427                        else:
     428                                AttListEnd |= AttValFollow & AttListDelim       
     429                                AttNameStart = 0
     430                                ParseError |= AttValFollow & ~AttListDelim
     431        else:
     432                # No WS character after ElemName; must be at the end
     433                AttListEnd = elem_name_ends & AttListDelim
     434                ParseError |= elem_name_ends & ~AttListDelim
     435
    247436        STagEnds = AttListEnd & lex.RAngle
    248437        # Mark any "/" characters found as the ends of empty element tags.
    249         tag_Callouts.EmptyTag_marks = bitutil.Advance(AttListEnd & lex.Slash)
    250        
    251         # Check for errors.
    252         ParseError |= tag_Callouts.AttVal_ends & tag_Callouts.AttName_starts # No intervening WS.
    253         ParseError |= tag_Callouts.AttName_starts & tag_Callouts.AttName_ends # Null AttName
    254         ParseError |= EqToCheck & ~lex.Equals # = not found where expected.
    255         ParseError |= tag_Callouts.AttVal_starts & ~ (lex.DQuote | lex.SQuote)
    256         ParseError |= AttValEnds & ~ (lex.DQuote | lex.SQuote)
     438        EmptyTag_marks = bitutil.Advance(AttListEnd & lex.Slash)
     439       
    257440        ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle
    258441
     
    263446                EndTagEnds = bitutil.ScanThru(EndTagEnds, lex.WS)
    264447        ParseError |= EndTagEnds & ~lex.RAngle
    265         tag_Callouts.error = ParseError
     448        if ParseError:
     449                error_tracker.NoteError("Tag parsing error found", (ParseError))
     450
     451        callouts.Transition_marks |= STagEnds | EmptyTag_marks | EndTagEnds
    266452               
    267         # Attribute value spans
    268         tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
    269                        
    270 def Parse_refs(lex, scope1, ctCDPI_Callouts, ref_Callouts):
    271         ref_Callouts.GenRef_starts = 0
    272         ref_Callouts.GenRef_ends = 0
    273         ref_Callouts.DecRef_starts = 0
    274         ref_Callouts.DecRef_ends = 0
    275         ref_Callouts.HexRef_starts = 0
    276         ref_Callouts.HexRef_ends = 0
    277         ref_Callouts.error = 0
    278 
    279         Ref1 = lex.RefStart &~ ctCDPI_Callouts.CtCDPI_mask
     453               
     454        # "]]>" within tags (in attribute values) is legal
     455        marker.CD_closer = marker.CD_closer &~ ((STagEnds | EmptyTag_marks) - elem_name_starts)
     456
     457def Parse_refs(lex, marker, callouts):
    280458        # All remaining "&" must be reference start characters; parse them.
    281         if Ref1:
    282                 scope1.RefStart = bitutil.Advance(Ref1)
    283                 NumRef2 = scope1.RefStart & lex.Hash
    284                 ref_Callouts.GenRef_starts = scope1.RefStart &~ lex.Hash
    285                 NumRef3 = bitutil.Advance(NumRef2)
    286                 HexRef3 = NumRef3 & lex.x
    287                 ref_Callouts.DecRef_starts = NumRef3 &~ lex.x
    288                 ref_Callouts.HexRef_starts = bitutil.Advance(HexRef3)
    289                 ref_Callouts.GenRef_ends = bitutil.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan)
    290                 ref_Callouts.DecRef_ends = bitutil.ScanThru(ref_Callouts.DecRef_starts, lex.Digit)
    291                 ref_Callouts.HexRef_ends = bitutil.ScanThru(ref_Callouts.HexRef_starts, lex.Hex)
    292                 # Error checks
    293                 # At least one digit required for DecRef, one hex digit for HexRef.
    294                 ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit
    295                 ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex
    296                 # Semicolon terminator required (also covers unterminated at EOF).
    297                 ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends
    298                 ref_error3 = ref_ends &~ lex.Semicolon
    299                 ref_Callouts.error = ref_error1 | ref_error2 | ref_error3
     459        if marker.Ref_opener:
     460                callouts.Symbol_starts |= marker.Ref_opener
     461                # ScanThru from next including all Name characters as well as # for
     462                # either general or numeric references.   Symbol table will validate.
     463                ref_ends = bitutil.ScanThru(marker.Ref_opener, lex.NameScan | marker.Ref_opener | lex.Hash)
     464                ref_error = ref_ends &~ lex.Semicolon
     465                if ref_error:
     466                        error_tracker.NoteError("Reference error found", ref_error)
     467                callouts.Symbol_ends |= ref_ends
     468
    300469   
    301 def Do_check_streams(ctCDPI_Callouts, tag_Callouts, lex, u8, scope1, ref_Callouts, xml_names, check_streams):
    302     # Ensure that no occurrence of ]]> occurs outside of markup.
    303     CD_end_error = ctCDPI_Callouts.CD_end & ~(ctCDPI_Callouts.CtCDPI_mask | tag_Callouts.AttVal_spans)
    304            
    305     # Consolidate and check for errors
    306     check_streams.error_mask = lex.error & EOF_mask | ctCDPI_Callouts.error | tag_Callouts.error | CD_end_error | ref_Callouts.error
    307 
    308     check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts
    309     check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends
    310     check_streams.att_refs = tag_Callouts.AttVal_spans & scope1.RefStart
     470def Prepare_text(lex, u8, marker, callouts):
     471        CD_end_error = marker.CD_closer
     472        if CD_end_error:
     473                error_tracker.NoteError("Error: ]]> in text", CD_end_error)
     474        callouts.Nonplain = u8.prefix | u8.suffix | lex.CR | marker.Ref_opener | marker.LAngle
     475     
    311476   
    312    
    313 def Main(lex, scope1, ctCDPI_Callouts, ref_Callouts, tag_Callouts, masks, xml_names, check_streams):   
    314        
    315         Add_scope_streams(lex, scope1)
    316    
     477def Main(basis_bits, lex, u8, marker, callouts):       
     478       
     479        # Classify bytes for UTF-8 processing, whitespace and control
     480        # processing and XML lexical analysis.
     481        # Classify_bytes(basis_bits, lex)
     482
     483        # Validate UTF-8 multibyte sequences and determine the UTF-8 scope streams
     484        # Validate_utf8(basis_bits, u8)
     485                               
     486        Classify_bytes_Validate_utf8(basis_bits, lex, u8)
     487
    317488        # Parse all comments, CDATA sections and processing instructions.
    318         Parse_CtCDPI(ctCDPI_Callouts, lex, scope1, check_streams)
     489        Parse_CtCDPI(lex, marker, callouts)
    319490               
    320491        # All remaining '<' must be tag start characters; parse tags.
    321         Parse_tags(lex, scope1, ctCDPI_Callouts, tag_Callouts)
     492        Parse_tags(lex, marker, callouts)
    322493
    323494        # All remaining '&' must be reference start characters; parse them.
    324         Parse_refs(lex, scope1, ctCDPI_Callouts, ref_Callouts)   
    325    
    326         Do_check_streams(ctCDPI_Callouts, tag_Callouts, lex, scope1, ref_Callouts, check_streams)
    327 
    328 
     495        Parse_refs(lex, marker, callouts)
     496       
     497        #
     498        Prepare_text(lex, u8, marker, callouts)
     499
     500
Note: See TracChangeset for help on using the changeset viewer.