Ignore:
Timestamp:
Jul 31, 2010, 12:02:39 PM (9 years ago)
Author:
cameron
Message:

Clean up.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/parabix2/parabix2_compilable.py

    r558 r559  
    1313#import bitutil
    1414
    15 #import sys
    16 
    17 class u8_streams ():
    18         unibyte = 0
    19         prefix = 0
    20         prefix2 = 0
    21         prefix3 = 0
    22         prefix4 = 0
    23         suffix = 0
    24         badprefix = 0
    25         xE0_scope = 0
    26         xED_scope = 0
    27         xF0_scope = 0
    28         xF4_scope = 0
    29         xA0_xBF = 0
    30         x80_x9F = 0
    31         x90_xBF = 0
    32         x80_x8F = 0
    33         xEF_scope = 0
    34         xBF = 0
    35         xBE = 0
    36         scope22 = 0
    37         scope32 = 0
    38         scope33 = 0
    39         scope42 = 0
    40         scope43 = 0
    41         scope44 = 0
    42 
    43 class control_streams ():
    44         x00_x1F = 0
    45         CR = 0
    46         LF = 0
    47         HT = 0
    48         SP = 0
    49         CR_scope = 0
    50         CRLF = 0
    51  
    52 class lexical_streams ():
    53         RefStart = 0
    54         Semicolon = 0 
    55         Colon = 0
    56         LAngle = 0
    57         RAngle = 0
    58         LBracket = 0
    59         RBracket = 0
    60         Exclam = 0
    61         QMark = 0
    62         Hyphen = 0
    63         Equals = 0
    64         SQuote = 0
    65         DQuote = 0
    66         Slash = 0
    67         Hash = 0
    68         x = 0
    69         ASCII_name_start = 0
    70         ASCII_name_char = 0
    71         NameScan = 0
    72         Digit = 0
    73         Hex = 0
    74         WS = 0
    75         PI_start = 0
    76         CtCD_start = 0
    77         EndTag_start = 0
    78         CD_end = 0
    79         DoubleHyphen = 0
    80         PI_end = 0
    81         CtCDPI_start = 0
    82         LAngle_scope = 0
    83         Hyphen_scope = 0
    84         QMark_scope = 0
    85         RBracket_scope = 0
    86 
    87 def classify_bytes(bit) :
    88         lex = lexical_streams()
    89         control = control_streams()
     15def main(u8data):
     16        # Transpose to parallel bit streams and prepare an EOF mask.
     17        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
     18
     19        # Classify bytes for UTF-8 processing, whitespace and control
     20        # processing and XML lexical analysis.
     21
    9022        temp1 = (bit[0] | bit[1]);
    9123        temp2 = (bit[2] &~ bit[3]);
     
    181113        lex.Hex = (temp62 | temp65);
    182114
    183         return (control, lex)
    184 
    185 
    186 class CtCDPI_callouts:
    187         CD_span = 0
    188         Ct_span = 0
    189         PI_mask = 0
    190         CtCDPI_mask = 0
    191         error = 0
    192        
    193 
    194 
    195 class ref_callouts:
    196         GenRefs = 0
    197         DecRefs = 0
    198         HexRefs = 0
    199         delmask = 0
    200         error = 0
    201 
    202 
    203 class tag_callouts:
    204         ElemNames = 0
    205         AttNames = 0
    206         AttVals = 0
    207         Tags = 0
    208         EmptyTagEnds = 0
    209         EndTags = 0
    210         error = 0
    211 
    212 
    213 def main(u8data):
    214         # Transpose to parallel bit streams and prepare an EOF mask.
    215         (bit, EOF_mask) = bitutil.transpose_streams(u8data)
    216 
    217         # Classify bytes for UTF-8 processing, whitespace and control
    218         # processing and XML lexical analysis.
    219         #(u8, control, lex) = byteclass.classify_bytes(bit)
    220         #(u8, control, lex) = byteclass.classify_bytes_with_shift1opt(bit)
    221         #(control, lex) = classify_bytes(bit)
    222 
    223         control = control_streams()
    224         temp1 = (bit[0] | bit[1]);
    225         temp2 = (bit[2] &~ bit[3]);
    226         temp3 = (temp2 &~ temp1);
    227         temp4 = (bit[5] &~ bit[4]);
    228         temp5 = (bit[6] &~ bit[7]);
    229         temp6 = (temp4 & temp5);
    230         lex.RefStart = (temp3 & temp6);
    231         temp7 = (bit[2] & bit[3]);
    232         temp8 = (temp7 &~ temp1);
    233         temp9 = (bit[4] &~ bit[5]);
    234         temp10 = (bit[6] & bit[7]);
    235         temp11 = (temp9 & temp10);
    236         lex.Semicolon = (temp8 & temp11);
    237         temp12 = (bit[4] & bit[5]);
    238         temp13 = (bit[6] | bit[7]);
    239         temp14 = (temp12 &~ temp13);
    240         lex.LAngle = (temp8 & temp14);
    241         temp15 = (temp12 & temp5);
    242         lex.RAngle = (temp8 & temp15);
    243         temp16 = (bit[1] &~ bit[0]);
    244         temp17 = (bit[3] &~ bit[2]);
    245         temp18 = (temp16 & temp17);
    246         lex.LBracket = (temp18 & temp11);
    247         temp19 = (bit[7] &~ bit[6]);
    248         temp20 = (temp12 & temp19);
    249         lex.RBracket = (temp18 & temp20);
    250         temp21 = (bit[4] | bit[5]);
    251         temp22 = (temp19 &~ temp21);
    252         lex.Exclam = (temp3 & temp22);
    253         temp23 = (temp12 & temp10);
    254         lex.QMark = (temp8 & temp23);
    255         lex.Hyphen = (temp3 & temp20);
    256         lex.Equals = (temp8 & temp20);
    257         temp24 = (temp4 & temp10);
    258         lex.SQuote = (temp3 & temp24);
    259         temp25 = (temp5 &~ temp21);
    260         lex.DQuote = (temp3 & temp25);
    261         lex.Slash = (temp3 & temp23);
    262         temp26 = (temp10 &~ temp21);
    263         lex.Hash = (temp3 & temp26);
    264         temp27 = (temp16 & temp7);
    265         temp28 = (temp9 &~ temp13);
    266         lex.x = (temp27 & temp28);
    267         temp29 = (temp9 & temp5);
    268         lex.Colon = (temp8 & temp29);
    269         temp30 = (temp18 & temp23);
    270         temp31 = (temp30 | lex.Colon);
    271         temp32 = (temp16 &~ bit[2]);
    272         temp33 = (bit[5] | temp10);
    273         temp34 = (bit[4] & temp33);
    274         temp35 = (~temp34);
    275         temp36 = (temp21 | temp13);
    276         temp37 = ((bit[3] & temp35)|(~(bit[3]) & temp36));
    277         temp38 = (temp32 & temp37);
    278         temp39 = (temp31 | temp38);
    279         temp40 = (temp16 & bit[2]);
    280         temp41 = (temp40 & temp37);
    281         lex.ASCII_name_start = (temp39 | temp41);
    282         temp42 = (temp30 | lex.Hyphen);
    283         temp43 = (temp3 & temp15);
    284         temp44 = (temp42 | temp43);
    285         temp45 = (temp8 &~ temp34);
    286         temp46 = (temp44 | temp45);
    287         temp47 = (temp46 | temp38);
    288         lex.ASCII_name_char = (temp47 | temp41);
    289         lex.NameScan = (lex.ASCII_name_char | bit[0]);
    290         temp48 = (temp1 | bit[2]);
    291         control.x00_x1F = (~temp48);
    292         temp49 = (bit[2] | bit[3]);
    293         temp50 = (temp1 | temp49);
    294         control.CR = (temp20 &~ temp50);
    295         control.LF = (temp29 &~ temp50);
    296         temp51 = (temp9 & temp19);
    297         control.HT = (temp51 &~ temp50);
    298         control.SP = (temp3 &~ temp36);
    299         temp52 = (temp20 | temp29);
    300         temp53 = (temp52 | temp51);
    301         temp54 = (temp53 &~ temp50);
    302         lex.WS = (temp54 | control.SP);
    303         temp55 = (bit[5] | bit[6]);
    304         temp56 = (bit[4] & temp55);
    305         lex.Digit = (temp8 &~ temp56);
    306         temp57 = (temp16 &~ temp49);
    307         temp58 = (temp57 &~ bit[4]);
    308         temp59 = (~temp10);
    309         temp60 = ((bit[5] & temp59)|(~(bit[5]) & temp13));
    310         temp61 = (temp58 & temp60);
    311         temp62 = (lex.Digit | temp61);
    312         temp63 = (temp16 & temp2);
    313         temp64 = (temp63 &~ bit[4]);
    314         temp65 = (temp64 & temp60);
    315         lex.Hex = (temp62 | temp65);
    316 
    317 
    318 
     115
     116        # Check for illegal control characters
    319117        xmlchar_error = (control.x00_x1F &~ lex.WS & EOF_mask)
    320118
    321119
    322         u8 = u8_streams()
    323120        u8.unibyte = (~bit[0]);
    324121        u8.suffix = 0
     122        u8.error = 0
     123        FFFE_FFFF = 0
    325124
    326125        if bit[0]:
     
    384183        lex.QMark_scope = bitutil.Advance(lex.QMark)
    385184
     185        lex.CD_end = 0
    386186        if lex.RBracket:
    387187                lex.RBracket_scope = bitutil.Advance(lex.RBracket)
     
    404204        #markup1 = parse_CtCDPI(lex, EOF_mask)
    405205        #CT_callouts = CtCDPI_callouts()
     206        CT_callouts.PI_name = 0
    406207        PI_starts = 0
    407208        PI_ends = 0
     
    412213        CtCDPI_starts = 0
    413214        PI_name_ends = 0
     215
    414216        # Scanning streams
    415217        CtCDPI_scan = ~lex.CtCDPI_start & EOF_mask
     
    448250                CtCDPI_Cursor &= EOF_mask
    449251        # End of loop: no remaining CtCDPI_Cursor
    450         #Not needed for xmlwf
    451         #CT_callouts.CD_span = CD_ends - CD_starts
    452         #CT_callouts.Ct_span = Ct_ends - Ct_starts
    453         #CT_callouts.PI_span = PI_ends - PI_starts
    454252       
    455253        CT_callouts.CtCDPI_mask = bitutil.Advance(CD_ends | Ct_ends | PI_ends) - CtCDPI_starts
    456         CT_callouts.error = Ct_ends & ~lex.RAngle | Ct_starts & ~ lex.Hyphen
    457         CT_callouts.error |= bitutil.Advance(PI_name_ends & ~ lex.WS) & ~ lex.PI_end
     254        CT_callouts.error = Ct_ends & ~lex.RAngle | Ct_starts & ~ lex.Hyphen
     255        CT_callouts.error |= bitutil.Advance(PI_name_ends & ~ lex.WS) & ~ lex.PI_end
    458256        # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
    459257        CT_callouts.error |= CT_callouts.CtCDPI_mask &~ EOF_mask
     
    557355        # All remaining "&" must be reference start characters; parse them.
    558356        # INLINED: refs = parse_refs(lex, CT_callouts.CtCDPI_mask)
    559         refs = ref_callouts()
    560357        refs.GenRefs = 0
    561         Ref1 = lex.RefStart &~ CT_callouts.CtCDPI_mask
     358        refs.error = 0
     359        Ref1 = lex.RefStart &~ CT_callouts.CtCDPI_mask
    562360        if Ref1:
    563361                Ref2 = bitutil.Advance(Ref1)
     
    583381                # the point for insertion of the "expansion" text (most often a
    584382                # single character).
    585                 #refs.delmask = (GenRefEnds | DecRefEnds | HexRefEnds) - lex.RefStart
     383
    586384                refs.error = error1 | error2 | error3
    587385
     
    601399        name_start = name_stream &~ bitutil.Advance(name_stream)
    602400        name_start_check = name_start & ~lex.ASCII_name_start
    603         name_check = (name_stream &~ name_start | nmtoken_stream) & ~lex.ASCII_name_char & ~u8.suffix
     401        name_check = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix
    604402
    605403        #return (CT_callouts, callouts, refs, u16hi, u16lo, delmask, error, lex, u16delmask, EOF_mask)
Note: See TracChangeset for help on using the changeset viewer.