source: proto/parabix2/parabix2_compilable_noopt.py @ 955

Last change on this file since 955 was 558, checked in by cameron, 9 years ago

Exclude ? from PI target.

File size: 18.0 KB
Line 
1# -*- coding: utf-8 -*-
2#
3# parabix2_compilable.py
4#
5# Parallel XML Parsing with Bitstream Addition
6# - Complete prototype for all bitstream computations in Parabix2
7# - optimized for compilation
8#
9# Robert D. Cameron
10# July 29, 2010
11#
12
13#import bitutil
14
15#import sys
16
17class 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
43class 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 
52class 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
87def classify_bytes(bit) :
88        lex = lexical_streams()
89        control = control_streams()
90        temp1 = (bit[0] | bit[1]);
91        temp2 = (bit[2] &~ bit[3]);
92        temp3 = (temp2 &~ temp1);
93        temp4 = (bit[5] &~ bit[4]);
94        temp5 = (bit[6] &~ bit[7]);
95        temp6 = (temp4 & temp5);
96        lex.RefStart = (temp3 & temp6);
97        temp7 = (bit[2] & bit[3]);
98        temp8 = (temp7 &~ temp1);
99        temp9 = (bit[4] &~ bit[5]);
100        temp10 = (bit[6] & bit[7]);
101        temp11 = (temp9 & temp10);
102        lex.Semicolon = (temp8 & temp11);
103        temp12 = (bit[4] & bit[5]);
104        temp13 = (bit[6] | bit[7]);
105        temp14 = (temp12 &~ temp13);
106        lex.LAngle = (temp8 & temp14);
107        temp15 = (temp12 & temp5);
108        lex.RAngle = (temp8 & temp15);
109        temp16 = (bit[1] &~ bit[0]);
110        temp17 = (bit[3] &~ bit[2]);
111        temp18 = (temp16 & temp17);
112        lex.LBracket = (temp18 & temp11);
113        temp19 = (bit[7] &~ bit[6]);
114        temp20 = (temp12 & temp19);
115        lex.RBracket = (temp18 & temp20);
116        temp21 = (bit[4] | bit[5]);
117        temp22 = (temp19 &~ temp21);
118        lex.Exclam = (temp3 & temp22);
119        temp23 = (temp12 & temp10);
120        lex.QMark = (temp8 & temp23);
121        lex.Hyphen = (temp3 & temp20);
122        lex.Equals = (temp8 & temp20);
123        temp24 = (temp4 & temp10);
124        lex.SQuote = (temp3 & temp24);
125        temp25 = (temp5 &~ temp21);
126        lex.DQuote = (temp3 & temp25);
127        lex.Slash = (temp3 & temp23);
128        temp26 = (temp10 &~ temp21);
129        lex.Hash = (temp3 & temp26);
130        temp27 = (temp16 & temp7);
131        temp28 = (temp9 &~ temp13);
132        lex.x = (temp27 & temp28);
133        temp29 = (temp9 & temp5);
134        lex.Colon = (temp8 & temp29);
135        temp30 = (temp18 & temp23);
136        temp31 = (temp30 | lex.Colon);
137        temp32 = (temp16 &~ bit[2]);
138        temp33 = (bit[5] | temp10);
139        temp34 = (bit[4] & temp33);
140        temp35 = (~temp34);
141        temp36 = (temp21 | temp13);
142        temp37 = ((bit[3] & temp35)|(~(bit[3]) & temp36));
143        temp38 = (temp32 & temp37);
144        temp39 = (temp31 | temp38);
145        temp40 = (temp16 & bit[2]);
146        temp41 = (temp40 & temp37);
147        lex.ASCII_name_start = (temp39 | temp41);
148        temp42 = (temp30 | lex.Hyphen);
149        temp43 = (temp3 & temp15);
150        temp44 = (temp42 | temp43);
151        temp45 = (temp8 &~ temp34);
152        temp46 = (temp44 | temp45);
153        temp47 = (temp46 | temp38);
154        lex.ASCII_name_char = (temp47 | temp41);
155        lex.NameScan = (lex.ASCII_name_char | bit[0]);
156        temp48 = (temp1 | bit[2]);
157        control.x00_x1F = (~temp48);
158        temp49 = (bit[2] | bit[3]);
159        temp50 = (temp1 | temp49);
160        control.CR = (temp20 &~ temp50);
161        control.LF = (temp29 &~ temp50);
162        temp51 = (temp9 & temp19);
163        control.HT = (temp51 &~ temp50);
164        control.SP = (temp3 &~ temp36);
165        temp52 = (temp20 | temp29);
166        temp53 = (temp52 | temp51);
167        temp54 = (temp53 &~ temp50);
168        lex.WS = (temp54 | control.SP);
169        temp55 = (bit[5] | bit[6]);
170        temp56 = (bit[4] & temp55);
171        lex.Digit = (temp8 &~ temp56);
172        temp57 = (temp16 &~ temp49);
173        temp58 = (temp57 &~ bit[4]);
174        temp59 = (~temp10);
175        temp60 = ((bit[5] & temp59)|(~(bit[5]) & temp13));
176        temp61 = (temp58 & temp60);
177        temp62 = (lex.Digit | temp61);
178        temp63 = (temp16 & temp2);
179        temp64 = (temp63 &~ bit[4]);
180        temp65 = (temp64 & temp60);
181        lex.Hex = (temp62 | temp65);
182
183        return (control, lex)
184
185
186class CtCDPI_callouts:
187        CD_span = 0
188        Ct_span = 0
189        PI_mask = 0
190        CtCDPI_mask = 0
191        error = 0
192       
193
194
195class ref_callouts:
196        GenRefs = 0
197        DecRefs = 0
198        HexRefs = 0
199        delmask = 0
200        error = 0
201
202
203class 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
213def 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
319        xmlchar_error = (control.x00_x1F &~ lex.WS & EOF_mask)
320
321
322        u8 = u8_streams()
323        u8.unibyte = (~bit[0]);
324        u8.suffix = 0
325
326        #if bit[0]:
327        u8.prefix = (bit[0] & bit[1]);
328        u8.prefix2 = (u8.prefix &~ bit[2]);
329        u8.prefix3 = (u8.prefix & temp2);
330        u8.prefix4 = (u8.prefix & temp7);
331        u8.suffix = (bit[0] &~ bit[1]);
332        temp66 = (u8.prefix &~ temp49);
333        temp67 = (temp21 | bit[6]);
334        temp68 = (temp66 &~ temp67);
335        temp69 = (bit[5] & temp13);
336        temp70 = (bit[4] | temp69);
337        temp71 = (u8.prefix4 & temp70);
338        u8.badprefix = (temp68 | temp71);
339        xE0 = (u8.prefix3 &~ temp36);
340        xED = (u8.prefix3 & temp20);
341        xF0 = (u8.prefix4 &~ temp36);
342        temp72 = (temp4 &~ temp13);
343        xF4 = (u8.prefix4 & temp72);
344        u8.xA0_xBF = (u8.suffix & bit[2]);
345        u8.x80_x9F = (u8.suffix &~ bit[2]);
346        u8.x90_xBF = (u8.suffix & temp49);
347        u8.x80_x8F = (u8.suffix &~ temp49);
348        xEF = (u8.prefix3 & temp23);
349        temp73 = (u8.suffix & temp7);
350        u8.xBF = (temp73 & temp23);
351        u8.xBE = (temp73 & temp15);
352        u8.xE0_scope = bitutil.Advance(xE0);
353        u8.xED_scope = bitutil.Advance(xED);
354        u8.xF0_scope = bitutil.Advance(xF0);
355        u8.xF4_scope = bitutil.Advance(xF4);
356        u8.xEF_scope = bitutil.Advance(xEF);
357        u8.scope22 = bitutil.Advance(u8.prefix2)
358        u8.scope32 = bitutil.Advance(u8.prefix3)
359        u8.scope33 = bitutil.Advance(u8.scope32)
360        u8.scope42 = bitutil.Advance(u8.prefix4)
361        u8.scope43 = bitutil.Advance(u8.scope42)
362        u8.scope44 = bitutil.Advance(u8.scope43)
363
364        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
365        u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43
366       
367        u8error1 = u8.xE0_scope & u8.x80_x9F
368        u8error2 = u8.xED_scope & u8.xA0_xBF
369        u8error3 = u8.xF0_scope & u8.x80_x8F
370        u8error4 = u8.xF4_scope & u8.x90_xBF
371
372        u8mismatch = u8anyscope ^ u8.suffix
373
374        u8.error = u8.badprefix | u8error1 | u8error2 | u8error3 | u8error4 | u8mismatch
375
376        EF_BF_pending = bitutil.Advance(u8.xEF_scope & u8.xBF)
377
378        FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
379
380        xmlchar_error |= FFFE_FFFF
381
382        lex.LAngle_scope = bitutil.Advance(lex.LAngle)
383        lex.Hyphen_scope = bitutil.Advance(lex.Hyphen)
384        lex.QMark_scope = bitutil.Advance(lex.QMark)
385
386        #if lex.RBracket:
387        lex.RBracket_scope = bitutil.Advance(lex.RBracket)
388        lex.CD_end = bitutil.Advance(lex.RBracket_scope & lex.RBracket) & lex.RAngle
389
390        # Compute XML multilterals such as <?, </, --, ]]>.
391        #lex = add_multiliterals(lex)
392        lex.PI_start = lex.LAngle_scope & lex.QMark
393        lex.CtCD_start = lex.LAngle_scope & lex.Exclam
394        lex.CtCDPI_start = lex.PI_start | lex.CtCD_start
395        lex.EndTag_start = lex.LAngle_scope & lex.Slash
396
397        #if lex.CtCDPI_start:
398        lex.DoubleHyphen = lex.Hyphen_scope & lex.Hyphen
399        lex.PI_end = lex.QMark_scope & lex.RAngle
400
401       
402        # THE FOLLOWING FUNCTIONAL CALL IS MANUALLY INLINED
403        # Parse all comments, CDATA sections and processing instructions.
404        #markup1 = parse_CtCDPI(lex, EOF_mask)
405        #CT_callouts = CtCDPI_callouts()
406        PI_starts = 0
407        PI_ends = 0
408        Ct_starts = 0
409        Ct_ends = 0
410        CD_starts = 0
411        CD_ends = 0
412        CtCDPI_starts = 0
413        PI_name_ends = 0
414        # Scanning streams
415        CtCDPI_scan = ~lex.CtCDPI_start & EOF_mask
416        Ct_end_scan = ~lex.DoubleHyphen & EOF_mask
417        CD_end_scan = ~lex.CD_end & EOF_mask
418        PI_end_scan = ~lex.PI_end & EOF_mask
419        #
420        # Initiate the scan
421        CtCDPI_Cursor = 1
422        CtCDPI_Cursor = bitutil.ScanThru(CtCDPI_Cursor, CtCDPI_scan)
423        CtCDPI_Cursor &= EOF_mask
424        while CtCDPI_Cursor:
425                CtCDPI_starts |= CtCDPI_Cursor
426                PI_Cursor = CtCDPI_Cursor & lex.PI_start
427                CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
428                CD_Cursor = CD_Ct_Cursor & lex.LBracket
429                Ct_Cursor = bitutil.Advance(CD_Ct_Cursor & lex.Hyphen) 
430                PI_starts |= PI_Cursor
431                CD_starts |= CD_Cursor
432                Ct_starts |= Ct_Cursor
433                Ct_Cursor = bitutil.Advance(Ct_Cursor)
434                Ct_end_scan |= Ct_Cursor
435                #PI_Cursor = bitutil.ScanThru(PI_Cursor, PI_end_scan)
436                PI_Cursor = bitutil.Advance(PI_Cursor)
437                PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
438                PI_name_ends |= PI_name_end
439                CT_callouts.PI_name |= PI_name_end - PI_Cursor
440                PI_Cursor = bitutil.ScanThru(PI_name_end, PI_end_scan)
441                CD_Cursor = bitutil.ScanThru(CD_Cursor, CD_end_scan)
442                Ct_Cursor = bitutil.Advance(bitutil.ScanThru(Ct_Cursor, Ct_end_scan))
443                PI_ends |= PI_Cursor
444                CD_ends |= CD_Cursor
445                Ct_ends |= Ct_Cursor
446                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
447                CtCDPI_Cursor = bitutil.ScanThru(CtCDPI_Cursor, CtCDPI_scan)
448                CtCDPI_Cursor &= EOF_mask
449        # 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
454       
455        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
458        # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
459        CT_callouts.error |= CT_callouts.CtCDPI_mask &~ EOF_mask
460        ########## END OF MANUAL INLINING
461       
462        # THE FOLLOWING FUNCTIONAL CALL IS MANUALLY INLINED
463        # All remaining "<" must be tag start characters; parse tags.
464        #tags = parse_tags(lex, CT_callouts.CtCDPI_mask, EOF_mask)
465
466        #callouts = tag_callouts()
467       
468        # Delimiters for scans.
469        DQuoteScan = ~(lex.DQuote | lex.LAngle) & EOF_mask
470        SQuoteScan = ~(lex.SQuote | lex.LAngle) & EOF_mask
471        AttListDelim = lex.Slash | lex.RAngle
472       
473        # Start the parallel parsing by inspecting the character
474        # after the opening "<" of a tag.
475        LAngleFollow = bitutil.Advance(lex.LAngle) &~ CT_callouts.CtCDPI_mask
476        ElemNamePositions = LAngleFollow & ~lex.Slash
477        EndTagSeconds = LAngleFollow & lex.Slash
478       
479        # Start Tag/Empty Element Tag Parsing
480
481        # Advance all cursors by scanning through the tag name.
482        ElemNameFollows = bitutil.ScanThru(ElemNamePositions, lex.NameScan)
483        # Must have at least one name character for a legal start tag.
484        # Mark any occurrences of null names as errors.
485        ParseError = ElemNamePositions & ElemNameFollows
486        callouts.ElemNames = ElemNameFollows - ElemNamePositions
487       
488        # Initialize the accumulators for attribute name and value positions.
489        AttNameStarts = 0 
490        AttNameFollows = 0
491        EqToCheck = 0
492        AttValStarts = 0
493        AttValEnds = 0
494        AttValFollows = 0
495
496        # After the element name, there may or may not be an attlist.
497        AfterWS = bitutil.ScanThru(ElemNameFollows, lex.WS)
498        AttListEnd = AfterWS & AttListDelim
499        AttNameStart = AfterWS & ~AttListDelim
500        # At least one WS character is required between ElemNames and AttNames.
501        ParseError |= ElemNameFollows & AttNameStart
502
503        #
504        # The following loop iterates through attributes within a start tag.
505        # Because all start tags are processed in parallel, the number of
506        # iterations is the maximum number of attributes found in any one
507        # start tag, plus one.
508        while AttNameStart:
509                AttNameStarts |= AttNameStart
510                AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
511                AttNameFollows |= AttNameFollow
512                # Scan through WS to the expected '=' delimiter.
513                EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
514                EqToCheck |= EqExpected
515                AttValPos = bitutil.ScanThru(bitutil.Advance(EqExpected), lex.WS)
516                AttValStarts |= AttValPos
517                DQuoteAttVal = AttValPos & lex.DQuote
518                SQuoteAttVal = AttValPos & lex.SQuote
519                DQuoteAttEnd = bitutil.ScanThru(bitutil.Advance(DQuoteAttVal), DQuoteScan)
520                SQuoteAttEnd = bitutil.ScanThru(bitutil.Advance(SQuoteAttVal), SQuoteScan)
521                AttValEnd = DQuoteAttEnd | SQuoteAttEnd
522                AttValEnds |= AttValEnd
523                AttValFollow = bitutil.Advance(AttValEnd)
524                AttValFollows |= AttValFollow
525                AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
526                AttListEnd |= AfterWS & AttListDelim
527                AttNameStart = AfterWS & ~AttListDelim
528
529        # No more attribute values to process when AttNameStart == 0.
530        # Not needed for xmlwf
531        callouts.AttNames = AttNameFollows - AttNameStarts
532        #callouts.AttVals = AttValFollows - AttValStarts
533        STagEnds = AttListEnd & lex.RAngle
534        # Mark any "/" characters found as the ends of empty element tags.
535        callouts.EmptyTagMarks = bitutil.Advance(AttListEnd & lex.Slash)
536        callouts.Tags = (STagEnds | callouts.EmptyTagMarks) - ElemNamePositions
537       
538        # Check for errors.
539        ParseError |= AttValFollows & AttNameStarts # No intervening WS.
540        ParseError |= AttNameStarts & AttNameFollows # Null AttName
541        ParseError |= EqToCheck & ~lex.Equals # = not found where expected.
542        ParseError |= AttValStarts & ~ (lex.DQuote | lex.SQuote)
543        ParseError |= AttValEnds & ~ (lex.DQuote | lex.SQuote)
544        ParseError |= callouts.EmptyTagMarks & ~lex.RAngle
545
546        # End Tag Parsing
547        EndTagEnds = bitutil.ScanThru(bitutil.ScanThru(bitutil.Advance(EndTagSeconds), lex.NameScan), lex.WS)
548        ParseError |= EndTagEnds & ~lex.RAngle
549        # Not needed for xmlwf
550        #callouts.EndTags = EndTagEnds - EndTagSeconds
551        callouts.error = ParseError
552        ########## END OF MANUAL INLINING
553
554
555
556
557        # All remaining "&" must be reference start characters; parse them.
558        # INLINED: refs = parse_refs(lex, CT_callouts.CtCDPI_mask)
559        refs = ref_callouts()
560        refs.GenRefs = 0
561        Ref1 = lex.RefStart &~ CT_callouts.CtCDPI_mask
562        #if Ref1:
563        Ref2 = bitutil.Advance(Ref1)
564        NumRef2 = Ref2 & lex.Hash
565        GenRef2 = Ref2 &~ lex.Hash
566        NumRef3 = bitutil.Advance(NumRef2)
567        HexRef3 = NumRef3 & lex.x
568        DecRef3 = NumRef3 &~ lex.x
569        HexRef4 = bitutil.Advance(HexRef3) 
570        GenRefEnds = bitutil.ScanThru(GenRef2, lex.NameScan)
571        DecRefEnds = bitutil.ScanThru(DecRef3, lex.Digit)
572        HexRefEnds = bitutil.ScanThru(HexRef4, lex.Hex)
573        # Error checks
574        # At least one digit required for DecRef, one hex digit for HexRef.
575        error1 = DecRef3 &~ lex.Digit
576        error2 = HexRef4 &~ lex.Hex
577        # Semicolon terminator required (also covers unterminated at EOF).
578        error3 = (GenRefEnds | DecRefEnds | HexRefEnds) &~ lex.Semicolon
579        refs.GenRefs = GenRefEnds - GenRef2
580        #refs.DecRefs = DecRefEnds - DecRef3
581        #refs.HexRefs = HexRefEnds - HexRef4
582        # Mark references for deletion, but leave the trailing semicolon as
583        # the point for insertion of the "expansion" text (most often a
584        # single character).
585        #refs.delmask = (GenRefEnds | DecRefEnds | HexRefEnds) - lex.RefStart
586        refs.error = error1 | error2 | error3
587
588
589        # Ensure that no occurrence of ]]> occurs outside of markup.
590        #CD_end_error = validate_no_CD_end(lex, CT_callouts, callouts)
591        CD_end_error = lex.CD_end & ~(CT_callouts.CtCDPI_mask | callouts.Tags)
592
593
594        # Consolidate and check for errors
595        error_mask = u8.error | xmlchar_error | CT_callouts.error | callouts.error | CD_end_error | refs.error
596
597       
598        qname_stream =  callouts.ElemNames | callouts.AttNames
599        ncname_stream = CT_callouts.PI_name | refs.GenRefs
600        name_stream = qname_stream | ncname_stream
601        name_start = name_stream &~ bitutil.Advance(name_stream)
602        name_start_check = name_start & ~lex.ASCII_name_start
603        name_check = (name_stream &~ name_start | nmtoken_stream) & ~lex.ASCII_name_char & ~u8.suffix
604
605        #return (CT_callouts, callouts, refs, u16hi, u16lo, delmask, error, lex, u16delmask, EOF_mask)
606        return (CT_callouts, callouts, refs, error, lex, EOF_mask, name_check, name_start_check, control)
607
608       
Note: See TracBrowser for help on using the repository browser.