source: proto/parabix2/parabix2_pablo.py @ 861

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

Organize call outs from Reference processing.

File size: 16.4 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
15class u8 ():
16  unibyte = 0
17  prefix = 0
18  prefix2 = 0
19  prefix3 = 0
20  prefix4 = 0
21  suffix = 0
22  badprefix = 0
23  xE0 = 0
24  xED = 0
25  xF0 = 0
26  xF4 = 0
27  xA0_xBF = 0
28  x80_x9F = 0
29  x90_xBF = 0
30  x80_x8F = 0
31  xEF = 0
32  xBF = 0
33  xBE = 0
34  scope22 = 0
35  scope32 = 0
36  scope33 = 0
37  scope42 = 0
38  scope43 = 0
39  scope44 = 0
40  xE0_scope = 0
41  xED_scope = 0
42  xF0_scope = 0
43  xF4_scope = 0
44  xEF_scope = 0
45  error = 0
46
47class Lex (BitStreamSet):
48        x00_x1F = 0
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        PI_start = 0
77        CtCD_start = 0
78        EndTag_start = 0
79        CD_end = 0
80        DoubleHyphen = 0
81        PI_end = 0
82        CtCDPI_start = 0
83
84class Scope1 (BitStreamSet):
85        RefStart = 0
86        LAngle = 0
87        Hyphen = 0
88        QMark = 0
89        RBracket = 0
90
91class CtCDPI_Callouts(BitStreamSet):
92        Ct_starts = 0
93        Ct_ends = 0
94        CD_starts = 0
95        CD_ends = 0
96        PI_starts = 0
97        PI_name_starts = 0
98        PI_name_ends = 0
99        PI_ends = 0
100        CtCDPI_mask = 0
101        error = 0
102
103class Ref_Callouts(BitStreamSet):
104        GenRef_starts = 0
105        GenRef_ends = 0
106        DecRef_starts = 0
107        DecRef_ends = 0
108        HexRef_starts = 0
109        HexRef_ends = 0
110        error = 0
111
112class callouts:
113        ElemNames = 0
114        AttNames = 0
115        AttVals = 0
116        Tags = 0
117        EmptyTagMarks = 0
118        EmptyTagEnds = 0
119        EndTags = 0
120        error = 0
121       
122
123
124def main(u8data):
125        # Classify bytes for UTF-8 processing, whitespace and control
126        # processing and XML lexical analysis.
127
128        temp1 = (bit[0] | bit[1]);
129        temp2 = (bit[2] &~ bit[3]);
130        temp3 = (temp2 &~ temp1);
131        temp4 = (bit[5] &~ bit[4]);
132        temp5 = (bit[6] &~ bit[7]);
133        temp6 = (temp4 & temp5);
134        lex.RefStart = (temp3 & temp6);
135        temp7 = (bit[2] & bit[3]);
136        temp8 = (temp7 &~ temp1);
137        temp9 = (bit[4] &~ bit[5]);
138        temp10 = (bit[6] & bit[7]);
139        temp11 = (temp9 & temp10);
140        lex.Semicolon = (temp8 & temp11);
141        temp12 = (bit[4] & bit[5]);
142        temp13 = (bit[6] | bit[7]);
143        temp14 = (temp12 &~ temp13);
144        lex.LAngle = (temp8 & temp14);
145        temp15 = (temp12 & temp5);
146        lex.RAngle = (temp8 & temp15);
147        temp16 = (bit[1] &~ bit[0]);
148        temp17 = (bit[3] &~ bit[2]);
149        temp18 = (temp16 & temp17);
150        lex.LBracket = (temp18 & temp11);
151        temp19 = (bit[7] &~ bit[6]);
152        temp20 = (temp12 & temp19);
153        lex.RBracket = (temp18 & temp20);
154        temp21 = (bit[4] | bit[5]);
155        temp22 = (temp19 &~ temp21);
156        lex.Exclam = (temp3 & temp22);
157        temp23 = (temp12 & temp10);
158        lex.QMark = (temp8 & temp23);
159        lex.Hyphen = (temp3 & temp20);
160        lex.Equals = (temp8 & temp20);
161        temp24 = (temp4 & temp10);
162        lex.SQuote = (temp3 & temp24);
163        temp25 = (temp5 &~ temp21);
164        lex.DQuote = (temp3 & temp25);
165        lex.Slash = (temp3 & temp23);
166        temp26 = (temp10 &~ temp21);
167        lex.Hash = (temp3 & temp26);
168        temp27 = (temp16 & temp7);
169        temp28 = (temp9 &~ temp13);
170        lex.x = (temp27 & temp28);
171        temp29 = (temp9 & temp5);
172        lex.Colon = (temp8 & temp29);
173        temp30 = (temp18 & temp23);
174        temp31 = (temp30 | lex.Colon);
175        temp32 = (temp16 &~ bit[2]);
176        temp33 = (bit[5] | temp10);
177        temp34 = (bit[4] & temp33);
178        temp35 = (~temp34);
179        temp36 = (temp21 | temp13);
180        temp37 = ((bit[3] & temp35)|(~(bit[3]) & temp36));
181        temp38 = (temp32 & temp37);
182        temp39 = (temp31 | temp38);
183        temp40 = (temp16 & bit[2]);
184        temp41 = (temp40 & temp37);
185        lex.ASCII_name_start = (temp39 | temp41);
186        temp42 = (temp30 | lex.Hyphen);
187        temp43 = (temp3 & temp15);
188        temp44 = (temp42 | temp43);
189        temp45 = (temp8 &~ temp34);
190        temp46 = (temp44 | temp45);
191        temp47 = (temp46 | temp38);
192        lex.ASCII_name_char = (temp47 | temp41);
193        lex.NameScan = (lex.ASCII_name_char | bit[0]);
194        temp48 = (temp1 | bit[2]);
195        lex.x00_x1F = (~temp48);
196        temp49 = (bit[2] | bit[3]);
197        temp50 = (temp1 | temp49);
198        lex.CR = (temp20 &~ temp50);
199        lex.LF = (temp29 &~ temp50);
200        temp51 = (temp9 & temp19);
201        lex.HT = (temp51 &~ temp50);
202        lex.SP = (temp3 &~ temp36);
203        temp52 = (temp20 | temp29);
204        temp53 = (temp52 | temp51);
205        temp54 = (temp53 &~ temp50);
206        lex.WS = (temp54 | lex.SP);
207        temp55 = (bit[5] | bit[6]);
208        temp56 = (bit[4] & temp55);
209        lex.Digit = (temp8 &~ temp56);
210        temp57 = (temp16 &~ temp49);
211        temp58 = (temp57 &~ bit[4]);
212        temp59 = (~temp10);
213        temp60 = ((bit[5] & temp59)|(~(bit[5]) & temp13));
214        temp61 = (temp58 & temp60);
215        temp62 = (lex.Digit | temp61);
216        temp63 = (temp16 & temp2);
217        temp64 = (temp63 &~ bit[4]);
218        temp65 = (temp64 & temp60);
219        lex.Hex = (temp62 | temp65);
220
221
222        # Check for illegal control characters
223        xmlchar_error = (lex.x00_x1F &~ lex.WS & EOF_mask)
224
225
226        u8.unibyte = (~bit[0]);
227        u8.suffix = 0
228        u8.error = 0
229        FFFE_FFFF = 0
230        u8anyscope = 0
231        if bit[0]:
232                u8.prefix = (bit[0] & bit[1]);
233                u8.prefix2 = (u8.prefix &~ bit[2]);
234                u8.prefix3 = (u8.prefix & temp2);
235                u8.prefix4 = (u8.prefix & temp7);
236                u8.suffix = (bit[0] &~ bit[1]);
237                temp66 = (u8.prefix &~ temp49);
238                temp67 = (temp21 | bit[6]);
239                temp68 = (temp66 &~ temp67);
240                temp69 = (bit[5] & temp13);
241                temp70 = (bit[4] | temp69);
242                temp71 = (u8.prefix4 & temp70);
243                u8.badprefix = (temp68 | temp71);
244                u8.error = u8.badprefix
245                u8.scope22 = bitutil.Advance(u8.prefix2)
246                u8anyscope = u8.scope22
247                if u8.prefix3 | u8.prefix4:
248                        xE0 = (u8.prefix3 &~ temp36);
249                        xED = (u8.prefix3 & temp20);
250                        xF0 = (u8.prefix4 &~ temp36);
251                        temp72 = (temp4 &~ temp13);
252                        xF4 = (u8.prefix4 & temp72);
253                        u8.xA0_xBF = (u8.suffix & bit[2]);
254                        u8.x80_x9F = (u8.suffix &~ bit[2]);
255                        u8.x90_xBF = (u8.suffix & temp49);
256                        u8.x80_x8F = (u8.suffix &~ temp49);
257                        xEF = (u8.prefix3 & temp23);
258                        temp73 = (u8.suffix & temp7);
259                        u8.xBF = (temp73 & temp23);
260                        u8.xBE = (temp73 & temp15);
261                        u8.xE0_scope = bitutil.Advance(xE0);
262                        u8.xED_scope = bitutil.Advance(xED);
263                        u8.xF0_scope = bitutil.Advance(xF0);
264                        u8.xF4_scope = bitutil.Advance(xF4);
265                        u8.xEF_scope = bitutil.Advance(xEF);
266                        u8.scope32 = bitutil.Advance(u8.prefix3)
267                        u8.scope33 = bitutil.Advance(u8.scope32)
268                        u8.scope42 = bitutil.Advance(u8.prefix4)
269                        u8.scope43 = bitutil.Advance(u8.scope42)
270                        u8.scope44 = bitutil.Advance(u8.scope43)
271
272                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
273                        u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43
274               
275                        u8error1 = u8.xE0_scope & u8.x80_x9F
276                        u8error2 = u8.xED_scope & u8.xA0_xBF
277                        u8error3 = u8.xF0_scope & u8.x80_x8F
278                        u8error4 = u8.xF4_scope & u8.x90_xBF
279       
280                        u8.error |= u8error1 | u8error2 | u8error3 | u8error4
281
282                        EF_BF_pending = bitutil.Advance(u8.xEF_scope & u8.xBF)
283
284                        FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
285        u8mismatch = u8anyscope ^ u8.suffix
286        u8.error |= u8mismatch
287
288
289        xmlchar_error |= FFFE_FFFF
290
291        scope1.LAngle = bitutil.Advance(lex.LAngle)
292        scope1.Hyphen = bitutil.Advance(lex.Hyphen)
293        scope1.QMark = bitutil.Advance(lex.QMark)
294
295        lex.CD_end = 0
296        if lex.RBracket:
297                scope1.RBracket = bitutil.Advance(lex.RBracket)
298                lex.CD_end = bitutil.Advance(scope1.RBracket & lex.RBracket) & lex.RAngle
299
300        # Compute XML multilterals such as <?, </, --, ]]>.
301        #lex = add_multiliterals(lex)
302        lex.PI_start = scope1.LAngle & lex.QMark
303        lex.CtCD_start = scope1.LAngle & lex.Exclam
304        lex.CtCDPI_start = lex.PI_start | lex.CtCD_start
305        lex.EndTag_start = scope1.LAngle & lex.Slash
306
307        #if lex.CtCDPI_start:
308        lex.DoubleHyphen = scope1.Hyphen & lex.Hyphen
309        lex.PI_end = scope1.QMark & lex.RAngle
310
311        ctCDPI_Callouts.Ct_starts = 0
312        ctCDPI_Callouts.Ct_ends = 0
313        ctCDPI_Callouts.CD_starts = 0
314        ctCDPI_Callouts.CD_ends = 0
315        ctCDPI_Callouts.PI_starts = 0
316        ctCDPI_Callouts.PI_name_starts = 0
317        ctCDPI_Callouts.PI_name_ends = 0
318        ctCDPI_Callouts.PI_ends = 0
319        ctCDPI_Callouts.CtCDPI_mask = 0
320        ctCDPI_Callouts.error = 0
321
322        CtCDPI_starts = 0
323
324        # Scanning streams
325        CtCDPI_scan = ~lex.CtCDPI_start & EOF_mask
326        Ct_end_scan = ~lex.DoubleHyphen & EOF_mask
327        CD_end_scan = ~lex.CD_end & EOF_mask
328        PI_end_scan = ~lex.PI_end & EOF_mask
329        #
330        # Initiate the scan
331        CtCDPI_Cursor = 1
332        CtCDPI_Cursor = bitutil.ScanThru(CtCDPI_Cursor, CtCDPI_scan)
333        CtCDPI_Cursor &= EOF_mask
334        while CtCDPI_Cursor:
335                CtCDPI_starts |= CtCDPI_Cursor
336                PI_Cursor = CtCDPI_Cursor & lex.PI_start
337                CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
338                CD_Cursor = CD_Ct_Cursor & lex.LBracket
339                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
340                ctCDPI_Callouts.PI_starts |= PI_Cursor
341                ctCDPI_Callouts.CD_starts |= CD_Cursor
342                ctCDPI_Callouts.Ct_starts |= Ct_Cursor
343                Ct_Cursor = bitutil.Advance(Ct_Cursor) 
344                Ct_errors |= Ct_Cursor & ~ lex.Hyphen
345                Ct_Cursor = bitutil.Advance(Ct_Cursor)
346                Ct_end_scan |= Ct_Cursor
347                #PI_Cursor = bitutil.ScanThru(PI_Cursor, PI_end_scan)
348                PI_Cursor = bitutil.Advance(PI_Cursor)
349                ctCDPI_Callouts.PI_name_starts |= PI_Cursor
350                PI_name_end = bitutil.ScanThru(PI_Cursor, lex.NameScan)
351                ctCDPI_Callouts.PI_name_ends |= PI_name_end
352                PI_Cursor = bitutil.ScanThru(PI_name_end, PI_end_scan)
353                CD_Cursor = bitutil.ScanThru(CD_Cursor, CD_end_scan)
354                Ct_Cursor = bitutil.Advance(bitutil.ScanThru(Ct_Cursor, Ct_end_scan))
355                ctCDPI_Callouts.PI_ends |= PI_Cursor
356                ctCDPI_Callouts.CD_ends |= CD_Cursor
357                ctCDPI_Callouts.Ct_ends |= Ct_Cursor
358                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
359                CtCDPI_Cursor = bitutil.ScanThru(CtCDPI_Cursor, CtCDPI_scan)
360                CtCDPI_Cursor &= EOF_mask
361       
362                ctCDPI_Callouts.CtCDPI_mask = bitutil.Advance(ctCDPI_Callouts.CD_ends | ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) - CtCDPI_starts
363                #ctCDPI_Callouts.error = Ct_ends & ~lex.RAngle | Ct_starts & ~ lex.Hyphen
364                ctCDPI_Callouts.error = Ct_errors | ctCDPI_Callouts.Ct_ends & ~lex.RAngle
365                ctCDPI_Callouts.error |= bitutil.Advance(ctCDPI_Callouts.PI_name_ends & ~ lex.WS) & ~ lex.PI_end
366                ctCDPI_Callouts.error |= ctCDPI_Callouts.PI_name_starts & ctCDPI_Callouts.PI_name_ends
367                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
368                ctCDPI_Callouts.error |= ctCDPI_Callouts.CtCDPI_mask &~ EOF_mask
369               
370        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
371
372        #callouts = tag_callouts()
373       
374        # Delimiters for scans.
375        DQuoteScan = ~(lex.DQuote | lex.LAngle) & EOF_mask
376        SQuoteScan = ~(lex.SQuote | lex.LAngle) & EOF_mask
377        AttListDelim = lex.Slash | lex.RAngle
378       
379        # Start the parallel parsing by inspecting the character
380        # after the opening "<" of a tag.
381        LAngleFollow = scope1.LAngle &~ ctCDPI_Callouts.CtCDPI_mask
382        ElemNamePositions = LAngleFollow & ~lex.Slash
383        EndTagSeconds = LAngleFollow & lex.Slash
384       
385        # Start Tag/Empty Element Tag Parsing
386
387        # Advance all cursors by scanning through the tag name.
388        ElemNameFollows = bitutil.ScanThru(ElemNamePositions, 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 = ElemNamePositions & ElemNameFollows
392        callouts.ElemNames = ElemNameFollows - ElemNamePositions
393       
394        # Initialize the accumulators for attribute name and value positions.
395        Attname_starts = 0 
396        AttNameFollows = 0
397        EqToCheck = 0
398        AttValStarts = 0
399        AttValEnds = 0
400        AttValFollows = 0
401
402        # After the element name, there may or may not be an attlist.
403        AfterWS = bitutil.ScanThru(ElemNameFollows, lex.WS)
404        AttListEnd = AfterWS & AttListDelim
405        AttNameStart = AfterWS & ~AttListDelim
406        # At least one WS character is required between ElemNames and AttNames.
407        ParseError |= ElemNameFollows & AttNameStart
408
409        #
410        # The following loop iterates through attributes within a start tag.
411        # Because all start tags are processed in parallel, the number of
412        # iterations is the maximum number of attributes found in any one
413        # start tag, plus one.
414        while AttNameStart:
415                Attname_starts |= AttNameStart
416                AttNameFollow = bitutil.ScanThru(AttNameStart, lex.NameScan)
417                AttNameFollows |= AttNameFollow
418                # Scan through WS to the expected '=' delimiter.
419                EqExpected = bitutil.ScanThru(AttNameFollow, lex.WS)
420                EqToCheck |= EqExpected
421                AttValPos = bitutil.ScanThru(EqExpected, EqExpected | lex.WS)
422                AttValStarts |= AttValPos
423                DQuoteAttVal = AttValPos & lex.DQuote
424                SQuoteAttVal = AttValPos & lex.SQuote
425                DQuoteAttEnd = bitutil.ScanThru(DQuoteAttVal, DQuoteAttVal | DQuoteScan)
426                SQuoteAttEnd = bitutil.ScanThru(SQuoteAttVal, SQuoteAttVal | SQuoteScan)
427                AttValEnd = DQuoteAttEnd | SQuoteAttEnd
428                AttValEnds |= AttValEnd
429                AttValFollow = bitutil.Advance(AttValEnd)
430                AttValFollows |= AttValFollow
431                AfterWS = bitutil.ScanThru(AttValFollow, lex.WS)
432                AttListEnd |= AfterWS & AttListDelim
433                AttNameStart = AfterWS & ~AttListDelim
434
435        # No more attribute values to process when AttNameStart == 0.
436        # Not needed for xmlwf
437        callouts.AttNames = AttNameFollows - Attname_starts
438        callouts.AttVals = AttValFollows - AttValStarts
439        STagEnds = AttListEnd & lex.RAngle
440        # Mark any "/" characters found as the ends of empty element tags.
441        callouts.EmptyTagMarks = bitutil.Advance(AttListEnd & lex.Slash)
442        callouts.Tags = (STagEnds | callouts.EmptyTagMarks) - ElemNamePositions
443       
444        # Check for errors.
445        ParseError |= AttValFollows & Attname_starts # No intervening WS.
446        ParseError |= Attname_starts & AttNameFollows # Null AttName
447        ParseError |= EqToCheck & ~lex.Equals # = not found where expected.
448        ParseError |= AttValStarts & ~ (lex.DQuote | lex.SQuote)
449        ParseError |= AttValEnds & ~ (lex.DQuote | lex.SQuote)
450        ParseError |= callouts.EmptyTagMarks & ~lex.RAngle
451
452        # End Tag Parsing
453        EndTagEnds = bitutil.ScanThru(bitutil.ScanThru(EndTagSeconds, EndTagSeconds | lex.NameScan), lex.WS)
454        ParseError |= EndTagEnds & ~lex.RAngle
455        # Not needed for xmlwf
456        #callouts.EndTags = EndTagEnds - EndTagSeconds
457        callouts.error = ParseError
458        ########## END OF MANUAL INLINING
459
460
461
462
463        # All remaining "&" must be reference start characters; parse them.
464
465        ref_Callouts.GenRef_starts = 0
466        ref_Callouts.GenRef_ends = 0
467        ref_Callouts.DecRef_starts = 0
468        ref_Callouts.DecRef_ends = 0
469        ref_Callouts.HexRef_starts = 0
470        ref_Callouts.HexRef_ends = 0
471        ref_Callouts.error = 0
472
473        Ref1 = lex.RefStart &~ ctCDPI_Callouts.CtCDPI_mask
474        if Ref1:
475                scope1.RefStart = bitutil.Advance(Ref1)
476                NumRef2 = scope1.RefStart & lex.Hash
477                ref_Callouts.GenRef_starts = scope1.RefStart &~ lex.Hash
478                NumRef3 = bitutil.Advance(NumRef2)
479                HexRef3 = NumRef3 & lex.x
480                ref_Callouts.DecRef_starts = NumRef3 &~ lex.x
481                ref_Callouts.HexRef_starts = bitutil.Advance(HexRef3) 
482                ref_Callouts.GenRef_ends = bitutil.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan)
483                ref_Callouts.DecRef_ends = bitutil.ScanThru(ref_Callouts.DecRef_starts, lex.Digit)
484                ref_Callouts.HexRef_ends = bitutil.ScanThru(ref_Callouts.HexRef_starts, lex.Hex)
485                # Error checks
486                # At least one digit required for DecRef, one hex digit for HexRef.
487                ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit
488                ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex
489                # Semicolon terminator required (also covers unterminated at EOF).
490                ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends
491                ref_error3 = ref_ends &~ lex.Semicolon
492                ref_Callouts.error = ref_error1 | ref_error2 | ref_error3
493
494
495        # Ensure that no occurrence of ]]> occurs outside of markup.
496        #CD_end_error = validate_no_CD_end(lex, ctCDPI_Callouts, callouts)
497        CD_end_error = lex.CD_end & ~(ctCDPI_Callouts.CtCDPI_mask | callouts.Tags)
498       
499
500       
501        #name and name start checking streams
502        PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
503        GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
504        qname_stream =  callouts.ElemNames | callouts.AttNames
505        ncname_stream = PI_names | GenRefs
506        name_stream = qname_stream | ncname_stream
507        name_start = name_stream &~ bitutil.Advance(name_stream)
508        name_start_check = name_start & ~lex.ASCII_name_start
509        name_check = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix
510       
511        #namespace validation
512        name_cursor = name_stream & ~bitutil.Advance(name_stream)
513        void_prefix_err = name_cursor & lex.Colon
514        namespace_sep = bitutil.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon
515        local_part_start = bitutil.Advance(namespace_sep)
516        local_part_err = local_part_start &~ lex.NameScan
517        colon2_err = bitutil.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
518        ncname_err = ncname_stream & lex.Colon
519        namespace_error = void_prefix_err | local_part_err | colon2_err | ncname_err
520       
521       
522        # Consolidate and check for errors
523        error_mask = u8.error | xmlchar_error | ctCDPI_Callouts.error | callouts.error | CD_end_error | ref_Callouts.error | namespace_error
524
525
526        #return (ctCDPI_Callouts, callouts, refs, u16hi, u16lo, delmask, error, lex, u16delmask, EOF_mask)
527        tag_marks = callouts.EmptyTagMarks | LAngleFollow | Attname_starts
528        NameFollows = ElemNameFollows | AttNameFollows
529        AttRef = callouts.AttVals & scope1.RefStart
530       
Note: See TracBrowser for help on using the repository browser.