source: proto/parabix2/parabix2_pablo.py @ 862

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

Reorganize callouts for start, end and empty tags

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