source: docs/EuroPar2011/Demo/europar.py @ 1302

Last change on this file since 1302 was 1302, checked in by lindanl, 8 years ago

Create a directory for HPCA

File size: 19.9 KB
Line 
1#
2# EuroPardemo.py
3
4
5import bitutil
6
7import byteclass
8
9import u8u16
10
11import sys
12
13zero_ch = '.'
14
15def demo_numeric_scan(chardata):
16        lgth = len(chardata)
17        (bit, EOF_mask) = bitutil.transpose_streams(chardata)
18        (u8, control, lex) = byteclass.classify_bytes(bit)
19        cursor = lex.Digit & ~ bitutil.Advance(lex.Digit)
20        cursor2 = cursor + lex.Digit
21        bitutil.print_aligned_u8_byte_streams([('source data $\\vartriangleleft$', chardata[::-1]), 
22                              ('cursor', bitutil.bitstream2stringLE(cursor, lgth, zero_ch)),
23                              ('[0-9] stream', bitutil.bitstream2stringLE(lex.Digit, lgth, zero_ch)),
24                              ('cursor + [0-9]', bitutil.bitstream2stringLE(cursor2, lgth, zero_ch))])
25
26def latex_numeric_scan1(chardata):
27        lgth = len(chardata)
28        (bit, EOF_mask) = bitutil.transpose_streams(chardata)
29        (u8, control, lex) = byteclass.classify_bytes(bit)
30        cursor = lex.Digit & ~ bitutil.Advance(lex.Digit)
31        cursor2 = cursor + lex.Digit
32        return bitutil.latex_streams([('source data $\\vartriangleleft$', chardata[::-1]), 
33                              ('$M_0$', bitutil.bitstream2stringLE(cursor, lgth, zero_ch)),
34                              ('$D$', bitutil.bitstream2stringLE(lex.Digit, lgth, zero_ch)),
35                              ('$M_1 = M_0 + D$', bitutil.bitstream2stringLE(cursor2, lgth, zero_ch))])
36
37def latex_numeric_scan2(chardata, cursorstr):
38        lgth = len(chardata)
39        (bit, EOF_mask) = bitutil.transpose_streams(chardata)
40        (bit2, EOF_mask2) = bitutil.transpose_streams(cursorstr)
41        (u8, control, lex) = byteclass.classify_bytes(bit)
42        (u8x, control2, lex2) = byteclass.classify_bytes(bit2)
43        cursor = bitutil.string2bitstream(cursorstr)
44        temp = (cursor + lex.Digit) 
45        cursor2 = temp & ~lex.Digit
46        return bitutil.latex_streams([('source data $\\vartriangleleft$', chardata[::-1]), 
47                              ('$B_7$', bitutil.bitstream2stringLE(bit[0], lgth, zero_ch)),
48                              ('$B_6$', bitutil.bitstream2stringLE(bit[1], lgth, zero_ch)),
49                              ('$B_5$', bitutil.bitstream2stringLE(bit[2], lgth, zero_ch)),
50                              ('$B_4$', bitutil.bitstream2stringLE(bit[3], lgth, zero_ch)),
51                              ('$B_3$', bitutil.bitstream2stringLE(bit[4], lgth, zero_ch)),
52                              ('$B_2$', bitutil.bitstream2stringLE(bit[5], lgth, zero_ch)),
53                              ('$B_1$', bitutil.bitstream2stringLE(bit[6], lgth, zero_ch)),
54                              ('$B_0$', bitutil.bitstream2stringLE(bit[7], lgth, zero_ch)),
55                              ('\\verb:[0-9]:', bitutil.bitstream2stringLE(lex.Digit, lgth, zero_ch)),
56                              ('$D = $\\verb:[0-9]:', bitutil.bitstream2stringLE(lex.Digit, lgth, zero_ch)),
57                              ('$M_0 =$', bitutil.bitstream2stringLE(cursor, lgth, zero_ch)),
58                              ('$M_0 + D$',  bitutil.bitstream2stringLE(temp, lgth, zero_ch)),
59                              ('$M_1 = (M_0 + D) \\wedge \\neg D$', bitutil.bitstream2stringLE(cursor2, lgth, zero_ch))])
60
61def latex_csv_parse(chardata):
62        lgth = len(chardata)
63        (bit, EOF_mask) = bitutil.transpose_streams(chardata)
64        (u8, control, lex) = byteclass.classify_bytes(bit)
65        p2 = lex.DQuote^(lex.DQuote<<1);
66        p4 = p2^(p2<<2);
67        p8 = p4^(p4<<4);
68        p16 = p8^(p8<<8);
69        p32 = p16^(p16<<16);
70        p64 = p32^(p32<<32);
71        quote_mask = p64^(p64<<64);
72        return bitutil.latex_streams([('source', chardata[::-1]), 
73                                ('Quote', bitutil.bitstream2stringLE(lex.DQuote, lgth, zero_ch)),
74                                ('LF', bitutil.bitstream2stringLE(control.LF, lgth, zero_ch)),
75                                ('p2=DQuote^(DQuote<<1)', bitutil.bitstream2stringLE(p2, lgth, zero_ch)),
76                                ('p4=p2^(p2<<2)', bitutil.bitstream2stringLE(p4, lgth, zero_ch)),
77                                ('p8=p4^(p4<<4)', bitutil.bitstream2stringLE(p8, lgth, zero_ch)),
78                                ('p16=p8^(p8<<8)', bitutil.bitstream2stringLE(p16, lgth, zero_ch)),
79                                ('p32=p16^(p16<<16)', bitutil.bitstream2stringLE(p32, lgth, zero_ch)),
80                                ('p64=p32^(p32<<32)', bitutil.bitstream2stringLE(p64, lgth, zero_ch)),
81                                ('quote mask', bitutil.bitstream2stringLE(quote_mask, lgth, zero_ch)),
82                                ('new line', bitutil.bitstream2stringLE(control.LF&~quote_mask, lgth, zero_ch))])
83
84
85def europar1():
86  return latex_numeric_scan2('--123----13794----1----456---249371----',
87                             '...........1......1....1.....1.........')
88
89
90
91def parse_decimal_refs(lex, CtCDPI_mask):
92        """Parse and call out decimal  character references.
93
94        >>> demo_refs(" &gt;  &#13;  &#x0a;  ")
95        input data       :  &gt;  &#13;  &#x0a; 
96        entity refs      : __11__________________
97        decimal char refs: _________11___________
98        hex char refs    : _________________11___
99        ref delmask      : _111___1111___11111___
100        errors           : _______________________
101
102        Empty numeric references are reported as errors.
103        >>> demo_refs(" &#;       &#x; ")
104        input data       :  &#;       &#x;
105        entity refs      : ________________
106        decimal char refs: ________________
107        hex char refs    : ________________
108        ref delmask      : _11________111__
109        errors           : ___1__________1__
110
111        Improperly terminated or unterminated references (lacking ";") are also errors.
112        >>> demo_refs("  &gt:  &#456a;  &#xab:  &unterminated")
113        input data       :   &gt:  &#456a;  &#xab:  &unterminated
114        entity refs      : ___111____________________111111111111
115        decimal char refs: __________111_________________________
116        hex char refs    : ____________________11________________
117        ref delmask      : __1111__11111____11111___1111111111111
118        errors           : ______1______1________1_______________1
119"""
120        CallOuts = ref_callouts()
121        Ref2 = lex.RefStart_scope &~ CtCDPI_mask
122        NumRef2 = Ref2 & lex.Hash
123        GenRef2 = Ref2 &~ lex.Hash
124        NumRef3 = bitutil.Advance(NumRef2)
125        HexRef3 = NumRef3 & lex.x
126        DecRef3 = NumRef3 &~ lex.x
127        HexRef4 = bitutil.Advance(HexRef3) 
128        GenRefEnds = bitutil.ScanThru(GenRef2, lex.NameScan)
129        DecRefEnds = bitutil.ScanThru(DecRef3, lex.Digit)
130        HexRefEnds = bitutil.ScanThru(HexRef4, lex.Hex)
131        # Error checks
132        # At least one digit required for DecRef, one hex digit for HexRef.
133        Error = DecRef3 &~ lex.Digit
134        # Semicolon terminator required (also covers unterminated at EOF).
135        Error |= (GenRefEnds | DecRefEnds | HexRefEnds) &~ lex.Semicolon
136        CallOuts.GenRefs = GenRefEnds - GenRef2
137        CallOuts.DecRefs = DecRefEnds - DecRef3
138        CallOuts.HexRefs = HexRefEnds - HexRef4
139        # Mark references for deletion, but leave the trailing semicolon as
140        # the point for insertion of the "expansion" text (most often a
141        # single character).
142        CallOuts.delmask = (GenRefEnds | DecRefEnds | HexRefEnds) - lex.RefStart
143        CallOuts.error = Error
144        return CallOuts
145
146class tag_callouts:
147        ElemNames = 0
148        AttNames = 0
149        AttVals = 0
150        Tags = 0
151        EmptyTagEnds = 0
152        EndTags = 0
153        error = 0
154
155def demo_decimal_refs(u8data):
156        lgth = len(u8data)
157        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
158        (u8, control, lex) = byteclass.classify_bytes(bit)
159        c0 = lex.RefStart
160        c1 = bitutil.Advance(c0)
161        e0 = c1 &~ lex.Hash
162        c2 = bitutil.Advance(c1 & ~e0)
163        e1 = c2 &~ lex.Digit
164        c3 = bitutil.ScanThru(c2 & ~e1, lex.Digit)
165        e2 = c3 & ~lex.Semicolon
166        c4 = c3 &~ e2
167        e = e0 | e1 | e2
168        return bitutil.latex_streams([('source data $\\vartriangleright$', u8data), 
169                              ('$M_0$', bitutil.bitstream2string(c0, lgth, zero_ch)),
170                              ('$M_1 = n(M_0)$', bitutil.bitstream2string(c1, lgth, zero_ch)),
171                              ('$E_0 = M_1 \\wedge \\neg $\\verb:[#]:', bitutil.bitstream2string(e0, lgth, zero_ch)),
172                              ('$M_2 = n(M_1 \\wedge \\neg  E_0)$', bitutil.bitstream2string(c2, lgth, zero_ch)),
173                              ('$E_1 = M_2 \\wedge \\neg  D$', bitutil.bitstream2string(e1, lgth, zero_ch)),
174                              ('$M_3 = s(M_2 \\wedge \\neg  E_1, D)$', bitutil.bitstream2string(c3, lgth, zero_ch)),
175                              ('$E_2 = M_1 \\wedge \\neg  $\\verb:[;]:', bitutil.bitstream2string(e2, lgth, zero_ch)),
176                              ('$M_4 = M_3 \\wedge \\neg  E_2$', bitutil.bitstream2string(c4, lgth, zero_ch)),
177                              ('$E = E0 | E1 | E_2$', bitutil.bitstream2string(e, lgth, zero_ch))])
178
179
180
181def demo_stags(u8data):
182        lgth = len(u8data)
183        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
184        (u8, control, lex) = byteclass.classify_bytes(bit)
185        m0 = lex.LAngle
186        m1 = bitutil.Advance(m0)
187        callouts = tag_callouts()
188       
189        # Delimiters for scans.
190        DQuoteScan = ~(lex.DQuote | lex.LAngle) & EOF_mask
191        SQuoteScan = ~(lex.SQuote | lex.LAngle) & EOF_mask
192        AttListDelim = lex.Slash | lex.RAngle
193       
194        # Start the parallel parsing by inspecting the character
195        # after the opening "<" of a tag.
196        LAngleFollow = lex.LAngle_scope
197        ElemNamePositions = LAngleFollow & ~lex.Slash
198        EndTagSeconds = LAngleFollow & lex.Slash
199       
200        # Start Tag/Empty Element Tag Parsing
201
202        # Advance all cursors by scanning through the tag name.
203        ElemNameFollows = bitutil.ScanThru(ElemNamePositions, lex.NameScan)
204        m2 = ElemNameFollows
205        # Must have at least one name character for a legal start tag.
206        # Mark any occurrences of null names as errors.
207        ParseError = ElemNamePositions & ElemNameFollows
208        callouts.ElemNames = ElemNameFollows - ElemNamePositions
209       
210        # Initialize the accumulators for attribute name and value positions.
211        AttNameStarts = 0 
212        AttNameFollows = 0
213        EqToCheck = 0
214        AttValStarts = 0
215        AttValEnds = 0
216        AttValFollows = 0
217
218        # After the element name, there may or may not be an attlist.
219        AfterWS = bitutil.ScanThru(ElemNameFollows, lex.WS)
220        m3 = AfterWS
221        AttListEnd = AfterWS & AttListDelim
222        AttNameStart1 = AfterWS & ~AttListDelim
223        # At least one WS character is required between ElemNames and AttNames.
224        ParseError |= ElemNameFollows & AttNameStart1
225        AttNameStart = AttNameStart1
226        #
227        # The following loop iterates through attributes within a start tag.
228        # Because all start tags are processed in parallel, the number of
229        # iterations is the maximum number of attributes found in any one
230        # start tag, plus one.
231       
232        #while AttNameStart:
233        AttNameStarts |= AttNameStart
234        AttNameFollow1 = bitutil.ScanThru(AttNameStart, lex.NameScan)
235        AttNameFollows |= AttNameFollow1
236        # Scan through WS to the expected '=' delimiter.
237        EqExpected1 = bitutil.ScanThru(AttNameFollow1, lex.WS)
238        EqToCheck |= EqExpected1
239        AttValPos1 = bitutil.ScanThru(bitutil.Advance(EqExpected1), lex.WS)
240        AttValStarts |= AttValPos1
241        DQuoteAttVal1 = AttValPos1 & lex.DQuote
242        SQuoteAttVal1 = AttValPos1 & lex.SQuote
243        DQuoteAttEnd1 = bitutil.ScanThru(bitutil.Advance(DQuoteAttVal1), DQuoteScan)
244        SQuoteAttEnd1 = bitutil.ScanThru(bitutil.Advance(SQuoteAttVal1), SQuoteScan)
245        AttValEnd1 = DQuoteAttEnd1 | SQuoteAttEnd1
246        AttValEnds |= AttValEnd1
247        AttValFollow1 = bitutil.Advance(AttValEnd1)
248        AttValFollows |= AttValFollow1
249        AfterWS1 = bitutil.ScanThru(AttValFollow1, lex.WS)
250        AttListEnd |= AfterWS1 & AttListDelim
251        AttNameStart2 = AfterWS1 & ~AttListDelim
252        AttNameStarts |= AttNameStart2
253        AttNameFollow2 = bitutil.ScanThru(AttNameStart2, lex.NameScan)
254        AttNameFollows |= AttNameFollow2
255        # Scan through WS to the expected '=' delimiter.
256        EqExpected2 = bitutil.ScanThru(AttNameFollow2, lex.WS)
257        EqToCheck |= EqExpected2
258        AttValPos2 = bitutil.ScanThru(bitutil.Advance(EqExpected2), lex.WS)
259        AttValStarts |= AttValPos2
260        DQuoteAttVal2 = AttValPos2 & lex.DQuote
261        SQuoteAttVal2 = AttValPos2 & lex.SQuote
262        DQuoteAttEnd2 = bitutil.ScanThru(bitutil.Advance(DQuoteAttVal2), DQuoteScan)
263        SQuoteAttEnd2 = bitutil.ScanThru(bitutil.Advance(SQuoteAttVal2), SQuoteScan)
264        AttValEnd2 = DQuoteAttEnd2 | SQuoteAttEnd2
265        AttValEnds |= AttValEnd2
266        AttValFollow2 = bitutil.Advance(AttValEnd2)
267        AttValFollows |= AttValFollow2
268        AfterWS2 = bitutil.ScanThru(AttValFollow2, lex.WS)
269        AttListEnd |= AfterWS2 & AttListDelim
270        AttNameStart3 = AfterWS2 & ~AttListDelim
271
272        # No more attribute values to process when AttNameStart == 0.
273
274        STagEnds = AttListEnd & lex.RAngle
275        # Mark any "/" characters found as the ends of empty element tags.
276        callouts.EmptyTagMarks = bitutil.Advance(AttListEnd & lex.Slash)
277        callouts.Tags = (STagEnds | callouts.EmptyTagMarks) - ElemNamePositions
278
279        # Check for errors.
280        ParseError |= AttValFollows & AttNameStarts # No intervening WS.
281        ParseError |= AttNameStarts & AttNameFollows # Null AttName
282        ParseError |= EqToCheck & ~lex.Equals # = not found where expected.
283        ParseError |= AttValStarts & ~ (lex.DQuote | lex.SQuote)
284        ParseError |= AttValEnds & ~ (lex.DQuote | lex.SQuote)
285        ParseError |= callouts.EmptyTagMarks & ~lex.RAngle
286
287        # End Tag Parsing
288        EndTagEnds = bitutil.ScanThru(bitutil.ScanThru(bitutil.Advance(EndTagSeconds), lex.NameScan), lex.WS)
289        ParseError |= EndTagEnds & ~lex.RAngle
290        callouts.EndTags = EndTagEnds - EndTagSeconds
291        callouts.error = ParseError
292
293        return bitutil.latex_streams([('source data $\\vartriangleright$', u8data),
294                              ('$N = $ name chars', bitutil.bitstream2string(lex.NameScan, lgth, zero_ch)),
295                              ('$W = $ white space', bitutil.bitstream2string(lex.WS, lgth, zero_ch)),
296                              ('$Q = \\neg$\\verb:[">]:', bitutil.bitstream2string(DQuoteScan, lgth, zero_ch)),
297                              ('$M_0$', bitutil.bitstream2string(m0, lgth, zero_ch)),
298                              ('$M_1 = n(M_0)$', bitutil.bitstream2string(ElemNamePositions, lgth, zero_ch)),
299                              ('$M_{0,7} = s(M_1, N)$', bitutil.bitstream2string(ElemNameFollows, lgth, zero_ch)),
300                              ('$M_{0,8} = s(M_{0,7}, W) \\wedge \\neg$\\verb:[>]:', bitutil.bitstream2string(AttNameStart1, lgth, zero_ch)),
301                              ('$M_{1,1} = s(M_{0,8}, N)$', bitutil.bitstream2string(AttNameFollow1, lgth, zero_ch)),
302                              ('$M_{1,2} = s(M_{1,1}, W) \\wedge$\\verb:[=]:', bitutil.bitstream2string(EqExpected1, lgth, zero_ch)),
303                              ('$M_{1,3} = n(M_{1,2})$', bitutil.bitstream2string(bitutil.Advance(EqExpected1), lgth, zero_ch)),
304                              ('$M_{1,4} = s(M_{1,3}, W) \\wedge$\\verb:["]:', bitutil.bitstream2string(AttValPos1, lgth, zero_ch)),
305                              ('$M_{1,5} = n(M_{1,4})$', bitutil.bitstream2string(bitutil.Advance(DQuoteAttVal1), lgth, zero_ch)),
306                              ('$M_{1,6} = s(M_{1,5}, Q) \\wedge$\\verb:["]:', bitutil.bitstream2string(DQuoteAttEnd1, lgth, zero_ch)),
307                              ('$M_{1,7} = n(M_{1,6})$', bitutil.bitstream2string(AttValFollow1, lgth, zero_ch)),
308                              ('$M_{1,8} = s(M_{1,7}, W) \\wedge \\neg$\\verb:[>]:', bitutil.bitstream2string(AttNameStart2, lgth, zero_ch)),
309                              ('$M_{2,1} = s(M_{1,8}, N)$', bitutil.bitstream2string(AttNameFollow2, lgth, zero_ch)),
310                              ('$M_{2,2} = s(M_{2,1}, W) \\wedge$\\verb:[=]:', bitutil.bitstream2string(EqExpected2, lgth, zero_ch)),
311                              ('$M_{2,3} = n(M_{2,2})$', bitutil.bitstream2string(bitutil.Advance(EqExpected2), lgth, zero_ch)),
312                              ('$M_{2,4} = s(M_{2,3}, W) \\wedge$\\verb:["]:', bitutil.bitstream2string(AttValPos2, lgth, zero_ch)),
313                              ('$M_{2,5} = n(M_{2,4})$', bitutil.bitstream2string(bitutil.Advance(DQuoteAttVal2), lgth, zero_ch)),
314                              ('$M_{2,6} = s(M_{2,5}, Q) \\wedge$\\verb:["]:', bitutil.bitstream2string(DQuoteAttEnd2, lgth, zero_ch)),
315                              ('$M_{2,7} = n(M_{2,6})$', bitutil.bitstream2string(AttValFollow2, lgth, zero_ch)),
316                              ('$M_{2,8} = s(M_{2,7}, W) \\wedge \\neg$\\verb:[>]:', bitutil.bitstream2string(AttNameStart3, lgth, zero_ch))])
317
318
319t1 = r"""--<e a= "137">---<el2 a="17" a2="3379">---<x>--"""
320
321
322def add_multiliterals(lex):
323        """Extend the byte-based lexical item streams for some important
324        multibyte literals.
325       
326        >>> demo_multiliterals("  <?php?>  <!--  -->  <![CDATA[  ]]> ")
327        input data  :   <?php?>  <!--  -->  <![CDATA[  ]]>
328        PI_start    : ___1_________________________________
329        CtCD_start  : ____________1__________1_____________
330        EndTag_start: _____________________________________
331        CD_end      : ___________________________________1_
332        DoubleHyphen: ______________1___1__________________
333        PI_end      : ________1____________________________
334        """
335
336        lex.PI_start = lex.LAngle_scope & lex.QMark
337        lex.CtCD_start = lex.LAngle_scope & lex.Exclam
338        lex.CtCDPI_start = lex.PI_start | lex.CtCD_start
339        lex.EndTag_start = lex.LAngle_scope & lex.Slash
340        lex.CD_end = bitutil.Advance(lex.RBracket_scope & lex.RBracket) & lex.RAngle
341        lex.DoubleHyphen = lex.Hyphen_scope & lex.Hyphen
342        lex.PI_end = lex.QMark_scope & lex.RAngle
343        return lex
344
345class CtCDPI_callouts:
346        CD_span = 0
347        Ct_span = 0
348        PI_mask = 0
349        PI_name = 0
350        CtCDPI_mask = 0
351        error = 0
352        PI_starts = 0
353        PI_ends = 0
354        Ct_starts = 0
355        Ct_ends = 0
356        CD_starts = 0
357        CD_ends = 0
358        CtCDPI_starts = 0
359        PI_name_ends = 0
360       
361
362def parse_CtCDPI(lex, EOF_mask):
363        callouts = CtCDPI_callouts()
364        # Scanning streams
365        CtCDPI_scan = ~lex.CtCDPI_start & EOF_mask
366        Ct_end_scan = ~lex.DoubleHyphen & EOF_mask
367        CD_end_scan = ~lex.CD_end & EOF_mask
368        PI_end_scan = ~lex.PI_end & EOF_mask
369        #
370        # Initiate the scan
371        CtCDPI_Cursor = 1
372        CtCDPI_Cursor = bitutil.ScanThru(CtCDPI_Cursor, CtCDPI_scan)
373        CtCDPI_Cursor &= EOF_mask
374        while CtCDPI_Cursor:
375                callouts.CtCDPI_starts |= CtCDPI_Cursor
376                PI_Cursor = CtCDPI_Cursor & lex.PI_start
377                CD_Ct_Cursor = bitutil.Advance(CtCDPI_Cursor & ~PI_Cursor)
378                CD_Cursor = CD_Ct_Cursor & lex.LBracket
379                Ct_Cursor = bitutil.Advance(CD_Ct_Cursor & lex.Hyphen) 
380                callouts.PI_starts |= PI_Cursor
381                callouts.CD_starts |= CD_Cursor
382                callouts.Ct_starts |= Ct_Cursor
383                Ct_Cursor = bitutil.Advance(Ct_Cursor)
384                Ct_end_scan |= Ct_Cursor
385                #PI_Cursor = bitutil.ScanThru(PI_Cursor, PI_end_scan)
386                PI_name_end = bitutil.ScanThru( bitutil.Advance(PI_Cursor), lex.NameScan)
387                callouts.PI_name_ends |= PI_name_end
388                callouts.PI_name |= PI_name_end - PI_Cursor
389                PI_Cursor = bitutil.ScanThru(PI_name_end, PI_end_scan)
390                CD_Cursor = bitutil.ScanThru(CD_Cursor, CD_end_scan)
391                Ct_Cursor = bitutil.Advance(bitutil.ScanThru(Ct_Cursor, Ct_end_scan))
392                callouts.PI_ends |= PI_Cursor
393                callouts.CD_ends |= CD_Cursor
394                callouts.Ct_ends |= Ct_Cursor
395                CtCDPI_Cursor = PI_Cursor | CD_Cursor | Ct_Cursor
396                CtCDPI_Cursor = bitutil.ScanThru(CtCDPI_Cursor, CtCDPI_scan)
397                CtCDPI_Cursor &= EOF_mask
398        # End of loop: no remaining CtCDPI_Cursor
399       
400        callouts.CtCDPI_mask |= bitutil.Advance(callouts.CD_ends | callouts.Ct_ends | callouts.PI_ends) - callouts.CtCDPI_starts
401        callouts.error = callouts.Ct_ends & ~lex.RAngle | callouts.Ct_starts & ~ lex.Hyphen
402        callouts.error |= bitutil.Advance(callouts.PI_name_ends & ~ lex.WS) & ~ lex.PI_end
403        # If any of the Comment, CDATA or PI markups are unterminated, it is an error.
404        callouts.error |= callouts.CtCDPI_mask &~ EOF_mask
405        return callouts
406
407
408def demo_CtCDPI(u8data):
409        lgth = len(u8data)
410        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
411        (u8, control, lex) = byteclass.classify_bytes(bit)
412        lex = add_multiliterals(lex)
413        markup = parse_CtCDPI(lex, EOF_mask)
414        return bitutil.latex_streams([('source data $\\vartriangleright$', u8data), 
415                              ('$M_i$', bitutil.bitstream2string(markup.CtCDPI_starts, lgth)),
416                              ('$M_f$', bitutil.bitstream2string(markup.CD_ends | markup.Ct_ends | markup.PI_ends, lgth)),
417                              ('$m = n(M_f) - m_i$', bitutil.bitstream2string(markup.CtCDPI_mask, lgth)),
418                              ('$M_1 = n(\\verb:[<]:) \\wedge \\neg m$', bitutil.bitstream2string(lex.LAngle_scope & ~ markup.CtCDPI_mask, lgth+1))])
419
420
421ctcdpi = "<!-- <<<< --> <?php 1<2 ?> <t> <![CDATA[ <demo/> ]]>."
422
423def demo_transpose_ascii(u8data):
424        lgth = len(u8data)
425        (bit, EOF_mask) = bitutil.transpose_streams(u8data)
426       
427        # Specify Column Alignemnt
428        latex_table = ""
429       
430        spec_list = [ 'c' for c in range(0,lgth+1) ]
431        spec = '|' + '|'.join(spec_list) + '|'
432
433        table_header = '\\begin{tabular}' 
434        table_header += '{' + spec + '}'
435        table_header +=  '\\hline' 
436        table_header += '\n' 
437       
438        latex_table += table_header
439       
440        # Single character per column
441        chars_row = '$T$' 
442        chars = list(u8data)
443        chars_row += ' & ' + ' & '.join(chars) + ' '
444        chars_row += '\\\\ \\hline' 
445        chars_row += '\n'
446       
447        latex_table += chars_row
448       
449        # ASCII
450        ascii_row = 'ASCII'
451        bits = []
452       
453        temp = [ (bin(ord(u8data[i]))).lstrip('-0b') for i in range(0,lgth) ] # strip 0b       
454       
455        for i in range(0,lgth):
456          zeroes = ''
457          for j in range(0,8-len(temp[i])):
458            zeroes += '0'
459          bits.append(zeroes + temp[i])
460
461 
462#        alerts = []     
463#       for k in range(0,lgth):
464#           temp = list(bits[k])
465#           
466#           alert = ''
467#           for b in range(0,len(temp)):
468#             alert += '{\color<' + str(b) + '>{blue}' + temp[b] + '}'
469#           alerts.append(alert)         
470#       ascii_row += ' & ' + "&".join(alerts)
471
472        ascii_row += ' & ' + ' & '.join(bits) 
473
474        ascii_row +=  ' \\\\ \\hline'
475        ascii_row += '\n'
476       
477        latex_table += ascii_row
478       
479        # 8
480        next_stream_row = ''
481        for i in range(0,8):
482           next_stream_row = '$B_' + '{' + str(i) + '}' + '$ '
483           
484           for j in range(0,lgth):
485             next_stream_row += (' & ' + bits[j][i])
486             
487           latex_table += next_stream_row 
488           latex_table += ' \\\\ \\hline'
489           latex_table += '\n'
490       
491        table_footer = '\\end{tabular}'
492        latex_table += table_footer 
493       
494        return latex_table
495
496if __name__ == "__main__":
497        print latex_csv_parse('1996,"Jeep","Grand","SELL!\nair"\n')
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
Note: See TracBrowser for help on using the repository browser.