source: proto/PDF/pdf_demo.py @ 2619

Last change on this file since 2619 was 2618, checked in by bhull, 7 years ago

Prototype changes

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