source: proto/SymbolTable/parabix2_symtab_pbs_div.py @ 1472

Last change on this file since 1472 was 1442, checked in by vla24, 8 years ago

SymbolTable?: Fixed integration with IDISA, it does not work well for pbgs_log and pbgs_id_adv. Changed bitutil.* to pablo.* for compiler generated files

File size: 21.3 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 Basis_bits():
18        bit_0 = 0
19        bit_1 = 0
20        bit_2 = 0
21        bit_3 = 0
22        bit_4 = 0
23        bit_5 = 0
24        bit_6 = 0
25        bit_7 = 0
26
27
28class u8 ():
29  unibyte = 0
30  prefix = 0
31  prefix2 = 0
32  prefix3 = 0
33  prefix4 = 0
34  suffix = 0
35  badprefix = 0
36  xE0 = 0
37  xED = 0
38  xF0 = 0
39  xF4 = 0
40  xA0_xBF = 0
41  x80_x9F = 0
42  x90_xBF = 0
43  x80_x8F = 0
44  xEF = 0
45  xBF = 0
46  xBE = 0
47  scope22 = 0
48  scope32 = 0
49  scope33 = 0
50  scope42 = 0
51  scope43 = 0
52  scope44 = 0
53  xE0_scope = 0
54  xED_scope = 0
55  xF0_scope = 0
56  xF4_scope = 0
57  xEF_scope = 0
58
59class Lex ():
60        CR = 0
61        LF = 0
62        HT = 0
63        SP = 0
64        CRLF = 0
65        RefStart = 0
66        Semicolon = 0
67        Colon = 0
68        LAngle = 0
69        RAngle = 0
70        LBracket = 0
71        RBracket = 0
72        Exclam = 0
73        QMark = 0
74        Hyphen = 0
75        Equals = 0
76        SQuote = 0
77        DQuote = 0
78        Slash = 0
79        Hash = 0
80        x = 0
81        ASCII_name_start = 0
82        ASCII_name_char = 0
83        NameScan = 0
84        Digit = 0
85        Hex = 0
86        WS = 0
87
88class Marker ():
89        LAngle_scope = 0
90        Ref_opener = 0
91        CD_closer = 0
92
93class CtCDPI_Callouts():
94        Ct_starts = 0
95        Ct_ends = 0
96        CD_starts = 0
97        CD_ends = 0
98        PI_starts = 0
99        PI_name_starts = 0
100        PI_name_ends = 0
101        PI_ends = 0
102
103class Ref_Callouts():
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
111class Hash_data():
112        Hash_value = 0
113
114class Tag_Callouts():
115        ElemName_starts = 0
116        ElemName_ends = 0
117        ElemName_ends_1_to_2 = 0
118        ElemName_ends_3_to_4 = 0
119        ElemName_ends_5_to_6 = 0
120        ElemName_ends_7_to_8 = 0
121        ElemName_ends_9_to_10 = 0
122        ElemName_ends_11_to_12 = 0
123        ElemName_ends_13_to_14 = 0
124        ElemName_ends_15_to_16 = 0
125        ElemName_remaining_ends = 0
126        AttName_starts = 0
127        AttName_ends = 0
128        AttVal_starts = 0
129        AttVal_ends = 0
130        AttVal_spans = 0
131        EmptyTag_marks = 0
132        EndTag_marks = 0
133
134class Check_streams():
135        misc_mask = 0
136        non_ascii_name_starts = 0
137        non_ascii_names = 0
138        tag_marks = 0
139        name_follows = 0
140        att_refs = 0
141
142def Classify_bytes_Validate_utf8(basis_bits, lex, u8):
143        temp1 = (basis_bits.bit_0 | basis_bits.bit_1);
144        temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3);
145        temp3 = (temp2 &~ temp1);
146        temp4 = (basis_bits.bit_5 &~ basis_bits.bit_4);
147        temp5 = (basis_bits.bit_6 &~ basis_bits.bit_7);
148        temp6 = (temp4 & temp5);
149        lex.RefStart = (temp3 & temp6);
150        temp7 = (basis_bits.bit_2 & basis_bits.bit_3);
151        temp8 = (temp7 &~ temp1);
152        temp9 = (basis_bits.bit_4 &~ basis_bits.bit_5);
153        temp10 = (basis_bits.bit_6 & basis_bits.bit_7);
154        temp11 = (temp9 & temp10);
155        lex.Semicolon = (temp8 & temp11);
156        temp12 = (basis_bits.bit_4 & basis_bits.bit_5);
157        temp13 = (basis_bits.bit_6 | basis_bits.bit_7);
158        temp14 = (temp12 &~ temp13);
159        lex.LAngle = (temp8 & temp14);
160        temp15 = (temp12 & temp5);
161        lex.RAngle = (temp8 & temp15);
162        temp16 = (basis_bits.bit_1 &~ basis_bits.bit_0);
163        temp17 = (basis_bits.bit_3 &~ basis_bits.bit_2);
164        temp18 = (temp16 & temp17);
165        lex.LBracket = (temp18 & temp11);
166        temp19 = (basis_bits.bit_7 &~ basis_bits.bit_6);
167        temp20 = (temp12 & temp19);
168        lex.RBracket = (temp18 & temp20);
169        temp21 = (basis_bits.bit_4 | basis_bits.bit_5);
170        temp22 = (temp19 &~ temp21);
171        lex.Exclam = (temp3 & temp22);
172        temp23 = (temp12 & temp10);
173        lex.QMark = (temp8 & temp23);
174        lex.Hyphen = (temp3 & temp20);
175        lex.Equals = (temp8 & temp20);
176        temp24 = (temp4 & temp10);
177        lex.SQuote = (temp3 & temp24);
178        temp25 = (temp5 &~ temp21);
179        lex.DQuote = (temp3 & temp25);
180        lex.Slash = (temp3 & temp23);
181        temp26 = (temp10 &~ temp21);
182        lex.Hash = (temp3 & temp26);
183        temp27 = (temp16 & temp7);
184        temp28 = (temp9 &~ temp13);
185        lex.x = (temp27 & temp28);
186        temp29 = (temp9 & temp5);
187        lex.Colon = (temp8 & temp29);
188        temp30 = (temp18 & temp23);
189        temp31 = (temp30 | lex.Colon);
190        temp32 = (temp16 &~ basis_bits.bit_2);
191        temp33 = (basis_bits.bit_5 | temp10);
192        temp34 = (basis_bits.bit_4 & temp33);
193        temp35 = (~temp34);
194        temp36 = (temp21 | temp13);
195        temp37 = ((basis_bits.bit_3 & temp35)|(~(basis_bits.bit_3) & temp36));
196        temp38 = (temp32 & temp37);
197        temp39 = (temp31 | temp38);
198        temp40 = (temp16 & basis_bits.bit_2);
199        temp41 = (temp40 & temp37);
200        lex.ASCII_name_start = (temp39 | temp41);
201        temp42 = (temp30 | lex.Hyphen);
202        temp43 = (temp3 & temp15);
203        temp44 = (temp42 | temp43);
204        temp45 = (temp8 &~ temp34);
205        temp46 = (temp44 | temp45);
206        temp47 = (temp46 | temp38);
207        lex.ASCII_name_char = (temp47 | temp41);
208        lex.NameScan = (lex.ASCII_name_char | basis_bits.bit_0);
209        temp48 = (temp1 | basis_bits.bit_2);
210        x00_x1F = (~temp48);
211        temp49 = (basis_bits.bit_2 | basis_bits.bit_3);
212        temp50 = (temp1 | temp49);
213        lex.CR = (temp20 &~ temp50);
214        lex.LF = (temp29 &~ temp50);
215        temp51 = (temp9 & temp19);
216        lex.HT = (temp51 &~ temp50);
217        lex.SP = (temp3 &~ temp36);
218        temp52 = (temp20 | temp29);
219        temp53 = (temp52 | temp51);
220        temp54 = (temp53 &~ temp50);
221        lex.WS = (temp54 | lex.SP);
222        temp55 = (basis_bits.bit_5 | basis_bits.bit_6);
223        temp56 = (basis_bits.bit_4 & temp55);
224        lex.Digit = (temp8 &~ temp56);
225        temp57 = (temp16 &~ temp49);
226        temp58 = (temp57 &~ basis_bits.bit_4);
227        temp59 = (~temp10);
228        temp60 = ((basis_bits.bit_5 & temp59)|(~(basis_bits.bit_5) & temp13));
229        temp61 = (temp58 & temp60);
230        temp62 = (lex.Digit | temp61);
231        temp63 = (temp16 & temp2);
232        temp64 = (temp63 &~ basis_bits.bit_4);
233        temp65 = (temp64 & temp60);
234        lex.Hex = (temp62 | temp65);
235        lex_error = x00_x1F &~ lex.WS
236        if pablo.inFile(lex_error):
237                error_tracker.NoteError("Error: illegal character", lex_error)
238
239
240        ### Validate_utf8(basis_bits, u8):
241        u8.unibyte = (~basis_bits.bit_0);
242        u8.suffix = 0
243        u8_error = 0
244        u8_FFFE_FFFF = 0
245        u8anyscope = 0 #local
246        if basis_bits.bit_0:
247                u8.prefix = (basis_bits.bit_0 & basis_bits.bit_1);
248                u8.prefix2 = (u8.prefix &~ basis_bits.bit_2);
249                u8.prefix3 = (u8.prefix & temp2);
250                u8.prefix4 = (u8.prefix & temp7);
251                u8.suffix = (basis_bits.bit_0 &~ basis_bits.bit_1);
252                temp66 = (u8.prefix &~ temp49);
253                temp67 = (temp21 | basis_bits.bit_6);
254                temp68 = (temp66 &~ temp67);
255                temp69 = (basis_bits.bit_5 & temp13);
256                temp70 = (basis_bits.bit_4 | temp69);
257                temp71 = (u8.prefix4 & temp70);
258                u8.badprefix = (temp68 | temp71);
259                u8_error = u8.badprefix
260                u8.scope22 = pablo.Advance(u8.prefix2)
261                u8anyscope = u8.scope22
262                if u8.prefix3 | u8.prefix4:
263                        xE0 = (u8.prefix3 &~ temp36);
264                        xED = (u8.prefix3 & temp20);
265                        xF0 = (u8.prefix4 &~ temp36);
266                        temp72 = (temp4 &~ temp13);
267                        xF4 = (u8.prefix4 & temp72);
268                        u8.xA0_xBF = (u8.suffix & basis_bits.bit_2);
269                        u8.x80_x9F = (u8.suffix &~ basis_bits.bit_2);
270                        u8.x90_xBF = (u8.suffix & temp49);
271                        u8.x80_x8F = (u8.suffix &~ temp49);
272                        xEF = (u8.prefix3 & temp23);
273                        temp73 = (u8.suffix & temp7);
274                        u8.xBF = (temp73 & temp23);
275                        u8.xBE = (temp73 & temp15);
276#
277#
278#                       scope3_32 = pablo.Advance32(u8.prefix3)
279#                       scope4_32 = pablo.Advance32(u8.prefix4)
280#                       u8.scope32 = interpose32(u8.prefix3, scope3_32, 1)
281#                       u8.scope33 = interpose32(u8.prefix3, scope3_32, 2)
282#                       u8.scope42 = interpose32(u8.prefix4, scope4_32, 1)
283#                       u8.scope43 = interpose32(u8.prefix4, scope4_32, 2)
284#                       u8.scope44 = interpose32(u8.prefix4, scope4_32, 3)
285#
286                        u8.scope32 = pablo.Advance(u8.prefix3)
287                        u8.scope33 = pablo.Advance(u8.scope32)
288                        u8.scope42 = pablo.Advance(u8.prefix4)
289                        u8.scope43 = pablo.Advance(u8.scope42)
290                        u8.scope44 = pablo.Advance(u8.scope43)
291#
292#                       u8.xE0_scope = pablo.Advance(xE0);
293#                       u8.xED_scope = pablo.Advance(xED);
294#                       u8.xF0_scope = pablo.Advance(xF0);
295#                       u8.xF4_scope = pablo.Advance(xF4);
296                        E0_F0_scope = pablo.Advance(xE0 | xF0)
297                        ED_F4_scope = pablo.Advance(xED | xF4)
298                        u8.xE0_scope = u8.scope32 & E0_F0_scope
299                        u8.xED_scope = u8.scope32 & ED_F4_scope
300                        u8.xF0_scope = u8.scope42 & E0_F0_scope
301                        u8.xF4_scope = u8.scope42 & ED_F4_scope
302                        u8.xEF_scope = pablo.Advance(xEF);
303
304                        u8lastscope = u8.scope22 | u8.scope33 | u8.scope44
305                        u8anyscope = u8lastscope | u8.scope32 | u8.scope42 | u8.scope43
306
307                        u8error1 = u8.xE0_scope & u8.x80_x9F
308                        u8error2 = u8.xED_scope & u8.xA0_xBF
309                        u8error3 = u8.xF0_scope & u8.x80_x8F
310                        u8error4 = u8.xF4_scope & u8.x90_xBF
311
312                        u8_error |= u8error1 | u8error2 | u8error3 | u8error4
313
314                        EF_BF_pending = pablo.Advance(u8.xEF_scope & u8.xBF)
315
316                        u8_FFFE_FFFF = (EF_BF_pending & (u8.xBE | u8.xBF))
317                u8mismatch = u8anyscope ^ u8.suffix
318                u8_error |= u8mismatch | u8_FFFE_FFFF
319                if u8_error:
320                        error_tracker.NoteError("UTF-8 error found", (u8_error))
321
322
323def Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams):
324        ctCDPI_Callouts.Ct_starts = 0
325        ctCDPI_Callouts.Ct_ends = 0
326        ctCDPI_Callouts.CD_starts = 0
327        ctCDPI_Callouts.CD_ends = 0
328        ctCDPI_Callouts.PI_starts = 0
329        ctCDPI_Callouts.PI_name_starts = 0
330        ctCDPI_Callouts.PI_name_ends = 0
331        ctCDPI_Callouts.PI_ends = 0
332        CtCDPI_starts = 0
333        CtCDPI_ends = 0
334        ctCDPI_mask = 0
335
336        v = lex.LAngle | lex.Hyphen
337        w = lex.Hyphen | lex.QMark
338        v1 = pablo.Advance(v)
339        w1 = pablo.Advance(w)
340
341        LAngle_scope = v1 &~ w1  #pablo.Advance(lex.LAngle)
342        PI_opener = LAngle_scope & lex.QMark
343        CtCD_opener= LAngle_scope & lex.Exclam
344        CtCDPI_opener = PI_opener | CtCD_opener
345
346        #DoubleHyphen = 0
347        CD_closer = 0
348        #PI_closer = 0
349
350        #if lex.Hyphen: DoubleHyphen = pablo.Advance(lex.Hyphen) & lex.Hyphen
351        DoubleHyphen = v1 & w1 & lex.Hyphen
352        if lex.RBracket:
353                DoubleRBracket = pablo.Advance(lex.RBracket) & lex.RBracket
354                CD_closer = pablo.Advance(DoubleRBracket) & lex.RAngle
355        #if lex.QMark: PI_closer = pablo.Advance(lex.QMark) & lex.RAngle
356        PI_closer = w1 & ~v1 & lex.RAngle
357
358        #
359        # Initiate the scan
360        CtCDPI_Cursor = pablo.ScanToFirst(CtCDPI_opener)
361        while CtCDPI_Cursor:
362                CtCDPI_starts |= CtCDPI_Cursor
363                PI_Cursor = CtCDPI_Cursor & PI_opener
364                CD_Ct_Cursor = pablo.Advance(CtCDPI_Cursor & ~PI_Cursor)
365                CD_Cursor = CD_Ct_Cursor & lex.LBracket
366                Ct_Cursor = CD_Ct_Cursor & lex.Hyphen
367                # PI processing
368                if PI_Cursor:
369                        ctCDPI_Callouts.PI_starts |= PI_Cursor
370                        PI_Cursor = pablo.Advance(PI_Cursor)
371                        ctCDPI_Callouts.PI_name_starts |= PI_Cursor
372                        PI_name_end = pablo.ScanThru(PI_Cursor, lex.NameScan)
373                        PI_error = PI_Cursor & PI_name_end
374                        PI_error |= pablo.Advance(PI_name_end & ~ lex.WS) & ~ PI_closer
375                        if PI_error:
376                                error_tracker.NoteError("Error in PI syntax", PI_name_end)
377                        ctCDPI_Callouts.PI_name_ends |= PI_name_end
378                        PI_Cursor = pablo.ScanTo(PI_name_end, PI_closer)
379                        ctCDPI_Callouts.PI_ends |= PI_Cursor
380                        CtCDPI_ends |= PI_Cursor
381
382                # CDATA section processing
383                if CD_Cursor:
384                        ctCDPI_Callouts.CD_starts |= CD_Cursor
385                        CD_Cursor = pablo.ScanTo(CD_Cursor, CD_closer)
386                        ctCDPI_Callouts.CD_ends |= CD_Cursor
387                        CtCDPI_ends |= CD_Cursor
388
389                # Comment processing
390                if Ct_Cursor:
391                        ctCDPI_Callouts.Ct_starts |= Ct_Cursor
392                        Ct_Cursor = pablo.Advance(Ct_Cursor)
393                        Ct_error = Ct_Cursor & ~ lex.Hyphen
394                        # Advance twice past <!--, so that we don't treat <!---
395                        # as being a terminated comment.
396                        Ct_Cursor = pablo.Advance(pablo.Advance(Ct_Cursor))
397                        Ct_Cursor = pablo.Advance(pablo.ScanTo(Ct_Cursor, DoubleHyphen))
398                        Ct_error |= Ct_Cursor & ~ lex.RAngle
399                        ctCDPI_Callouts.Ct_ends |= Ct_Cursor
400                        CtCDPI_ends |= Ct_Cursor
401                        if Ct_error:
402                                error_tracker.NoteError("Error in comment syntax", Ct_error)
403
404                # Common processing
405                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
406                CtCDPI_Cursor = pablo.ScanTo(CtCDPI_Cursor, CtCDPI_opener)
407                ctCDPI_mask |= (CtCDPI_ends - CtCDPI_starts) | CtCDPI_ends
408                # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
409                ctCDPI_error = pablo.atEOF(ctCDPI_mask)
410
411                if ctCDPI_error:
412                        error_tracker.NoteError("Error in comment, CDATA or processing instruction syntax", ctCDPI_error)
413
414        check_streams.misc_mask = (lex.WS | lex.LAngle | (pablo.Advance(ctCDPI_Callouts.Ct_ends | ctCDPI_Callouts.PI_ends) - (ctCDPI_Callouts.Ct_starts | ctCDPI_Callouts.PI_starts)) | CtCDPI_starts) & EOF_mask
415
416
417        # Identify the remaining significant markers for XML processing.
418        marker.LAngle_scope = LAngle_scope &~ ctCDPI_mask
419        marker.Ref_opener = lex.RefStart &~ ctCDPI_mask
420        marker.CD_closer = CD_closer &~ ctCDPI_mask
421
422def Parse_tags(lex, marker, tag_Callouts):
423
424        # Delimiters for scans.
425        DQuoteDelim = lex.DQuote | lex.LAngle
426        SQuoteDelim = lex.SQuote | lex.LAngle
427        AttListDelim = lex.Slash | lex.RAngle
428
429        # Start the parallel parsing by inspecting the character
430        # after the opening "<" of a tag.
431        tag_Callouts.ElemName_starts = marker.LAngle_scope & ~lex.Slash
432        tag_Callouts.EndTag_marks = marker.LAngle_scope & lex.Slash
433
434        # Start Tag/Empty Element Tag Parsing
435
436        # Advance all cursors by scanning through the tag name.
437        tag_Callouts.ElemName_ends = pablo.ScanThru(tag_Callouts.ElemName_starts, lex.NameScan)
438        # Must have at least one name character for a legal start tag.
439        # Mark any occurrences of null names as errors.
440        ParseError = tag_Callouts.ElemName_starts & tag_Callouts.ElemName_ends
441
442        # Initialize the accumulators for attribute name and value positions.
443        tag_Callouts.AttName_starts = 0
444        tag_Callouts.AttName_ends = 0
445        tag_Callouts.AttVal_starts = 0
446        tag_Callouts.AttVal_ends = 0
447
448        # After the element name, there may or may not be an attlist.
449        if tag_Callouts.ElemName_ends & lex.WS:
450                AfterWS = pablo.ScanThru(tag_Callouts.ElemName_ends, lex.WS)
451                AttListEnd = AfterWS & AttListDelim
452                AttNameStart = AfterWS & ~AttListDelim
453                #
454                # The following loop iterates through attributes within a start tag.
455                # Because all start tags are processed in parallel, the number of
456                # iterations is the maximum number of attributes found in any one
457                # start tag, plus one.
458                while AttNameStart:
459                        ParseError |= AttNameStart &~ lex.NameScan
460                        tag_Callouts.AttName_starts |= AttNameStart
461                        AttNameFollow = pablo.ScanThru(AttNameStart, lex.NameScan)
462                        tag_Callouts.AttName_ends |= AttNameFollow
463                        # Scan through WS to the expected '=' delimiter.
464                        # EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
465                        # But use if test to optimize.
466                        if AttNameFollow & lex.WS:
467                                EqExpected = pablo.ScanThru(AttNameFollow, lex.WS)
468                        else: EqExpected = AttNameFollow
469                        ParseError |= EqExpected &~ lex.Equals
470                        AttValPos = pablo.ScanThru(EqExpected, EqExpected | lex.WS)
471                        tag_Callouts.AttVal_starts |= AttValPos
472                        DQuoteAttVal = AttValPos & lex.DQuote
473                        SQuoteAttVal = AttValPos & lex.SQuote
474                        DQuoteAttEnd = pablo.ScanTo(DQuoteAttVal, DQuoteDelim &~ DQuoteAttVal)
475                        SQuoteAttEnd = pablo.ScanTo(SQuoteAttVal, SQuoteDelim &~ SQuoteAttVal)
476                        AttValEnd = DQuoteAttEnd | SQuoteAttEnd
477                        ParseError |= (AttValPos | AttValEnd) &~ (lex.DQuote | lex.SQuote)
478                        AttValFollow = pablo.Advance(AttValEnd)
479                        tag_Callouts.AttVal_ends |= AttValFollow
480                        #  AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
481                        if AttValFollow & lex.WS:
482                                AfterWS = pablo.ScanThru(AttValFollow, lex.WS)
483                                AttListEnd |= AfterWS & AttListDelim
484                                AttNameStart = AfterWS & ~AttListDelim
485                        else:
486                                AttListEnd |= AttValFollow & AttListDelim
487                                AttNameStart = 0
488                                ParseError |= AttValFollow & ~AttListDelim
489        else:
490                # No WS character after ElemName; must be at the end
491                AttListEnd = tag_Callouts.ElemName_ends & AttListDelim
492                ParseError |= tag_Callouts.ElemName_ends & ~AttListDelim
493
494        STagEnds = AttListEnd & lex.RAngle
495        # Mark any "/" characters found as the ends of empty element tags.
496        tag_Callouts.EmptyTag_marks = pablo.Advance(AttListEnd & lex.Slash)
497
498        ParseError |= tag_Callouts.EmptyTag_marks & ~lex.RAngle
499
500        # End Tag Parsing
501
502        EndTagEnds = pablo.ScanThru(tag_Callouts.EndTag_marks, tag_Callouts.EndTag_marks | lex.NameScan)
503        if EndTagEnds & lex.WS:
504                EndTagEnds = pablo.ScanThru(EndTagEnds, lex.WS)
505        ParseError |= EndTagEnds & ~lex.RAngle
506        if ParseError:
507                error_tracker.NoteError("Tag parsing error found", (ParseError))
508
509
510        # Attribute value spans
511        tag_Callouts.AttVal_spans = tag_Callouts.AttVal_ends - tag_Callouts.AttVal_starts
512
513def Parse_refs(lex, marker, ref_Callouts):
514        ref_Callouts.GenRef_starts = 0
515        ref_Callouts.GenRef_ends = 0
516        ref_Callouts.DecRef_starts = 0
517        ref_Callouts.DecRef_ends = 0
518        ref_Callouts.HexRef_starts = 0
519        ref_Callouts.HexRef_ends = 0
520        ref_error = 0
521
522        # All remaining "&" must be reference start characters; parse them.
523        if marker.Ref_opener:
524                Ref_scope = pablo.Advance(marker.Ref_opener)
525                NumRef2 = Ref_scope & lex.Hash
526                ref_Callouts.GenRef_starts = Ref_scope &~ lex.Hash
527                NumRef3 = pablo.Advance(NumRef2)
528                HexRef3 = NumRef3 & lex.x
529                ref_Callouts.DecRef_starts = NumRef3 &~ lex.x
530                ref_Callouts.HexRef_starts = pablo.Advance(HexRef3)
531                ref_Callouts.GenRef_ends = pablo.ScanThru(ref_Callouts.GenRef_starts, lex.NameScan)
532                ref_Callouts.DecRef_ends = pablo.ScanThru(ref_Callouts.DecRef_starts, lex.Digit)
533                ref_Callouts.HexRef_ends = pablo.ScanThru(ref_Callouts.HexRef_starts, lex.Hex)
534                # Error checks
535                # At least one digit required for DecRef, one hex digit for HexRef.
536                ref_error1 = ref_Callouts.DecRef_starts &~ lex.Digit
537                ref_error2 = ref_Callouts.HexRef_starts &~ lex.Hex
538                # Semicolon terminator required (also covers unterminated at EOF).
539                ref_ends = ref_Callouts.GenRef_ends | ref_Callouts.DecRef_ends | ref_Callouts.HexRef_ends
540                ref_error3 = ref_ends &~ lex.Semicolon
541                ref_error = ref_error1 | ref_error2 | ref_error3
542                if ref_error:
543                        error_tracker.NoteError("Reference error found", (ref_error))
544
545
546
547def Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams):
548        PI_names = ctCDPI_Callouts.PI_name_ends - ctCDPI_Callouts.PI_name_starts
549        GenRefs = ref_Callouts.GenRef_ends - ref_Callouts.GenRef_starts
550        ElemNames = tag_Callouts.ElemName_ends - tag_Callouts.ElemName_starts
551        AttNames = tag_Callouts.AttName_ends - tag_Callouts.AttName_starts
552        qname_stream =  ElemNames | AttNames
553        ncname_stream = PI_names | GenRefs
554        name_stream = qname_stream | ncname_stream
555        name_start = name_stream &~ pablo.Advance(name_stream)
556        name_cursor = name_stream & ~pablo.Advance(name_stream)
557        void_prefix_err = name_cursor & lex.Colon
558        namespace_sep = pablo.ScanThru(name_cursor, lex.NameScan &~ lex.Colon) & lex.Colon
559        local_part_start = pablo.Advance(namespace_sep)
560        local_part_err = local_part_start &~ lex.NameScan
561        colon2_err = pablo.ScanThru(local_part_start, lex.NameScan &~ lex.Colon) & lex.Colon
562        ncname_err = ncname_stream & lex.Colon
563        namespace_error = void_prefix_err | local_part_err | colon2_err | ncname_err
564        if namespace_error:
565                error_tracker.NoteError("error found", namespace_error)
566
567
568        check_streams.non_ascii_name_starts = name_start &~lex.ASCII_name_start
569        check_streams.non_ascii_names = (name_stream &~ name_start) & ~lex.ASCII_name_char & ~u8.suffix
570
571def Do_check_streams(marker, tag_Callouts, check_streams):
572        CD_end_error = marker.CD_closer & ~tag_Callouts.AttVal_spans
573        if CD_end_error:
574                error_tracker.NoteError("Error: ]]> in text", CD_end_error)
575        check_streams.tag_marks = tag_Callouts.EmptyTag_marks | tag_Callouts.ElemName_starts | tag_Callouts.EndTag_marks | tag_Callouts.AttName_starts
576        check_streams.name_follows = tag_Callouts.ElemName_ends | tag_Callouts.AttName_ends
577        check_streams.att_refs = tag_Callouts.AttVal_spans & marker.Ref_opener
578
579def Form_Length_Group_Bitstreams(tag_Callouts):
580
581    starts = tag_Callouts.ElemName_starts
582    ends = tag_Callouts.ElemName_ends
583
584    temp = ends | pablo.Advance(ends)
585
586    # Group symbols of length 1 and 2
587    start_2 = pablo.Advance(pablo.Advance(starts))
588    tag_Callouts.ElemName_ends_1_to_2 =  start_2 & temp
589
590    # Group symbols of length 3 and 4
591    start_4 = pablo.Advance(pablo.Advance(start_2 & ~temp))
592    tag_Callouts.ElemName_ends_3_to_4 =  start_4 & temp
593
594    # Group symbols of length 5 and 6
595    start_6 = pablo.Advance(pablo.Advance(start_4 & ~temp))
596    tag_Callouts.ElemName_ends_5_to_6 =  start_6 & temp
597
598    # Group symbols of length 7 and 8
599    start_8 = pablo.Advance(pablo.Advance(start_6 & ~temp))
600    tag_Callouts.ElemName_ends_7_to_8 =  start_8 & temp
601
602    # Group symbols of length 9 and 10
603    start_10 = pablo.Advance(pablo.Advance(start_8 & ~temp))
604    tag_Callouts.ElemName_ends_9_to_10 =  start_10 & temp
605
606    # Group symbols of length 11 and 12
607    start_12 = pablo.Advance(pablo.Advance(start_10 & ~temp))
608    tag_Callouts.ElemName_ends_11_to_12 =  start_12 & temp
609
610    # Group symbols of length 13 and 14
611    start_14 = pablo.Advance(pablo.Advance(start_12 & ~temp))
612    tag_Callouts.ElemName_ends_13_to_14 =  start_14 & temp
613
614    # Group symbols of length 15 and 16
615    start_16 = pablo.Advance(pablo.Advance(start_14 & ~temp))
616    tag_Callouts.ElemName_ends_15_to_16 =  start_16 & temp
617
618    # Group symbols of length 17 and longer
619    tag_Callouts.ElemName_remaining_ends = start_16 & ~tag_Callouts.ElemName_ends_15_to_16
620
621
622def Compute_Hash_Value_Bitstream(hash_data, basis_bits):
623    hash_data.Hash_value = basis_bits.bit_2 ^ basis_bits.bit_4 ^ basis_bits.bit_6
624    #hash_data.Hash_value = basis_bits.bit_3 ^ basis_bits.bit_5 ^ basis_bits.bit_7
625
626def Main(basis_bits, lex, u8, xml_char, scope1, ctCDPI_Callouts, ref_Callouts, tag_Callouts, masks, xml_names, check_streams, hash_data):
627
628        # Classify bytes for UTF-8 processing, whitespace and control
629        # processing and XML lexical analysis.
630        # Classify_bytes(basis_bits, lex)
631
632        # Validate UTF-8 multibyte sequences and determine the UTF-8 scope streams
633        # Validate_utf8(basis_bits, u8)
634
635        Classify_bytes_Validate_utf8(basis_bits, lex, u8)
636
637        # Parse all comments, CDATA sections and processing instructions.
638        Parse_CtCDPI(lex, marker, ctCDPI_Callouts, check_streams)
639
640        # All remaining '<' must be tag start characters; parse tags.
641        Parse_tags(lex, marker, tag_Callouts)
642
643        # All remaining '&' must be reference start characters; parse them.
644        Parse_refs(lex, marker, ref_Callouts)
645
646        # Validate XML namespaces and generate bit streams to post validate non-ascii range XML names
647        Validate_xml_names(ctCDPI_Callouts, ref_Callouts, tag_Callouts, lex, u8, check_streams)
648
649        Do_check_streams(marker, tag_Callouts, check_streams)
650
651        # These methods are needed to do Paralel Bitstream Based Length Sorting
652        Form_Length_Group_Bitstreams(tag_Callouts)
653
654        Compute_Hash_Value_Bitstream(hash_data, basis_bits);
Note: See TracBrowser for help on using the repository browser.