Changeset 2667 for proto/PDF


Ignore:
Timestamp:
Nov 21, 2012, 11:06:40 AM (6 years ago)
Author:
bhull
Message:

Various bug fixes and improvements

Location:
proto/PDF
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/PDF/pablo_template_pdf.cpp

    r2639 r2667  
    2323static int cur_state;
    2424
     25
     26
     27
     28
     29#define has_bit(x) (x != 0)
     30template <class bitblock_t, class scanblock_t>
     31class DualScanner: public Scanner<bitblock_t, scanblock_t> {
     32protected:
     33        const bitblock_t * strm1;
     34        const bitblock_t * strm2;
     35       
     36        int block_count;
     37        int32_t pos;
     38        int32_t blk;
     39        scanblock_t scan_blk1;
     40        scanblock_t scan_blk2;
     41public:
     42
     43        DualScanner(){}
     44        DualScanner(const bitblock_t * s1, const bitblock_t * s2, int bit_block_count) {
     45                init(s1,s2,bit_block_count);
     46        }
     47
     48        IDISA_ALWAYS_INLINE void init(const bitblock_t * s1, const bitblock_t * s2, int bit_block_count) {
     49               
     50                this->strm1     = s1;
     51                this->strm2     = s2;
     52                this->pos = 0;
     53                this->blk = 0;
     54                this->scan_blk1 = *(scanblock_t *)s1;
     55                this->scan_blk2 = *(scanblock_t *)s2;
     56                this->block_count = bit_block_count*sizeof(bitblock_t)/sizeof(scanblock_t);
     57        }
     58
     59        IDISA_ALWAYS_INLINE int32_t scan_to_next1() {
     60                while (this->blk < this->block_count){
     61                        if(has_bit(this->scan_blk1)){
     62                                this->pos = scan_forward_zeroes(this->scan_blk1) + (this->blk * (sizeof(scanblock_t)*8));
     63                                this->scan_blk1 = this->scan_blk1 & (this->scan_blk1-1);  // clear rightmost bit
     64
     65                                return (this->pos);
     66                        }
     67
     68                        this->blk++;
     69                        this->scan_blk1 = *((scanblock_t *)this->strm1 + this->blk);
     70                        this->scan_blk2 = *((scanblock_t *)this->strm2 + this->blk);
     71                };
     72
     73                this->pos = -1;
     74                return (this->pos);
     75        }
     76        IDISA_ALWAYS_INLINE int32_t scan_to_next2() {
     77                while (this->blk < this->block_count){
     78                        if(has_bit(this->scan_blk2)){
     79                                this->pos = scan_forward_zeroes(this->scan_blk2) + (this->blk * (sizeof(scanblock_t)*8));
     80                                this->scan_blk2 = this->scan_blk2 & (this->scan_blk2-1);  // clear rightmost bit
     81
     82                                return (this->pos);
     83                        }
     84
     85                        this->blk++;
     86                        this->scan_blk1 = *((scanblock_t *)this->strm1 + this->blk);
     87                        this->scan_blk2 = *((scanblock_t *)this->strm2 + this->blk);
     88                };
     89
     90                this->pos = -1;
     91                return (this->pos);
     92        }
     93       
     94       
     95
     96        IDISA_ALWAYS_INLINE bool is_done() {return (-1==this->pos);}
     97        IDISA_ALWAYS_INLINE int32_t get_pos() const {return this->pos;}
     98
     99        //static const int32_t BLOCK_COUNT = 16*sizeof(bitblock_t)/sizeof(scanblock_t);
     100
     101};
     102#undef has_bit
     103
     104
     105
    25106static inline void inc() {
    26107        depth++;
    27108}
    28109
     110
    29111static inline void dec() {
    30112        depth--;
    31113}
    32 #define scan_to_next_and_test(scanner, state) \
    33         scanner.scan_to_next();\
    34         if (scanner.is_done()) {\
     114#define scan_to_next_and_test1(scanner, state) \
     115        (scanner).scan_to_next1();\
     116        if ((scanner).is_done()) {\
    35117                cur_state=state;\
    36118                return;\
    37119                }\
    38120               
     121#define scan_to_next_and_test2(scanner, state) \
     122        (scanner).scan_to_next2();\
     123        if ((scanner).is_done()) {\
     124                cur_state=state;\
     125                return;\
     126                }\
    39127       
    40         //if (scanner.is_done())
     128        //if ((*scanner).is_done())
    41129
    42130static BitBlock lt_zero() {
     
    89177#define LOOKAHEAD_BLOCKS 1
    90178#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
    91 #define SEGMENT_BLOCKS  4
     179#define SEGMENT_BLOCKS  16
    92180#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
    93181#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
     
    198286}       
    199287
    200 void postprocess_do_block(Marker & marker, uint8_t * src_buffer,  int block_base) {
     288void postprocess_do_block(BitBlock * starts, BitBlock * others, uint8_t * src_buffer,  int block_base, int bit_block_count, bool final) {
    201289               
    202290                int ch;
    203                 ForwardScanner<BitBlock, ScanWord> scanner;
    204                 ForwardScanner<BitBlock, ScanWord> starts_scanner(&(marker.starts));
    205                 ForwardScanner<BitBlock, ScanWord> others_scanner(&(marker.others));
    206                 scanner = starts_scanner;
     291                DualScanner<BitBlock, ScanWord> dscanner(starts, others, bit_block_count);
     292
    207293                switch(cur_state){
    208294                        case 0:
    209                                 scanner = starts_scanner;
    210295                                goto pos0;
    211296                        case 1:
    212                                 scanner = others_scanner;
    213297                                goto pos1;
    214298                        case 2:
    215                                 scanner = others_scanner;
    216299                                goto pos2;
    217300                        case 3:
    218                                 scanner = others_scanner;
    219301                                goto pos3;
    220302                        case 4:
    221                                 scanner = others_scanner;
    222303                                goto pos4;
    223304                        case 5:
    224                                 scanner = others_scanner;
    225305                                goto pos5;
    226306                        case 6:
    227                                 scanner = others_scanner;
    228307                                goto pos6;
    229308                        case 7:
    230                                 scanner = others_scanner;
    231309                                goto pos7;
    232310                        case 8:
    233                                 scanner = others_scanner;
    234311                                goto pos8;
    235312                        case 9:
    236                                 scanner = others_scanner;
    237313                                goto pos9;
    238314                        case 10:
    239                                 scanner = starts_scanner;
    240315                                goto pos10;
     316                        case 11:
     317                                goto pos11;
    241318                }
    242319
    243320               
    244                 pos0: scan_to_next_and_test(scanner, 0);
    245                 while(!scanner.is_done()) {
    246                         switch (src_buffer[block_base+scanner.get_pos()])
     321                pos0: scan_to_next_and_test1(dscanner, 0);
     322                while(!(dscanner).is_done()) {
     323                        switch (src_buffer[block_base+(dscanner).get_pos()])
    247324                        {
    248325                                case '/':
    249326                                        cout<<"LexName:";
    250327                                        outstring = "";
    251                                         startpos = block_base+scanner.get_pos();
    252                                         scanner.set_strm(&(marker.others));
    253                                         scanner.move_to(scanner.get_pos());
    254                                         pos1: scan_to_next_and_test(scanner, 1);
    255                                        
    256                                        
    257                                         ch = src_buffer[block_base+scanner.get_pos()];
     328                                        startpos = block_base+(dscanner).get_pos();
     329                                        pos1: scan_to_next_and_test2(dscanner, 1);
     330                                       
     331                                       
     332                                        ch = src_buffer[block_base+(dscanner).get_pos()];
    258333                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
    259                                                 outstring+=get_substring(src_buffer,startpos+1, scanner.get_pos()-2);
    260                                                 startpos = block_base+scanner.get_pos();
     334                                                outstring+=get_substring(src_buffer,startpos+1, block_base+(dscanner).get_pos()-2);
     335                                                startpos = block_base+(dscanner).get_pos();
    261336                                                if (ch<='9')            val =  ch - '0';
    262337                                                else if (ch<='F')       val = 10 + ch - 'A';
    263338                                                else val = 10 + ch - 'a';
    264                                                 ch = src_buffer[block_base+scanner.get_pos()-1];
     339                                                ch = src_buffer[block_base+(dscanner).get_pos()-1];
    265340                                               
    266341                                                if (ch<='9')            val = val + 16*(ch - '0');
     
    268343                                                else val = val+ 16*(10 + ch - 'a');
    269344                                                outstring+=val;
    270                                                 scanner.scan_to_next();
    271                                                 ch = src_buffer[block_base+scanner.get_pos()];
    272                                         }
    273                                         outstring+=get_substring(src_buffer,startpos+1,block_base+scanner.get_pos());
    274                                         scanner.set_strm(&(marker.starts));
    275                                         scanner.move_to(scanner.get_pos()-1);
     345                                                pos11: scan_to_next_and_test2(dscanner, 11);
     346                                                ch = src_buffer[block_base+(dscanner).get_pos()];
     347                                        }
     348                                        outstring+=get_substring(src_buffer,startpos+1,block_base+(dscanner).get_pos());
    276349                                        cout<<outstring<<endl;
    277350                       
     
    281354                                        cout<<"LexLiteralString:";
    282355                                        outstring="";
    283                                         startpos = block_base+scanner.get_pos();
    284                                         scanner.set_strm(&(marker.others));
    285                                         scanner.move_to(scanner.get_pos());
    286                                         pos2: scan_to_next_and_test(scanner, 2);
    287                                         while (!scanner.is_done()) {
    288                                                 outstring+=get_substring(src_buffer, startpos+1,block_base+scanner.get_pos());
    289                                                 if (src_buffer[block_base+scanner.get_pos()]==')') {
     356                                        startpos = block_base+(dscanner).get_pos();
     357                                       
     358                                        //IMPLEMENT SEPARATE FINAL FUNCTION
     359                                        pos2: if (final) {
     360                                                dscanner.scan_to_next2();
     361                                                if (dscanner.is_done()) {
     362                                                        cout << "Corrupt string"<<endl;
     363                                                        return;
     364                                                }
     365                                        }
     366                                        else {
     367                                                scan_to_next_and_test2(dscanner, 2);
     368                                        }
     369                                        while (!(dscanner).is_done()) {
     370                                                outstring+=get_substring(src_buffer, startpos+1,block_base+(dscanner).get_pos());
     371                                                if (src_buffer[block_base+(dscanner).get_pos()]==')') {
    290372                                                        cout<<outstring<<endl;
    291373                                                        break;
    292374                                                }
    293                                                 startpos=block_base+scanner.get_pos();
    294                                                 if (src_buffer[block_base+scanner.get_pos()]=='\\') {
    295                                                         ch = src_buffer[block_base+scanner.get_pos()+1];
     375                                                startpos=block_base+(dscanner).get_pos();
     376                                                if (src_buffer[block_base+(dscanner).get_pos()]=='\\') {
     377                                                        ch = src_buffer[block_base+(dscanner).get_pos()+1];
    296378                                                        switch (ch) {
    297379                                                                case 'n':
     
    310392                                                                        outstring+=0x0C;
    311393                                                                        break;
    312                                                                 case 0: case 1:
    313                                                                 case 2: case 3:
    314                                                                 case 4: case 5:
    315                                                                 case 6: case 7:
     394                                                                case '0': case '1':
     395                                                                case '2': case '3':
     396                                                                case '4': case '5':
     397                                                                case '6': case '7':
    316398                                                                        val = ch - '0';
    317                                                                         if ((src_buffer[block_base+scanner.get_pos()+2]) >= '0' && (src_buffer[block_base+scanner.get_pos()+2]<='8')) {
    318                                                                                 val = val*8 + src_buffer[block_base+scanner.get_pos()+2]-'0';
     399                                                                        if ((src_buffer[block_base+(dscanner).get_pos()+2]) >= '0' && (src_buffer[block_base+(dscanner).get_pos()+2]<='8')) {
     400                                                                                val = val*8 + src_buffer[block_base+(dscanner).get_pos()+2]-'0';
    319401                                                                                startpos+=1;
    320                                                                                 if ((src_buffer[block_base+scanner.get_pos()+3]) >= '0' && (src_buffer[block_base+scanner.get_pos()+3]<='8')) {
    321                                                                                         val = val*8 + src_buffer[block_base+scanner.get_pos()+3]-'0';
     402                                                                                if ((src_buffer[block_base+(dscanner).get_pos()+3]) >= '0' && (src_buffer[block_base+(dscanner).get_pos()+3]<='8')) {
     403                                                                                        val = val*8 + src_buffer[block_base+(dscanner).get_pos()+3]-'0';
    322404                                                                                        startpos+=1;
    323405                                                                                }
     
    327409                                                                        break;
    328410                                                                case 13:
    329                                                                         if (src_buffer[block_base+scanner.get_pos()+2]==10) {
     411                                                                        if (src_buffer[block_base+(dscanner).get_pos()+2]==10) {
    330412                                                                                startpos+=1;
    331413                                                                        }
     
    342424                                                else {
    343425                                                        outstring+=0x0A;
    344                                                         if (src_buffer[block_base+scanner.get_pos()+1]==0x0a) {
     426                                                        if (src_buffer[block_base+(dscanner).get_pos()+1]==0x0a) {
    345427                                                                startpos+=1;
    346428                                                        }
    347429                                                }
    348                                                 //CHANGE FOR FINAL BLOCK
    349                                                 pos3: scan_to_next_and_test(scanner, 3);
    350                                         }
    351                                        
    352                                         if (scanner.is_done()) {
     430                                               
     431                                               
     432                                                //IMPLEMENT SEPARATE FINAL FUNCTION
     433                                                pos3: if (final) {
     434                                                        dscanner.scan_to_next2();
     435                                                        if (dscanner.is_done()) {
     436                                                                cout << "Corrupt string"<<endl;
     437                                                                return;
     438                                                        }
     439                                                }
     440                                                else {
     441                                                        scan_to_next_and_test2(dscanner, 3);
     442                                                }
     443                                        }
     444                                       
     445                                        if ((dscanner).is_done()) {
    353446                                                cout << "Corrupt string"<<endl;
    354447                                        }
    355                                         scanner.set_strm(&(marker.starts));
    356                                         scanner.move_to(scanner.get_pos()-1);
    357448                                        break;
    358449                                case '0': case '1':
     
    365456                                        cout << "LexNumber:";
    366457                                               
    367                                         startpos = block_base+scanner.get_pos();
    368                                         scanner.set_strm(&(marker.others));
    369                                         scanner.move_to(scanner.get_pos());
    370                                         pos4: scan_to_next_and_test(scanner, 4);
    371                                        
    372                                         outstring=get_substring(src_buffer,startpos,block_base+scanner.get_pos());
    373                                         scanner.set_strm(&(marker.starts));
    374                                         scanner.move_to(scanner.get_pos()-1);
     458                                        startpos = block_base+(dscanner).get_pos();
     459                                        pos4: scan_to_next_and_test2(dscanner, 4);
     460                                       
     461                                        outstring=get_substring(src_buffer,startpos,block_base+(dscanner).get_pos());
    375462                                        cout<<outstring<<endl;
    376463                                        break;
     
    378465                                        cout << "LexHexString:";
    379466                                        outstring="";
    380                                         scanner.set_strm(&(marker.others));
    381                                         scanner.move_to(scanner.get_pos());
    382                                         pos5: scan_to_next_and_test(scanner, 5);
    383                                         ch = src_buffer[block_base+scanner.get_pos()];
     467                                        pos5: scan_to_next_and_test2(dscanner, 5);
     468                                        ch = src_buffer[block_base+(dscanner).get_pos()];
    384469                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
    385470                                                if (ch<='9')            val =  16*(ch - '0');
    386471                                                else if (ch<='F')       val = 16*(10 + ch - 'A');
    387472                                                else val = 16*(10 + ch - 'a');
    388                                                 pos6: scan_to_next_and_test(scanner, 6);
    389                                                 ch = src_buffer[block_base+scanner.get_pos()];
     473                                                pos6: scan_to_next_and_test2(dscanner, 6);
     474                                                ch = src_buffer[block_base+(dscanner).get_pos()];
    390475                                                if (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
    391476                                                        if (ch<='9')            val +=  (ch - '0');
     
    393478                                                        else val += 10 + ch - 'a';
    394479                                                       
    395                                                         //CHANGE FOR FINAL BLOCK (If scanner.is_done(), BASE_ASSERT)
    396                                                         pos7: scan_to_next_and_test(scanner, 7);
     480                                                        //IMPLEMENT SEPARATE FINAL FUNCTION
     481                                                        pos7: if (final) {
     482                                                                dscanner.scan_to_next2();
     483                                                                if (dscanner.is_done()) {
     484                                                                        cout<<"BASE_ASSERT(false, \"Bad String\");"<<endl;
     485                                                                        return;
     486                                                                }
     487                                                        }
     488                                                        else {
     489                                                                 scan_to_next_and_test2(dscanner, 7);   
     490                                                        }
    397491                                                       
    398492                                                       
    399                                                         ch = src_buffer[block_base+scanner.get_pos()];
     493                                                       
     494                                                       
     495                                                        ch = src_buffer[block_base+(dscanner).get_pos()];
    400496                                                }
    401497                                                outstring+=val;
     
    407503                                        {
    408504                                                cout<<outstring<<endl;
    409                                         }
    410                                         scanner.set_strm(&(marker.starts));
    411                                         scanner.move_to(scanner.get_pos()-1);                                   
     505                                        }                                       
    412506                                        break;
    413507                                case ')':
    414                                         cout << "BASE_ASSERT(false, \"')' is not matched\");"<<endl;//"BASE_ASSERT(false, "\')\' is not matched");"
     508                                        cout << "BASE_ASSERT(false, \"')' is not matched\");"<<endl;
    415509                                        break;
    416510                                case '[':
    417511                                        cout<<"Array Start"<<endl;
    418                                         scanner.set_strm(&(marker.others));
    419                                         scanner.move_to(scanner.get_pos());
    420                                         pos8: scan_to_next_and_test(scanner, 8);
    421                                         scanner.set_strm(&(marker.starts));
    422                                        
    423                                         scanner.move_to(scanner.get_pos()-1);
     512                                        pos8: scan_to_next_and_test2(dscanner, 8);
    424513                                        break;
    425514                                default:
    426515                                        cout<<"LexDefault:";
    427                                         startpos = block_base+scanner.get_pos();
    428                                         scanner.set_strm(&(marker.others));
    429                                         scanner.move_to(scanner.get_pos());
    430                                         pos9: scan_to_next_and_test(scanner, 9);
    431                                         outstring = get_substring(src_buffer,startpos,block_base+scanner.get_pos());
     516                                        startpos = block_base+(dscanner).get_pos();
     517                                        pos9: scan_to_next_and_test2(dscanner, 9);
     518                                        outstring = get_substring(src_buffer,startpos,block_base+(dscanner).get_pos());
    432519                                        if (outstring=="null") {
    433520                                                cout << "NULL OBJECT"<<endl;
     
    439526                                                cout << "RETURN FALSE:"<<outstring<<endl;
    440527                                        }
    441                                         scanner.set_strm(&(marker.starts));
    442                                         scanner.move_to(scanner.get_pos()-1);
    443528                                       
    444529                                }
    445530                               
    446531
    447                         if(!scanner.is_done()) {
    448                                 pos10: scan_to_next_and_test(scanner, 10);
     532                        if(!(dscanner).is_done()) {
     533                                pos10: scan_to_next_and_test1(dscanner, 10);
     534
    449535                        }
    450536                }
     
    480566        int padding_read = 0;
    481567        int remaining = 0;
    482 
     568BitBlock starts[SEGMENT_SIZE];
     569BitBlock others[SEGMENT_SIZE];
    483570  /* Tracked for post processing */
    484571        //int buffer_base=0;
     
    562649                  @block_stmts
    563650
    564       postprocess_do_block(marker, src_buffer,  block_base);
     651      starts[blk]=marker.starts;
     652          others[blk]=marker.others;
     653       //postprocess_do_block(&(marker.starts), &(marker.others), src_buffer,  block_base);
    565654
    566655                  block_base += BLOCK_SIZE;
     
    585674                 
    586675                 
    587                  
    588                  
    589        postprocess_do_block(marker, src_buffer,  block_base);
     676                    starts[blk]=marker.starts;
     677                        others[blk]=marker.others;
     678                 
     679       //postprocess_do_block(&(marker.starts), &(marker.others), src_buffer,  block_base);
    590680                  blk++;
    591681        }
     
    594684        // buffer_pos += chars_avail;
    595685        // buffer_base = buffer_pos;
    596 
     686postprocess_do_block(starts, others, src_buffer,  0, 1, blk==1);       
     687if (blk>1){
     688postprocess_do_block(&starts[1], &others[1], src_buffer,  128, blk-1, true);}
    597689        PERF_SEC_END(parser_timer, chars_avail);
    598690}
  • proto/PDF/pdf.py

    r2639 r2667  
    5050        UERParen = 0
    5151        escapes = 0
     52        escaped = 0
    5253
    5354class Comments_Callouts() :
     
    203204        odd_start = start & odd
    204205        odd_final = pablo.ScanThru(odd_start, lex.Backslash)
     206        odd_sut =pablo.SpanUpTo(odd_start, odd_final)
     207
    205208        escape = escape | (odd_final & even)
    206         escape_char |= odd & pablo.SpanUpTo(odd_start, odd_final)
     209        escape_char |= odd & odd_sut
    207210       
    208211        escaped_Callouts.escapes = escape_char
    209212        escaped_Callouts.UELParen = lex.LParen &~ escape
    210213        escaped_Callouts.UERParen = lex.RParen &~ escape
     214        escaped_Callouts.escaped = escape
    211215               
    212216# Parallel version
     
    286290                                        literalStrings_Callouts.ends|=string_cursor
    287291                                        cursor = pablo.ScanTo(pablo.Advance(string_cursor), scan_characters)
    288                                 elif lt_zero():
     292                                if lt_zero():
    289293                                        literalStrings_Callouts.error|=string_cursor
    290294                                        cursor = pablo.ScanTo(pablo.Advance(string_cursor), scan_characters)
    291                                 else:
     295                                if ~(is_zero() | lt_zero()):
    292296                                        cursor = pablo.ScanTo(pablo.Advance(string_cursor), escaped_Callouts.UELParen | escaped_Callouts.UERParen)
    293297                                       
     
    296300        literalStrings_Callouts.mask = pablo.InclusiveSpan(literalStrings_Callouts.starts,literalStrings_Callouts.ends)
    297301        literalStrings_Callouts.escapes = escaped_Callouts.escapes & literalStrings_Callouts.mask
    298         literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ literalStrings_Callouts.escapes
     302        literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ escaped_Callouts.escaped
    299303        marker.mask = comments_Callouts.mask | literalStrings_Callouts.mask
    300304        marker.starts |= literalStrings_Callouts.starts
  • proto/PDF/pdf_demo.py

    r2629 r2667  
    4747        UERParen = 0
    4848        escapes = 0
     49        escaped = 0
    4950
    5051class Comments_Callouts() :
     
    210211        escaped_Callouts.UELParen = lex.LParen &~ escape
    211212        escaped_Callouts.UERParen = lex.RParen &~ escape
     213        escaped_Callouts.escaped = escape
    212214
    213215def inc() :
     
    311313        literalStrings_Callouts.mask = pablo.InclusiveSpan(literalStrings_Callouts.starts,literalStrings_Callouts.ends)
    312314        literalStrings_Callouts.escapes = escaped_Callouts.escapes & literalStrings_Callouts.mask
    313         literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ literalStrings_Callouts.escapes
     315        literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ escaped_Callouts.escaped
    314316        marker.mask |= comments_Callouts.mask | literalStrings_Callouts.mask
    315317        marker.starts |= literalStrings_Callouts.starts
     
    667669                        ('Special Chars Follows', pablo.bitstream2string(specialChars_Callouts.follows, lgth+1)),                             
    668670                        ('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 
     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 TracChangeset for help on using the changeset viewer.