source: proto/PDF/pdf_demo.py @ 2629

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

Added token output for compiled version

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