source: proto/PDF/pdf_demo.py @ 5322

Last change on this file since 5322 was 2667, checked in by bhull, 7 years ago

Various bug fixes and improvements

File size: 24.1 KB
RevLine 
[2667]1# pdf_demo.py -
2#
3# (c) 2012 Robert D. Cameron, Ken Herdy, Ben Hull
4# All rights reserved.
5# Licensed to International Characters, Inc. under Academic Free License 3.0
6#
7
8import sys
9import pablo
10import optparse
11import config_demo
12
13class Basis_bits():     
14        bit_0 = 0
15        bit_1 = 0
16        bit_2 = 0
17        bit_3 = 0
18        bit_4 = 0
19        bit_5 = 0
20        bit_6 = 0
21        bit_7 = 0
22
23class Lex ():
24        LParen = 0
25        RParen = 0
26        Backslash = 0
27        Percent = 0
28        Slash = 0
29        Regular = 0
30        LAngle = 0
31        RAngle = 0
32        Hex = 0
33        WS = 0
34        Digit = 0
35        Sign = 0
36        Period = 0
37        EOL = 0
38        RBracket = 0
39        LBracket = 0
40        Hash = 0
41        CR = 0
42        LF = 0
43        Special = 0
44       
45class Escaped_Callouts ():
46        UELParen = 0
47        UERParen = 0
48        escapes = 0
49        escaped = 0
50
51class Comments_Callouts() :
52        mask = 0
53
54class LiteralStrings_Callouts() :
55        starts = 0
56        ends = 0
57        escapes = 0
58        carriage_returns = 0
59        mask = 0
60        error = 0
61
62class Marker() :
63        mask = 0
64        starts = 0
65        others = 0
66
67class Names_Callouts() :
68        starts = 0
69        follows = 0
70        escapes = 0
71
72class HexStrings_Callouts() :
73        starts = 0
74        ends = 0
75        error = 0
76        hex = 0
77
78class Numeric_Callouts() :
79        starts = 0
80        follows = 0
81        error = 0
82
83class Keywords_Callouts() :
84        starts = 0
85        ends = 0
86       
87class SpecialChars_Callouts() :
88        starts = 0
89        follows = 0
90
91class WS_Or_Comment () :
92        mask = 0       
93
94def Classify_bytes(basis_bits, lex): 
95        temp1 = (basis_bits.bit_0 | basis_bits.bit_1)
96        temp2 = (basis_bits.bit_2 &~ basis_bits.bit_3)
97        temp3 = (temp2 &~ temp1)
98        temp4 = (basis_bits.bit_4 &~ basis_bits.bit_5)
99        temp5 = (basis_bits.bit_6 | basis_bits.bit_7)
100        temp6 = (temp4 &~ temp5)
101        lex.LParen = (temp3 & temp6)
102        temp7 = (basis_bits.bit_7 &~ basis_bits.bit_6)
103        temp8 = (temp4 & temp7)
104        lex.RParen = (temp3 & temp8)
105        temp9 = (basis_bits.bit_1 &~ basis_bits.bit_0)
106        temp10 = (basis_bits.bit_3 &~ basis_bits.bit_2)
107        temp11 = (temp9 & temp10)
108        temp12 = (basis_bits.bit_4 & basis_bits.bit_5)
109        temp13 = (temp12 &~ temp5)
110        lex.Backslash = (temp11 & temp13)
111        temp14 = (temp5 &~ temp7)
112        temp15 = (temp4 &~ temp14)
113        temp16 = (temp3 & temp15)
114        temp17 = (basis_bits.bit_2 & basis_bits.bit_3)
115        temp18 = (temp17 &~ temp1)
116        temp19 = (temp18 & temp13)
117        temp20 = (temp16 | temp19)
118        temp21 = (basis_bits.bit_6 &~ basis_bits.bit_7)
119        temp22 = (temp12 & temp21)
120        temp23 = (temp18 & temp22)
121        temp24 = (temp20 | temp23)
122        temp25 = (basis_bits.bit_6 & basis_bits.bit_7)
123        temp26 = (temp4 & temp25)
124        temp27 = (temp11 & temp26)
125        temp28 = (temp24 | temp27)
126        temp29 = (temp12 & temp7)
127        temp30 = (temp11 & temp29)
128        temp31 = (temp28 | temp30)
129        temp32 = (temp9 & temp17)
130        temp33 = (temp32 & temp26)
131        temp34 = (temp31 | temp33)
132        temp35 = (temp32 & temp29)
133        temp36 = (temp34 | temp35)
134        temp37 = (basis_bits.bit_5 &~ basis_bits.bit_4)
135        temp38 = (temp37 & temp7)
136        temp39 = (temp3 & temp38)
137        temp40 = (temp36 | temp39)
138        temp41 = (temp12 & temp25)
139        temp42 = (temp3 & temp41)
140        lex.Special = (temp40 | temp42)
141        lex.Percent = (temp3 & temp38)
142        lex.Period = (temp3 & temp22)
143        lex.LAngle = (temp18 & temp13)
144        lex.RAngle = (temp18 & temp22)
145        lex.LBracket = (temp11 & temp26)
146        lex.RBracket = (temp11 & temp29)
147        lex.Slash = (temp3 & temp41)
148        temp43 = (basis_bits.bit_2 | basis_bits.bit_3)
149        temp44 = (temp1 | temp43)
150        temp45 = (temp4 & temp21)
151        temp46 = (temp29 | temp45)
152        lex.EOL = (temp46 &~ temp44)
153        temp47 = (basis_bits.bit_4 | basis_bits.bit_5)
154        temp48 = (temp47 | temp5)
155        temp49 = (temp44 | temp48)
156        temp50 = (temp13 &~ temp44)
157        temp51 = (temp49 &~ temp50)
158        temp52 = (temp29 &~ temp44)
159        temp53 = (temp51 &~ temp52)
160        temp54 = (temp45 &~ temp44)
161        temp55 = (temp53 &~ temp54)
162        temp56 = (temp8 &~ temp44)
163        temp57 = (temp55 &~ temp56)
164        temp58 = (temp3 &~ temp48)
165        temp59 = (temp57 &~ temp58)
166        lex.WS = (~temp59)
167        temp60 = (basis_bits.bit_5 | basis_bits.bit_6)
168        temp61 = (basis_bits.bit_4 & temp60)
169        lex.Digit = (temp18 &~ temp61)
170        temp62 = (temp29 | temp26)
171        lex.Sign = (temp3 & temp62)
172        temp63 = (temp9 &~ temp43)
173        temp64 = (temp63 &~ basis_bits.bit_4)
174        temp65 = (~temp25)
175        temp66 = ((basis_bits.bit_5 & temp65)|(~(basis_bits.bit_5) & temp5))
176        temp67 = (temp64 & temp66)
177        temp68 = (lex.Digit | temp67)
178        temp69 = (temp9 & temp2)
179        temp70 = (temp69 &~ basis_bits.bit_4)
180        temp71 = (temp70 & temp66)
181        lex.Hex = (temp68 | temp71)
182        temp72 = (temp25 &~ temp47)
183        lex.Hash = (temp3 & temp72)
184        lex.CR = (temp29 &~ temp44)
185        lex.LF = (temp45 &~ temp44)
186        lex.Regular = ~lex.Special&~lex.WS
187
188def simd_const_4(hexdigit, EOF_mask):
189        lgth = pablo.count_leading_zeroes(~EOF_mask)/4
190        return int(hexdigit*(lgth+1),16)&EOF_mask
191
192def Parse_Escaped(lex, escaped_Callouts):
193
194        # Demo only. 'odd' / 'even' stream definitions are Hard coded into the pablo_template_pdf.cpp file.
195        odd = simd_const_4('a',pablo.EOF_mask) 
196        even = simd_const_4('5',pablo.EOF_mask) 
197
198        start = lex.Backslash &~ pablo.Advance(lex.Backslash)
199        even_start = start & even
200       
201        even_final = pablo.ScanThru(even_start, lex.Backslash) 
202        escape = even_final & odd
203        escape_char = even & pablo.SpanUpTo(even_start, even_final)
204       
205        odd_start = start & odd
206        odd_final = pablo.ScanThru(odd_start, lex.Backslash)
207        escape = escape | (odd_final & even)
208        escape_char |= odd & pablo.SpanUpTo(odd_start, odd_final)
209       
210        escaped_Callouts.escapes = escape_char
211        escaped_Callouts.UELParen = lex.LParen &~ escape
212        escaped_Callouts.UERParen = lex.RParen &~ escape
213        escaped_Callouts.escaped = escape
214
215def inc() :
216        global depth
217        depth+=1
218
219def dec() :
220        global depth
221        depth-=1
222
223def lt_zero() :
224        global depth
225        return depth < 0
226
227def gt_zero() :
228        global depth
229        return depth > 0
230
231def is_zero() :
232        global depth
233        return depth==0
234               
235# Parallel version
236# def Parse_LiteralStrings(LParen, RParen, LiteralStrings_Callouts):
237        # unmatched = RParen
238        # pscan = {}
239        # qscan = {}
240        # LiteralStrings_Callouts.closed={}
241        # i = 0
242        # pscan[0] = pablo.ScanTo(pablo.Advance(LParen), LParen | RParen)
243        # qscan[0] = pablo.ScanTo(pablo.Advance(RParen), LParen | RParen)
244        # LiteralStrings_Callouts.mask = (pscan[0] - (LParen)) | pscan[0]
245       
246        # LiteralStrings_Callouts.closed[i] = pscan[i] & RParen
247        # unclosed = pscan[i] & LParen | qscan[i] & RParen
248        # LiteralStrings_Callouts.error = pscan[i] &~ pablo.EOF_mask
249        # all_closed = LiteralStrings_Callouts.closed[i]
250        # while unclosed:
251                # i += 1
252                # pscan[i] = pablo.ScanTo(pablo.Advance(unclosed & LParen), unclosed)
253                # qscan[i] = pablo.ScanTo(pablo.Advance(unclosed & RParen), unclosed)
254                # LiteralStrings_Callouts.mask|=(pscan[i]-(unclosed & LParen)) | pscan[i]
255                # LiteralStrings_Callouts.closed[i] = pscan[i] & RParen #| qscan[i] & LParen
256                # unclosed = pscan[i] & LParen | qscan[i] & RParen
257                # all_closed |= LiteralStrings_Callouts.closed[i]
258                # LiteralStrings_Callouts.error |= pscan[i] &~ pablo.EOF_mask #| ~pablo.atEOF(qscan[i])
259       
260        # LiteralStrings_Callouts.error |= RParen &~ all_closed
261# def Parse_Comments(Percent, lex, Comments_Callouts) :
262        # end = Pablo.ScanTo(Percent, lex.EOL)
263        # Comments_Callouts.mask = end-Percent
264# def Parse_CommentsLiteralStrings(lex, Escaped_Callouts, Marker, Comments_Callouts, LiteralStrings_Callouts) :
265        # Parse_LiteralStrings(Escaped_Callouts.UELParen, Escaped_Callouts.UERParen, LiteralStrings_Callouts)
266        # while (lex.Percent &~ (LiteralStrings_Callouts.mask | Comments_Callouts.mask)) :
267                # Parse_Comments(lex.Percent&~LiteralStrings_Callouts.mask, lex, Comments_Callouts)
268                # if (LiteralStrings_Callouts.mask & Comments_Callouts.mask) :
269                        # Parse_LiteralStrings(Escaped_Callouts.UELP &~ Comments_Callouts.mask, Escaped_Callouts.UERP &~ Comments_Callouts.mask, LiteralStrings_Callouts)
270                # else :
271                        # break
272        # Marker.mask = Comments_Callouts.mask | LiteralStrings_Callouts.mask
273
274def Parse_CommentsLiteralStrings(lex, escaped_Callouts, marker, comments_Callouts, literalStrings_Callouts) :
275        #not entirely sure this code is correct once compiled
276        depth = 0
277        comment_starts=0
278        comment_ends=0
279        scan_characters = escaped_Callouts.UELParen | escaped_Callouts.UERParen | lex.Percent
280        cursor = pablo.ScanToFirst(scan_characters)
281        while pablo.inFile(cursor) :
282                comment_cursor = cursor & lex.Percent
283                string_cursor = cursor & (escaped_Callouts.UELParen|escaped_Callouts.UERParen)
284                if comment_cursor :
285                        comment_starts |=comment_cursor
286                        comment_cursor = pablo.ScanTo(comment_cursor, lex.EOL)
287                        comment_ends |=comment_cursor
288                        cursor = pablo.ScanTo(pablo.Advance(comment_cursor), scan_characters)
289               
290                if string_cursor :
291                        if (string_cursor & escaped_Callouts.UELParen) :
292                                if is_zero():
293                                        literalStrings_Callouts.starts|=string_cursor
294
295                                inc()
296
297                                cursor = pablo.ScanTo(pablo.Advance(string_cursor), escaped_Callouts.UELParen | escaped_Callouts.UERParen)
298                        if (string_cursor & escaped_Callouts.UERParen) :
299
300                                dec()
301
302                                if is_zero():
303                                        literalStrings_Callouts.ends|=string_cursor
304                                        cursor = pablo.ScanTo(pablo.Advance(string_cursor), scan_characters)
305                                elif lt_zero():
306                                        literalStrings_Callouts.error|=string_cursor
307                                        cursor = pablo.ScanTo(pablo.Advance(string_cursor), scan_characters)
308                                else:
309                                        cursor = pablo.ScanTo(pablo.Advance(string_cursor), escaped_Callouts.UELParen | escaped_Callouts.UERParen)
310                                       
311
312        comments_Callouts.mask = pablo.SpanUpTo(comment_starts, comment_ends)
313        literalStrings_Callouts.mask = pablo.InclusiveSpan(literalStrings_Callouts.starts,literalStrings_Callouts.ends)
314        literalStrings_Callouts.escapes = escaped_Callouts.escapes & literalStrings_Callouts.mask
315        literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ escaped_Callouts.escaped
316        marker.mask |= comments_Callouts.mask | literalStrings_Callouts.mask
317        marker.starts |= literalStrings_Callouts.starts
318        marker.others |= literalStrings_Callouts.ends | literalStrings_Callouts.escapes | literalStrings_Callouts.carriage_returns
319
320def Parse_Names(lex, marker, names_Callouts) :
321        names_Callouts.starts =lex.Slash&~marker.mask
322        firstCharacter = pablo.Advance(names_Callouts.starts)
323        names_Callouts.follows = pablo.ScanThru(firstCharacter, lex.Regular)
324        names_Callouts.escapes = (pablo.Advance(pablo.Advance(lex.Hash))&pablo.Advance(lex.Hex)&lex.Hex)&pablo.SpanUpTo(names_Callouts.starts, names_Callouts.follows)
325        marker.mask |=names_Callouts.starts|(firstCharacter&~names_Callouts.follows)
326        marker.starts |= names_Callouts.starts
327        marker.others |= names_Callouts.follows | names_Callouts.escapes
328
329
330def Parse_HexStrings(lex, marker, hexStrings_Callouts) :
331        hexStrings_Callouts.starts = lex.LAngle &~marker.mask
332        hexStrings_Callouts.ends = pablo.ScanThru(pablo.Advance(hexStrings_Callouts.starts),lex.Hex|lex.WS)
333        hexStrings_Callouts.error = hexStrings_Callouts.ends &~ lex.RAngle
334        mask = pablo.InclusiveSpan(hexStrings_Callouts.starts,hexStrings_Callouts.ends)
335        hexStrings_Callouts.hex = lex.Hex & mask
336        marker.mask |= mask
337        marker.starts |= hexStrings_Callouts.starts
338        marker.others |= hexStrings_Callouts.ends | hexStrings_Callouts.hex
339
340def Parse_Numeric(lex, marker, numeric_Callouts) :
341        numeric_characters = (lex.Digit | lex.Period | lex.Sign)
342        numeric_Callouts.starts =(numeric_characters &~ pablo.Advance(lex.Regular)) &~ marker.mask
343        numeric_Callouts.follows =pablo.ScanThru(numeric_Callouts.starts, lex.Regular)
344        marker.mask |= numeric_Callouts.starts
345        marker.starts |= numeric_Callouts.starts
346        marker.others |= numeric_Callouts.follows
347        # aftersign = pablo.Advance(numeric_Callouts.starts & lex.Sign) | (numeric_Callouts.starts &~ lex.Sign)
348        # temp = pablo.ScanThru(aftersign, lex.Digit)
349        # afterperiod = pablo.Advance(temp & lex.Period) | (temp &~ lex.Period)
350        # numeric_Callouts.follows = pablo.ScanThru(afterperiod, lex.Digit)
351        # numeric_Callouts.error = numeric_Callouts.follows &~ (lex.WS | lex.Delimiter)
352        # marker.mask |= numeric_Callouts.starts
353
354def Parse_Keywords(lex, marker, keywords_Callouts) :
355        keywords_Callouts.starts = (lex.Regular &~ pablo.Advance(lex.Regular)) &~ marker.mask
356        keywords_Callouts.follows = pablo.ScanThru(keywords_Callouts.starts, lex.Regular)
357        marker.starts |= keywords_Callouts.starts
358        marker.others |= keywords_Callouts.follows
359       
360def Parse_SpecialChars(lex, marker, specialChars_Callouts) :
361        specialChars_Callouts.starts =  (lex.Special) &~ marker.mask
362        specialChars_Callouts.follows = pablo.Advance(specialChars_Callouts.starts)
363        marker.starts |= specialChars_Callouts.starts
364        marker.others |= specialChars_Callouts.follows
365       
366def scan_to_next(stream) :
367        global position
368        global lgth
369
370        while (stream >>position > 0) :
371                if stream  & 1<<position >0:
372                        return stream&~ 1<<position
373                else :
374                        position+=1
375        position = -1
376        return stream
377def is_done() :
378        if position == -1:
379                return True
380        else:
381                return False
382
383       
384def IsNumberStart(character) :
385        return (ord(character) >= ord('0') and ord(character) <=ord('9')) or character=='-' or character=='+' or character=='.'
386def IsHex(character) :
387        return (ord(character) >= ord('0') and ord(character) <=ord('9')) or (ord(character) >=ord('a') and ord(character) <=ord('f')) or (ord(character) >=ord('A') and ord(character) <= ord('F'))
388def HexValue(character) :
389        if (ord(character) >= ord('0') and ord(character) <=ord('9')):
390                return ord(character) -ord('0')
391        elif (ord(character) >=ord('a') and ord(character) <=ord('f')):
392                return ord(character)-ord('a')+10
393        elif (ord(character) >=ord('A') and ord(character) <= ord('F')):
394                return ord(character)-ord('A')+10
395        else:
396                return -1
397
398def LexName() :
399        #Stream marks any escapes and the follow position
400        #Escapes are marked at the second hex value following the escape character
401        global position
402        global data
403        global stream
404        outstring = ''
405        startpos = position
406        stream = scan_to_next(stream)
407        while IsHex(data[position]):
408                outstring +=data[startpos+1:position-2]
409                value = HexValue(data[position-1])*16 + HexValue(data[position])
410                outstring+=chr(value)
411                startpos=position
412                stream = scan_to_next(stream)
413
414        outstring +=data[startpos+1:position]
415       
416        #Check length if needed
417        #if (mp_doc && mp_doc->m_pdfa_check) {
418        #       if (sz>127) {
419        #               mp_doc->m_pdfa_err.Add(__CZ::e_PDFA1_12_3); // Name with more than 127 bytes
420        #       }
421        #}
422        return outstring
423       
424def LexNumber() :
425        #Error handling done using PDFTron's number parser
426        global position
427        global data
428        global stream
429        startpos = position
430        stream = scan_to_next(stream)
431        numstring = data[startpos:position]
432       
433        #Convert to numeric value and check value if needed
434        #assert(Filters::FilterReader::m_read_proc);
435        #if (Filters::FilterReader::m_read_proc(&m_tmp_buffer.front(), &num)) {
436        #       if (mp_doc && mp_doc->m_pdfa_check) {
437        #               if (num == floor(num) && (num>2147483647.0 || num<-2147483648.0)) {
438        #                       mp_doc->m_pdfa_err.Add(__CZ::e_PDFA1_12_3); // Contains an integer value outside of the allowed range [-2^31, 2^31-1],
439        #               }
440        #       }
441        #}
442        #else {
443        #       num = 0;
444        #       if (mp_doc && mp_doc->m_pdfa_check) {
445        #               mp_doc->m_pdfa_err.Add(__CZ::e_PDFA1_12_3); // Bad number
446        #       }
447        #}
448        return numstring
449       
450       
451       
452def LexLiteralString() :
453        #Stream marks any escapes, any carriage returns, and the end position
454       
455        global position
456        global data
457        global stream
458        outstring = ''
459        startpos = position
460        stream = scan_to_next(stream)
461        while is_done()==False and data[position]!=')':
462                outstring +=data[startpos+1:position]
463                startpos = position
464                if data[position]=='\\': #escape
465                        next_char = data[position+1]
466                        if next_char=='n':
467                                outstring+=chr(0x0A) #linefeed
468                        elif next_char=='r':
469                                outstring+=chr(0x0D) #carriage return
470                        elif next_char=='t':
471                                outstring+=chr(0x09) #horizontal tab
472                        elif next_char=='b':
473                                outstring+=chr(0x08) #backspace
474                        elif next_char=='f':
475                                outstring+=chr(0x0C) #form-feed
476                        elif ord(next_char) >= ord('0') and ord(next_char) <= ord('8'): #Octal character code
477                                val = ord(next_char)-ord('0')
478                                if ord(data[position+2]) >= ord('0') and ord(data[position+2]) <= ord('8'):
479                                        val = val*8 + ord(data[position+2])-ord('0')
480                                        startpos+=1
481                                        if ord(data[position+3]) >= ord('0') and ord(data[position+3]) <= ord('8'):
482                                                val = val*8 + ord(data[position+3])-ord('0')
483                                                startpos+=1
484                                val = val & 0xFF
485                                outstring+=chr(val)
486                        elif ord(next_char)==13: #CR.  Don't output either the CR or the CRLF
487                                if ord(data[position+2]) == 10: #LF
488                                        startpos+=1
489                        elif ord(next_char)==10: #LF.  Don't output.
490                                #do nothing.  hack so that the intended c structure is preserved
491                                position=position
492                        else:
493                                #moved (, ), and \ into default case
494                                outstring+=next_char
495                        startpos+=1
496                else:
497                        #This position is a carriage return.  Convert CR or CRLF to LF.
498                        outstring+=chr(0x0A)
499                        if data[position+1]==chr(0x0A):
500                                startpos+=1
501                stream = scan_to_next(stream)
502       
503        if is_done():
504                return 'Corrupt string'
505                #BASE_ASSERT(false, "Corrupt string");
506       
507
508        outstring +=data[startpos+1:position]
509       
510        #if outstring>=65536:
511                #BASE_WARNING(false, "The implementation limit for the length of string was exceeded");
512       
513        #StringDecrypt(m_tmp_buffer);
514        return outstring
515       
516def LexHexString():
517        #Stream marks all hex characters in the string as well as the end position
518        #Is it worth actually marking the hex characters if whitespace is rare?
519        global position
520        global data
521        global stream
522        outstring = ''
523        stream = scan_to_next(stream)
524        while (IsHex(data[position])):
525                val = HexValue(data[position])*16
526                stream = scan_to_next(stream)
527                if IsHex(data[position]):
528                        val += HexValue(data[position])
529                        stream = scan_to_next(stream)
530                #else:
531                        #if (mp_doc && mp_doc->m_pdfa_check) {
532                        #       mp_doc->m_pdfa_err.Add(__CZ::e_PDFA1_6_1); // Invalid hexadecimal strings used
533                        #}
534                outstring+=chr(val)
535        if data[position]!='>': #The end character might not be a proper closer
536                return 'BASE_ASSERT(false, "Bad String");'
537                #BASE_ASSERT(false, "Bad String");
538        #StringDecrypt(m_tmp_buffer);
539        return outstring
540       
541def LexDefault() :
542        #Handles keywords and some special characters (excluding '(', '[', '<'.  also excluding ')' and '>' that end strings)
543        global position
544        global data
545        global stream
546        startpos = position
547        stream = scan_to_next(stream)
548        outstring = data[startpos:position]
549        if outstring == 'null':
550                return 'NULL OBJECT'
551        elif outstring == 'true':
552                return 'TRUE OBJECT'
553        elif outstring == 'false':
554                return 'FALSE OBJECT'
555        else:
556                return 'RETURN FALSE:'+outstring
557               
558       
559       
560def GenerateOutput(input,options):
561        if options.debug:
562                return GetPrintableString(input)
563        else:
564                return input
565def GetPrintableString(input):
566        outstring =''
567        i=0
568        while i < len(input):
569                if ord(input[i]) >=32 and ord(input[i])<=126:
570                        outstring+=input[i]
571                else:
572                        char_string = str(ord(input[i]))
573                        while len(char_string)<3:
574                                char_string='0'+char_string
575                        outstring+='&'+char_string
576                i+=1
577        return outstring
578
579basis_bits = Basis_bits()
580lex = Lex()
581literalStrings_Callouts = LiteralStrings_Callouts()
582escaped_Callouts = Escaped_Callouts()
583comments_Callouts = Comments_Callouts()
584names_Callouts = Names_Callouts()
585hexStrings_Callouts = HexStrings_Callouts()
586numeric_Callouts = Numeric_Callouts()
587keywords_Callouts = Keywords_Callouts()
588specialChars_Callouts = SpecialChars_Callouts()
589marker = Marker()
590
591global depth
592depth = 0
593
594if __name__ == "__main__":
595
596        option_parser = config_demo.get_option_parser() 
597        options, args = option_parser.parse_args(sys.argv[1:])
598
599        if len(args) != 1:
600                option_parser.print_usage()
601                sys.exit()
602        else:
603                input_file = args[0]
604        global data
605        data = pablo.readfile(input_file)
606
607        global lgth
608        lgth = len(data)
609
610        pablo.EOF_mask = pablo.transpose_streams(data, basis_bits)
611        Classify_bytes(basis_bits, lex)
612        Parse_Escaped(lex, escaped_Callouts)
613        Parse_CommentsLiteralStrings(lex, escaped_Callouts, marker, comments_Callouts, literalStrings_Callouts)
614        Parse_Names(lex, marker, names_Callouts)
615        Parse_HexStrings(lex, marker, hexStrings_Callouts)
616        Parse_Numeric(lex, marker, numeric_Callouts)
617        Parse_Keywords(lex, marker, keywords_Callouts)
618        Parse_SpecialChars(lex, marker, specialChars_Callouts)
619
620       
621       
622       
623        startsStream = marker.starts #literalStrings_Callouts.starts | names_Callouts.starts | hexStrings_Callouts.starts | numeric_Callouts.starts | keywords_Callouts.starts | specialChars_Callouts.starts
624        global stream
625        stream = marker.others #hexStrings_Callouts.hex | literalStrings_Callouts.carriage_returns|literalStrings_Callouts.escapes | names_Callouts.escapes | literalStrings_Callouts.ends | names_Callouts.follows | hexStrings_Callouts.ends | numeric_Callouts.follows | keywords_Callouts.follows | specialChars_Callouts.follows
626        global position
627        position = 0
628        startsStream=scan_to_next(startsStream)
629        while is_done()==False:
630                if data[position] == '/':
631                        print GenerateOutput('LexName:'+LexName(),options)
632                elif data[position]=='(':
633                        print GenerateOutput('LexLiteralString:'+LexLiteralString(),options)
634                elif IsNumberStart(data[position]):
635                        print GenerateOutput('LexNumber:'+LexNumber(),options)
636                elif data[position]=='<':
637                        print GenerateOutput('LexHexString:'+LexHexString(),options)
638                elif data[position]==')':
639                        print GenerateOutput('BASE_ASSERT(false, "\')\' is not matched");',options)
640                        #BASE_ASSERT(false, "\')\' is not matched");
641                elif data[position]=='[':
642                        print GenerateOutput('Array Start',options)
643                        stream = scan_to_next(stream) #to clear the end position. should probably change the bitstreams instead
644                        #Call LexArray
645                else :
646                        print GenerateOutput('LexDefault:'+LexDefault(),options)
647                if is_done()==False:
648                        startsStream = scan_to_next(startsStream)
649               
650               
651        if (options.debug ):
652                pablo.print_aligned_streams([('Input Data', data), 
653                        ('Regular', pablo.bitstream2string(lex.Regular, lgth+1)),
654                        ('String Starts', pablo.bitstream2string(literalStrings_Callouts.starts, lgth+1)),
655                        ('String Escapes', pablo.bitstream2string(literalStrings_Callouts.escapes, lgth+1)),
656                        ('String Carriage Returns', pablo.bitstream2string(literalStrings_Callouts.carriage_returns, lgth+1)),
657                        ('String Ends', pablo.bitstream2string(literalStrings_Callouts.ends, lgth+1)),
658                        ('Names Starts', pablo.bitstream2string(names_Callouts.starts, lgth+1)),                             
659                        ('Names Escapes', pablo.bitstream2string(names_Callouts.escapes, lgth+1)),                           
660                        ('Names Follows', pablo.bitstream2string(names_Callouts.follows, lgth+1)),
661                        ('Hex Strings Starts', pablo.bitstream2string(hexStrings_Callouts.starts, lgth+1)),
662                        ('Hex Strings Hex', pablo.bitstream2string(hexStrings_Callouts.hex, lgth+1)),
663                        ('Hex Strings Ends', pablo.bitstream2string(hexStrings_Callouts.ends, lgth+1)),                       
664                        ('Numeric Starts', pablo.bitstream2string(numeric_Callouts.starts, lgth+1)),
665                        ('Numeric Follows', pablo.bitstream2string(numeric_Callouts.follows, lgth+1)),
666                        ('Keyword Starts', pablo.bitstream2string(keywords_Callouts.starts, lgth+1)),                         
667                        ('Keyword Follows', pablo.bitstream2string(keywords_Callouts.follows, lgth+1)),
668                        ('Special Chars Starts', pablo.bitstream2string(specialChars_Callouts.starts, lgth+1)),
669                        ('Special Chars Follows', pablo.bitstream2string(specialChars_Callouts.follows, lgth+1)),                             
670                        ('Errors', pablo.bitstream2string(literalStrings_Callouts.error | hexStrings_Callouts.error | numeric_Callouts.error, lgth+1))])
671        #else:
672                #print pablo.bitstream2string(literalStrings_Callouts.starts, lgth+1)
673                #print pablo.bitstream2string(literalStrings_Callouts.escapes, lgth+1)
674                #print pablo.bitstream2string(literalStrings_Callouts.carriage_returns, lgth+1)
675                #print pablo.bitstream2string(literalStrings_Callouts.ends, lgth+1)
676                #print pablo.bitstream2string(names_Callouts.starts, lgth+1)
677                #print pablo.bitstream2string(names_Callouts.escapes, lgth+1)
678                #print pablo.bitstream2string(names_Callouts.follows, lgth+1)
679                #print pablo.bitstream2string(hexStrings_Callouts.starts, lgth+1)
680                #print pablo.bitstream2string(hexStrings_Callouts.hex, lgth+1)
681                #print pablo.bitstream2string(hexStrings_Callouts.ends, lgth+1)
682                #print pablo.bitstream2string(numeric_Callouts.starts, lgth+1)
683                #print pablo.bitstream2string(numeric_Callouts.follows, lgth+1)
684                #print pablo.bitstream2string(keywords_Callouts.starts, lgth+1)
685                #print pablo.bitstream2string(keywords_Callouts.follows, lgth+1)
686                #print pablo.bitstream2string(specialChars_Callouts.starts, lgth+1)
687                #print pablo.bitstream2string(specialChars_Callouts.follows, lgth+1)
688                #print pablo.bitstream2string(marker.starts, lgth+1)   
689                #print pablo.bitstream2string(marker.others, lgth+1)   
690
691
692       
693
Note: See TracBrowser for help on using the repository browser.