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

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

Bug fixes in demo

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