source: proto/parabix2/parabix2_pablo2.py @ 1054

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

Version with separate UTF8 validation

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