source: proto/parabix2/parabix2.py @ 1959

Last change on this file since 1959 was 1959, checked in by lindanl, 7 years ago

Add prototype that can run under python and is compilable as well

File size: 18.8 KB
Line 
1# -*- coding: utf-8 -*-
2#
3# parabix2.py
4#
5# Parallel XML Parsing with Bitstream Addition
6#
7# - Complete prototype for all bitstream computations in Parabix2
8# - Optimized for compilation
9# - Separate compilation
10
11# Robert D. Cameron, Dan Lin
12# March 24, 2012
13#
14import sys
15import pablo
16import error_tracker
17
18class Basis_bits():     
19        bit_0 = 0
20        bit_1 = 0
21        bit_2 = 0
22        bit_3 = 0
23        bit_4 = 0
24        bit_5 = 0
25        bit_6 = 0
26        bit_7 = 0
27
28
29class U8 ():
30        suffix = 0
31
32class Lex ():
33        CR = 0
34        LF = 0
35        HT = 0
36        SP = 0
37        CRLF = 0
38        RefStart = 0
39        Semicolon = 0 
40        Colon = 0
41        LAngle = 0
42        RAngle = 0
43        LBracket = 0
44        RBracket = 0
45        Exclam = 0
46        QMark = 0
47        Hyphen = 0
48        Equals = 0
49        SQuote = 0
50        DQuote = 0
51        Slash = 0
52        Hash = 0
53        x = 0
54        ASCII_name_start = 0
55        ASCII_name_char = 0
56        NameScan = 0
57        Digit = 0
58        Hex = 0
59        WS = 0
60
61class Marker ():
62        LAngle_scope = 0
63        Ref_opener = 0
64        CD_closer = 0
65
66class CtCDPI_Callouts():
67        Ct_starts = 0
68        Ct_ends = 0
69        CD_starts = 0
70        CD_ends = 0
71        PI_starts = 0
72        PI_name_starts = 0
73        PI_name_ends = 0
74        PI_ends = 0
75
76class Ref_Callouts():
77        GenRef_starts = 0
78        GenRef_ends = 0
79        DecRef_starts = 0
80        DecRef_ends = 0
81        HexRef_starts = 0
82        HexRef_ends = 0
83
84class Tag_Callouts():
85        ElemName_starts = 0
86        ElemName_ends = 0
87        AttName_starts = 0
88        AttName_ends = 0
89        AttVal_starts = 0
90        AttVal_ends = 0
91        AttVal_spans = 0
92        EmptyTag_marks = 0
93        EndTag_marks = 0
94       
95class Check_streams():
96        misc_mask = 0
97        non_ascii_name_starts = 0
98        non_ascii_names = 0
99        tag_marks = 0 
100        name_follows = 0 
101        att_refs = 0 
102
103def Classify_bytes_Validate_utf8(basis_bits, lex, u8): 
104        temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
105        temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
106        temp3 = (temp2 &~ temp1);
107        temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
108        temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
109        temp6 = (temp4 & temp5);
110        lex.RefStart = (temp3 & temp6);
111        temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
112        temp8 = (temp7 &~ temp1);
113        temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
114        temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
115        temp11 = (temp9 & temp10);
116        lex.Semicolon = (temp8 & temp11);
117        temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
118        temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
119        temp14 = (temp12 &~ temp13);
120        lex.LAngle = (temp8 & temp14);
121        temp15 = (temp12 & temp5);
122        lex.RAngle = (temp8 & temp15);
123        temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
124        temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
125        temp18 = (temp16 & temp17);
126        lex.LBracket = (temp18 & temp11);
127        temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
128        temp20 = (temp12 & temp19);
129        lex.RBracket = (temp18 & temp20);
130        temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
131        temp22 = (temp19 &~ temp21);
132        lex.Exclam = (temp3 & temp22);
133        temp23 = (temp12 & temp10);
134        lex.QMark = (temp8 & temp23);
135        lex.Hyphen = (temp3 & temp20);
136        lex.Equals = (temp8 & temp20);
137        temp24 = (temp4 & temp10);
138        lex.SQuote = (temp3 & temp24);
139        temp25 = (temp5 &~ temp21);
140        lex.DQuote = (temp3 & temp25);
141        lex.Slash = (temp3 & temp23);
142        temp26 = (temp10 &~ temp21);
143        lex.Hash = (temp3 & temp26);
144        temp27 = (temp16 & temp7);
145        temp28 = (temp9 &~ temp13);
146        lex.x = (temp27 & temp28);
147        temp29 = (temp9 & temp5);
148        lex.Colon = (temp8 & temp29);
149        temp30 = (temp18 & temp23);
150        temp31 = (temp30 | lex.Colon);
151        temp32 = (temp16 &~ basis_bits.bit_2);
152        temp33 = (basis_bits.bit_5 | temp10);
153        temp34 = (basis_bits.bit_4 & temp33);
154        temp35 = (~temp34);
155        temp36 = (temp21 | temp13);
156        temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
157        temp38 = (temp32 & temp37);
158        temp39 = (temp31 | temp38);
159        temp40 = (temp16 & basis_bits.bit_2);
160        temp41 = (temp40 & temp37);
161        lex.ASCII_name_start = (temp39 | temp41);
162        temp42 = (temp30 | lex.Hyphen);
163        temp43 = (temp3 & temp15);
164        temp44 = (temp42 | temp43);
165        temp45 = (temp8 &~ temp34);
166        temp46 = (temp44 | temp45);
167        temp47 = (temp46 | temp38);
168        lex.ASCII_name_char = (temp47 | temp41);
169        lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
170        temp48 = (temp1 | basis_bits.bit_2);
171        x00_x1F = (~temp48);
172        temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
173        temp50 = (temp1 | temp49);
174        lex.CR = (temp20 &~ temp50);
175        lex.LF = (temp29 &~ temp50);
176        temp51 = (temp9 & temp19);
177        lex.HT = (temp51 &~ temp50);
178        lex.SP = (temp3 &~ temp36);
179        temp52 = (temp20 | temp29);
180        temp53 = (temp52 | temp51);
181        temp54 = (temp53 &~ temp50);
182        lex.WS = (temp54 | lex.SP);
183        temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
184        temp56 = (basis_bits.bit_4 & temp55);
185        lex.Digit = (temp8 &~ temp56);
186        temp57 = (temp16 &~ temp49);
187        temp58 = (temp57 &~ basis_bits.bit_4);
188        temp59 = (~temp10);
189        temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
190        temp61 = (temp58 & temp60);
191        temp62 = (lex.Digit | temp61);
192        temp63 = (temp16 & temp2);
193        temp64 = (temp63 &~ basis_bits.bit_4);
194        temp65 = (temp64 & temp60);
195        lex.Hex = (temp62 | temp65);
196        lex_error = x00_x1F &~ lex.WS
197        if pablo.inFile(lex_error):
198                error_tracker.NoteError("Error: illegal character", lex_error)
199               
200       
201        ### Validate_utf8(basis_bits, u8):
202        unibyte = (~basis_bits.bit_0);
203        suffix = 0
204        u8_error = 0
205        u8_FFFE_FFFF = 0
206        u8anyscope = 0 #local
207        if basis_bits.bit_0:
208                prefix = (basis_bits.bit_0 & basis_bits.bit_1);
209                prefix2 = (prefix &~ basis_bits.bit_2);
210                prefix3 = (prefix & temp2);
211                prefix4 = (prefix & temp7);
212                suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
213                temp66 = (prefix &~ temp49);
214                temp67 = (temp21 | basis_bits.bit_6);
215                temp68 = (temp66 &~ temp67);
216                temp69 = (basis_bits.bit_5 & temp13);
217                temp70 = (basis_bits.bit_4 | temp69);
218                temp71 = (prefix4 & temp70);
219                badprefix = (temp68 | temp71);
220                u8_error = badprefix
221                scope22 = pablo.Advance(prefix2)
222                u8anyscope = scope22
223                if prefix3 | prefix4:
224                        xE0 = (prefix3 &~ temp36);
225                        xED = (prefix3 & temp20);
226                        xF0 = (prefix4 &~ temp36);
227                        temp72 = (temp4 &~ temp13);
228                        xF4 = (prefix4 & temp72);
229                        xA0_xBF = (suffix & basis_bits.bit_2);
230                        x80_x9F = (suffix &~ basis_bits.bit_2);
231                        x90_xBF = (suffix & temp49);
232                        x80_x8F = (suffix &~ temp49);
233                        xEF = (prefix3 & temp23);
234                        temp73 = (suffix & temp7);
235                        xBF = (temp73 & temp23);
236                        xBE = (temp73 & temp15);
237
238                        scope32 = pablo.Advance(prefix3)
239                        scope33 = pablo.Advance(scope32)
240                        scope42 = pablo.Advance(prefix4)
241                        scope43 = pablo.Advance(scope42)
242                        scope44 = pablo.Advance(scope43)
243
244                        E0_F0_scope = pablo.Advance(xE0 | xF0)
245                        ED_F4_scope = pablo.Advance(xED | xF4)
246                        xE0_scope = scope32 & E0_F0_scope
247                        xED_scope = scope32 & ED_F4_scope
248                        xF0_scope = scope42 & E0_F0_scope
249                        xF4_scope = scope42 & ED_F4_scope
250                        xEF_scope = pablo.Advance(xEF);
251
252                        u8lastscope = scope22 | scope33 | scope44
253                        u8anyscope = u8lastscope | scope32 | scope42 | scope43
254               
255                        u8error1 = xE0_scope & x80_x9F
256                        u8error2 = xED_scope & xA0_xBF
257                        u8error3 = xF0_scope & x80_x8F
258                        u8error4 = xF4_scope & x90_xBF
259       
260                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4
261
262                        EF_BF_pending = pablo.Advance(xEF_scope & xBF)
263
264                        u8_FFFE_FFFF = (EF_BF_pending & (xBE | xBF))
265                u8mismatch = u8anyscope ^ suffix
266                u8_error |= u8mismatch | u8_FFFE_FFFF
267                if u8_error:
268                        error_tracker.NoteError("UTF-8 error found", (u8_error))
269                       
270       
271def Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams):
272        ctCDPI_Callouts.Ct_starts = 0
273        ctCDPI_Callouts.Ct_ends = 0
274        ctCDPI_Callouts.CD_starts = 0
275        ctCDPI_Callouts.CD_ends = 0
276        ctCDPI_Callouts.PI_starts = 0
277        ctCDPI_Callouts.PI_name_starts = 0
278        ctCDPI_Callouts.PI_name_ends = 0
279        ctCDPI_Callouts.PI_ends = 0
280        CtCDPI_starts = 0
281        CtCDPI_ends = 0
282        ctCDPI_mask = 0
283
284        v = lex.LAngle | lex.Hyphen
285        w = lex.Hyphen | lex.QMark
286        v1 = pablo.Advance(v)
287        w1 = pablo.Advance(w)
288       
289        LAngle_scope = v1 &~ w1  #pablo.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 = pablo.Advance(lex.Hyphen) & lex.Hyphen
299        DoubleHyphen = v1 & w1 & lex.Hyphen
300        if lex.RBracket:
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
304        PI_closer = w1 & ~v1 & lex.RAngle
305
306        #
307        # Initiate the scan
308        CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener)
309        while CtCDPI_Cursor:
310                CtCDPI_starts |= CtCDPI_Cursor
311                PI_Cursor = CtCDPI_Cursor & PI_opener
312                CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor)
313                CD_Cursor = CD_Ct_Cursor & lex.LBracket
314                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
315                # PI processing
316                if PI_Cursor:
317                        ctCDPI_Callouts.PI_starts |= PI_Cursor
318                        PI_Cursor = pablo.Advance(PI_Cursor)
319                        ctCDPI_Callouts.PI_name_starts |= PI_Cursor
320                        PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan)
321                        PI_error = PI_Cursor & PI_name_end
322                        PI_error |= pablo.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
323                        if PI_error:
324                                error_tracker.NoteError("Error in PI syntax", PI_name_end)
325                        ctCDPI_Callouts.PI_name_ends |= PI_name_end
326                        PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer)
327                        ctCDPI_Callouts.PI_ends |= PI_Cursor
328                        CtCDPI_ends |= PI_Cursor
329
330                # CDATA section processing
331                if CD_Cursor:
332                        ctCDPI_Callouts.CD_starts |= CD_Cursor
333                        CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer)
334                        ctCDPI_Callouts.CD_ends |= CD_Cursor
335                        CtCDPI_ends |= CD_Cursor
336
337                # Comment processing
338                if Ct_Cursor:
339                        ctCDPI_Callouts.Ct_starts |= Ct_Cursor
340                        Ct_Cursor = pablo.Advance(Ct_Cursor) 
341                        Ct_error = Ct_Cursor & ~ lex.Hyphen
342                        # Advance twice past <!--, so that we don't treat <!---
343                        # as being a terminated comment.
344                        Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor))
345                        Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen))
346                        Ct_error |= Ct_Cursor & ~ lex.RAngle   
347                        ctCDPI_Callouts.Ct_ends |= Ct_Cursor
348                        CtCDPI_ends |= Ct_Cursor
349                        if Ct_error:
350                                error_tracker.NoteError("Error in comment syntax", Ct_error)
351
352                # Common processing
353                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
354                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)
355                ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends             
356                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
357                ctCDPI_error = pablo.atEOF(ctCDPI_mask)
358               
359                if ctCDPI_error:
360                        error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
361               
362        check_streams.misc_mask = pablo.inFile((lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) - (ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts))
363
364        # Identify the remaining significant markers for XML processing.
365        marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask
366        marker.Ref_opener = lex.RefStart &~ ctCDPI_mask
367        marker.CD_closer = CD_closer &~ ctCDPI_mask
368
369def Parse_tags(lex, marker, tag_Callouts):
370       
371        # Delimiters for scans.
372        DQuoteDelim = lex.DQuote | lex.LAngle
373        SQuoteDelim = lex.SQuote | lex.LAngle
374        AttListDelim = lex.Slash | lex.RAngle
375       
376        # Start the parallel parsing by inspecting the character
377        # after the opening "<" of a tag.
378        tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash
379        tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash
380       
381        # Start Tag/Empty Element Tag Parsing
382
383        # Advance all cursors by scanning through the tag name.
384        tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
385        # Must have at least one name character for a legal start tag.
386        # Mark any occurrences of null names as errors.
387        ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends
388       
389        # Initialize the accumulators for attribute name and value positions.
390        tag_Callouts.AttName_starts = 0 
391        tag_Callouts.AttName_ends = 0
392        tag_Callouts.AttVal_starts = 0
393        tag_Callouts.AttVal_ends = 0
394
395        # After the element name, there may or may not be an attlist.
396        if tag_Callouts.ElemName_ends & lex.WS:
397                AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
398                AttListEnd = AfterWS & AttListDelim
399                AttNameStart = AfterWS & ~AttListDelim
400                #
401                # The following loop iterates through attributes within a start tag.
402                # Because all start tags are processed in parallel, the number of
403                # iterations is the maximum number of attributes found in any one
404                # start tag, plus one.
405                while AttNameStart:
406                        ParseError |= AttNameStart &~ lex.NameScan
407                        tag_Callouts.AttName_starts |= AttNameStart
408                        AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan)
409                        tag_Callouts.AttName_ends |= AttNameFollow
410                        # Scan through WS to the expected '=' delimiter.
411                        # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
412                        # But use if test to optimize.
413                        if AttNameFollow & lex.WS: 
414                                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
415                        else: EqExpected = AttNameFollow
416                        ParseError |= EqExpected &~ lex.Equals
417                        AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
418                        tag_Callouts.AttVal_starts |= AttValPos
419                        DQuoteAttVal = AttValPos & lex.DQuote
420                        SQuoteAttVal = AttValPos & lex.SQuote
421                        DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
422                        SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
423                        AttValEnd = DQuoteAttEnd | SQuoteAttEnd
424                        ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote)
425                        AttValFollow = pablo.Advance(AttValEnd)
426                        tag_Callouts.AttVal_ends |= AttValFollow
427                        #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
428                        if AttValFollow & lex.WS: 
429                                AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
430                                AttListEnd |= AfterWS & AttListDelim
431                                AttNameStart = AfterWS & ~AttListDelim
432                        else: 
433                                AttListEnd |= AttValFollow & AttListDelim       
434                                AttNameStart = 0
435                                ParseError |= AttValFollow & ~AttListDelim
436        else:
437                # No WS character after ElemName; must be at the end
438                AttListEnd = tag_Callouts.ElemName_ends & AttListDelim
439                ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim
440
441        STagEnds = AttListEnd & lex.RAngle
442        # Mark any "/" characters found as the ends of empty element tags.
443        tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash)
444       
445        ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle
446
447        # End Tag Parsing
448
449        EndTagEnds = pablo.ScanThru(tag_Callouts.EndTag_marks, tag_Callouts.EndTag_marks | lex.NameScan)
450        if EndTagEnds & lex.WS:
451                EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS)
452        ParseError |= EndTagEnds & ~lex.RAngle
453        if ParseError:
454                error_tracker.NoteError("Tag parsing error found", (ParseError))
455               
456               
457        # Attribute value spans
458        tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
459
460def Parse_refs(lex, marker, ref_Callouts):
461        ref_Callouts.GenRef_starts = 0
462        ref_Callouts.GenRef_ends = 0
463        ref_Callouts.DecRef_starts = 0
464        ref_Callouts.DecRef_ends = 0
465        ref_Callouts.HexRef_starts = 0
466        ref_Callouts.HexRef_ends = 0
467        ref_error = 0
468
469        # All remaining "&" must be reference start characters; parse them.
470        if marker.Ref_opener:
471                Ref_scope = pablo.Advance(marker.Ref_opener)
472                NumRef2 = Ref_scope & lex.Hash
473                ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash
474                NumRef3 = pablo.Advance(NumRef2)
475                HexRef3 = NumRef3 & lex.x
476                ref_Callouts.DecRef_starts = NumRef3 &~ lex.x
477                ref_Callouts.HexRef_starts = pablo.Advance(HexRef3) 
478                ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan)
479                ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit)
480                ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex)
481                # Error checks
482                # At least one digit required for DecRef, one hex digit for HexRef.
483                ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit
484                ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex
485                # Semicolon terminator required (also covers unterminated at EOF).
486                ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends
487                ref_error3 = ref_ends &~ lex.Semicolon
488                ref_error = ref_error1 | ref_error2 | ref_error3
489                if ref_error:
490                        error_tracker.NoteError("Reference error found", (ref_error))
491                       
492
493
494def Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams):
495        PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
496        GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
497        ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
498        AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
499        qname_stream =  ElemNames | AttNames
500        ncname_stream = PI_names | GenRefs
501        name_stream = qname_stream | ncname_stream
502        name_start = name_stream &~ pablo.Advance(name_stream)
503        name_cursor = name_stream & ~pablo.Advance(name_stream)
504        void_prefix_err = name_cursor & lex.Colon
505        namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon
506        local_part_start = pablo.Advance(namespace_sep)
507        local_part_err = local_part_start &~ lex.NameScan
508        colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
509        ncname_err = ncname_stream & lex.Colon
510        namespace_error = void_prefix_err | local_part_err | colon2_err | ncname_err
511        if namespace_error:
512                error_tracker.NoteError("error found", namespace_error)
513               
514                       
515        check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start
516        check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix
517   
518def Do_check_streams(marker, tag_Callouts, check_streams):
519        CD_end_error = marker.CD_closer & ~tag_Callouts.AttVal_spans
520        if CD_end_error: 
521                error_tracker.NoteError("Error: ]]> in text", CD_end_error)
522        check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts
523        check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends
524        check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener
525
526
527def Main(basis_bits, lex, u8, xml_char, scope1, ctCDPI_Callouts, ref_Callouts, tag_Callouts, masks, xml_names, check_streams): 
528       
529        # Classify bytes for UTF-8 processing, whitespace and control
530        # processing and XML lexical analysis.
531        # Classify_bytes(basis_bits, lex)
532
533        # Validate UTF-8 multibyte sequences and determine the UTF-8 scope streams
534        # Validate_utf8(basis_bits, u8)
535                               
536        Classify_bytes_Validate_utf8(basis_bits, lex, u8)
537
538        # Parse all comments, CDATA sections and processing instructions.
539        Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams)
540               
541        # All remaining '<' must be tag start characters; parse tags.
542        Parse_tags(lex, marker, tag_Callouts) 
543
544        # All remaining '&' must be reference start characters; parse them.
545        Parse_refs(lex, marker, ref_Callouts)
546       
547        # Validate XML namespaces and generate bit streams to post validate non-ascii range XML names
548        Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams)
549   
550        Do_check_streams(marker, tag_Callouts, check_streams)
551
552
553
554basis_bits = Basis_bits()
555lex = Lex()
556u8 = U8()
557marker = Marker()
558ctCDPI_Callouts = CtCDPI_Callouts()
559tag_Callouts = Tag_Callouts()
560ref_Callouts = Ref_Callouts()
561check_streams = Check_streams()
562
563if __name__ == "__main__":
564       
565        if len(sys.argv) > 1:
566                u8data = pablo.readfile(sys.argv[1]) 
567                pablo.EOF_mask = pablo.transpose_streams(u8data, basis_bits)
568                Classify_bytes_Validate_utf8(basis_bits, lex, u8)
569                Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams)
570                Parse_tags(lex, marker, tag_Callouts)
571                Parse_refs(lex, marker, ref_Callouts)
572                Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams)
573                Do_check_streams(marker, tag_Callouts, check_streams)
574        else:
575                print("Usage: python parabix2.py <file>")
576       
577
578
Note: See TracBrowser for help on using the repository browser.