source: proto/parabix2/parabix2_pablo.py @ 859

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

Unify XML scope streams into Scope1 class

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