source: proto/parabix2/parabix2_pablo.py @ 1264

Last change on this file since 1264 was 1264, checked in by cameron, 8 years ago

Optimize Parse_CtCDPI

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