Changeset 2629


Ignore:
Timestamp:
Nov 11, 2012, 9:15:19 PM (7 years ago)
Author:
bhull
Message:

Added token output for compiled version

Location:
proto/PDF
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • proto/PDF/pablo_template_pdf.cpp

    r2570 r2629  
    2929static BitBlock lt_zero() {
    3030        if (depth < 0) {
     31                return simd<1>::constant<1>();
     32        } else {
    3133                return simd<1>::constant<0>();
     34        }
     35}
     36
     37static BitBlock gt_zero() {
     38        if (depth > 0) {
     39                return simd<1>::constant<1>();
    3240        } else {
    33                 return simd<1>::constant<1>();
    34         }
    35 }
    36 
    37 static BitBlock ge_zero() {
    38         if (depth > 0) {
    3941                return simd<1>::constant<0>();
    40         } else {
    41                 return simd<1>::constant<1>();
    4242        }
    4343}
     
    4545static BitBlock is_zero() {
    4646        if (0 == depth) {
     47                return simd<1>::constant<1>();
     48        } else {
    4749                return simd<1>::constant<0>();
    48         } else {
    49                 return simd<1>::constant<1>();
    5050        }
    5151}
     
    137137        return(0);
    138138}
    139 
     139/*void print_register2(const char * var_name, BitBlock v, int length) {
     140        unsigned char c;
     141        printf("%10s = ", var_name);
     142        for(int i=(length+7)/8; i>=0; i--) {
     143                c = *(((unsigned char *)&v)+i);
     144                int div = 128;
     145                while (div > 0) {
     146                        if (c>=div) {
     147                                cout<<"1";
     148                                c-=div;
     149                        }
     150                        else {
     151                                cout<<"0";
     152                        }
     153                        div = div / 2;
     154                }
     155        }
     156        printf("\n");
     157}*/
     158void print_register2(const char * var_name, BitBlock v, int length) {
     159        unsigned char c;
     160        printf("%10s = ", var_name);
     161        for(int i=0;i<=(length+7)/8; i++) {
     162                c = *(((unsigned char *)&v)+i);
     163                int count = 0;
     164                while (count < 8) {
     165                        if ((c % 2)==1)
     166                        {
     167                                cout<<"1";
     168                        }
     169                        else {
     170                                cout<<"0";
     171                        }
     172                        c = c / 2;
     173                        count+=1;
     174                }
     175        }
     176        printf("\n");
     177}
     178string get_substring(uint8_t * src_buffer, int start, int end) {
     179        string out = "";
     180        for (int i =start;i<end;i++)
     181        {
     182                out+=src_buffer[i];
     183        }
     184        return out;
     185}       
    140186void do_process(FILE *infile, FILE *outfile) {
    141187        @decl
     
    253299                  s2p_do_final_block((BytePack *) &src_buffer[block_base], basis_bits, EOF_mask);
    254300                  @final_block_stmts
    255 
     301                  //print_register2("markstarts",marker.starts,remaining);
     302                 
     303                 
     304                string outstring;
     305                int startpos;
     306                int ch;
     307                int val;
     308                ForwardScanner<BitBlock, ScanWord> scanner(&(marker.starts));
     309                scanner.scan_to_next();
     310                while(!scanner.is_done()) {
     311                        switch (src_buffer[scanner.get_pos()])
     312                        {
     313                                case '/':
     314                                        cout<<"LexName:";
     315                                        outstring = "";
     316                                        startpos = scanner.get_pos();
     317                                        scanner.set_strm(&(marker.others));
     318                                        scanner.move_to(scanner.get_pos());
     319                                        scanner.scan_to_next();
     320                                       
     321                                       
     322                                        ch = src_buffer[scanner.get_pos()];
     323                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
     324                                                outstring+=get_substring(src_buffer,startpos+1, scanner.get_pos()-2);
     325                                                startpos = scanner.get_pos();
     326                                                if (ch<='9')            val =  ch - '0';
     327                                                else if (ch<='F')       val = 10 + ch - 'A';
     328                                                else val = 10 + ch - 'a';
     329                                                ch = src_buffer[scanner.get_pos()-1];
     330                                               
     331                                                if (ch<='9')            val = val + 16*(ch - '0');
     332                                                else if (ch<='F')       val = val+16*(10 + ch - 'A');
     333                                                else val = val+ 16*(10 + ch - 'a');
     334                                                outstring+=val;
     335                                                scanner.scan_to_next();
     336                                                ch = src_buffer[scanner.get_pos()];
     337                                        }
     338                                        outstring+=get_substring(src_buffer,startpos+1,scanner.get_pos());
     339                                        scanner.set_strm(&(marker.starts));
     340                                        scanner.move_to(scanner.get_pos()-1);
     341                                        cout<<outstring<<endl;
     342                       
     343                                       
     344                                        break;
     345                                case '(':
     346                                        cout<<"LexLiteralString:";
     347                                        outstring="";
     348                                        startpos = scanner.get_pos();
     349                                        scanner.set_strm(&(marker.others));
     350                                        scanner.move_to(scanner.get_pos());
     351                                        scanner.scan_to_next();
     352                                        while (!scanner.is_done()) {
     353                                                outstring+=get_substring(src_buffer, startpos+1,scanner.get_pos());
     354                                                if (src_buffer[scanner.get_pos()]==')') {
     355                                                        cout<<outstring<<endl;
     356                                                        break;
     357                                                }
     358                                                startpos=scanner.get_pos();
     359                                                if (src_buffer[scanner.get_pos()]=='\\') {
     360                                                        ch = src_buffer[scanner.get_pos()+1];
     361                                                        switch (ch) {
     362                                                                case 'n':
     363                                                                        outstring+=0x0A;
     364                                                                        break;
     365                                                                case 'r':
     366                                                                        outstring+=0x0D;
     367                                                                        break;
     368                                                                case 't':
     369                                                                        outstring+=0x09;
     370                                                                        break;
     371                                                                case 'b':
     372                                                                        outstring+=0x08;
     373                                                                        break;
     374                                                                case 'f':
     375                                                                        outstring+=0x0C;
     376                                                                        break;
     377                                                                case 0: case 1:
     378                                                                case 2: case 3:
     379                                                                case 4: case 5:
     380                                                                case 6: case 7:
     381                                                                        val = ch - '0';
     382                                                                        if ((src_buffer[scanner.get_pos()+2]) >= '0' && (src_buffer[scanner.get_pos()+2]<='8')) {
     383                                                                                val = val*8 + src_buffer[scanner.get_pos()+2]-'0';
     384                                                                                startpos+=1;
     385                                                                                if ((src_buffer[scanner.get_pos()+3]) >= '0' && (src_buffer[scanner.get_pos()+3]<='8')) {
     386                                                                                        val = val*8 + src_buffer[scanner.get_pos()+3]-'0';
     387                                                                                        startpos+=1;
     388                                                                                }
     389                                                                        }
     390                                                                        val = val & 0xFF;
     391                                                                        outstring+=val;
     392                                                                        break;
     393                                                                case 13:
     394                                                                        if (src_buffer[scanner.get_pos()+2]==10) {
     395                                                                                startpos+=1;
     396                                                                        }
     397                                                                        break;
     398                                                                case 10:
     399                                                                        break;
     400                                                                default:
     401                                                                        outstring+=ch;
     402                                                        }
     403                                                        startpos+=1;
     404                                       
     405                                       
     406                                                }
     407                                                else {
     408                                                        outstring+=0x0A;
     409                                                        if (src_buffer[scanner.get_pos()+1]==0x0a) {
     410                                                                startpos+=1;
     411                                                        }
     412                                                }
     413                                                scanner.scan_to_next();
     414                                        }
     415                                       
     416                                        if (scanner.is_done()) {
     417                                                cout << "Corrupt string"<<endl;
     418                                        }
     419                                        scanner.set_strm(&(marker.starts));
     420                                        scanner.move_to(scanner.get_pos()-1);
     421                                        break;
     422                                case '0': case '1':
     423                                case '2': case '3':
     424                                case '4': case '5':
     425                                case '6': case '7':
     426                                case '8': case '9':
     427                                case '.': case '+':
     428                                case '-':
     429                                        cout << "LexNumber:";
     430                                               
     431                                        startpos = scanner.get_pos();
     432                                        scanner.set_strm(&(marker.others));
     433                                        scanner.move_to(scanner.get_pos());
     434                                        scanner.scan_to_next();
     435                                       
     436                                        outstring=get_substring(src_buffer,startpos,scanner.get_pos());
     437                                        scanner.set_strm(&(marker.starts));
     438                                        scanner.move_to(scanner.get_pos()-1);
     439                                        cout<<outstring<<endl;
     440                                        break;
     441                                case '<':
     442                                        cout << "LexHexString:";
     443                                        outstring="";
     444                                        scanner.set_strm(&(marker.others));
     445                                        scanner.move_to(scanner.get_pos());
     446                                        scanner.scan_to_next();
     447                                        ch = src_buffer[scanner.get_pos()];
     448                                        while (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
     449                                                if (ch<='9')            val =  16*(ch - '0');
     450                                                else if (ch<='F')       val = 16*(10 + ch - 'A');
     451                                                else val = 16*(10 + ch - 'a');
     452                                                scanner.scan_to_next();
     453                                                ch = src_buffer[scanner.get_pos()];
     454                                                if (('0'<=ch && ch<='9') || ('A'<=ch && ch<='F') ||('a'<=ch && ch<='f')) {
     455                                                        if (ch<='9')            val +=  (ch - '0');
     456                                                        else if (ch<='F')       val += (10 + ch - 'A');
     457                                                        else val += 10 + ch - 'a';
     458                                                        scanner.scan_to_next();
     459                                                        ch = src_buffer[scanner.get_pos()];
     460                                                }
     461                                                outstring+=val;
     462                                        }
     463                                        if (ch !='>') {
     464                                                cout<<"BASE_ASSERT(false, \"Bad String\");"<<endl;
     465                                        }
     466                                        else
     467                                        {
     468                                                cout<<outstring<<endl;
     469                                        }
     470                                        scanner.set_strm(&(marker.starts));
     471                                        scanner.move_to(scanner.get_pos()-1);                                   
     472                                        break;
     473                                case ')':
     474                                        cout << "BASE_ASSERT(false, \"')' is not matched\");"<<endl;//"BASE_ASSERT(false, "\')\' is not matched");"
     475                                        break;
     476                                case '[':
     477                                        cout<<"Array Start"<<endl;
     478                                        scanner.set_strm(&(marker.others));
     479                                        scanner.move_to(scanner.get_pos());
     480                                        scanner.scan_to_next();
     481                                        scanner.set_strm(&(marker.starts));
     482                                       
     483                                        scanner.move_to(scanner.get_pos()-1);
     484                                        break;
     485                                default:
     486                                        cout<<"LexDefault:";
     487                                        startpos = scanner.get_pos();
     488                                        scanner.set_strm(&(marker.others));
     489                                        scanner.move_to(scanner.get_pos());
     490                                        scanner.scan_to_next();
     491                                        outstring = get_substring(src_buffer,startpos,scanner.get_pos());
     492                                        if (outstring=="null") {
     493                                                cout << "NULL OBJECT"<<endl;
     494                                        } else if (outstring=="true") {
     495                                                cout << "TRUE OBJECT"<<endl;
     496                                        } else if (outstring =="false") {
     497                                                cout << "FALSE OBJECT"<<endl;
     498                                        } else {
     499                                                cout << "RETURN FALSE:"<<outstring<<endl;
     500                                        }
     501                                        scanner.set_strm(&(marker.starts));
     502                                        scanner.move_to(scanner.get_pos()-1);
     503                                       
     504                                }
     505                               
     506
     507                        if(!scanner.is_done()) {
     508                                scanner.scan_to_next();
     509                        }
     510                }
     511                 
     512                 
     513                 
     514                 
     515                 
     516                 
     517                 
     518                 
     519                 
     520                 
     521                 
     522                 
     523                 
    256524      // postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)src_buffer, buffer_base, block_base, chars_avail, tracker);
    257525                  blk++;
  • proto/PDF/pdf.py

    r2620 r2629  
    6464class Marker() :
    6565        mask = 0
     66        starts = 0
     67        others = 0
    6668
    6769class Names_Callouts() :
     
    8385class Keywords_Callouts() :
    8486        starts = 0
    85         ends = 0
     87        follows = 0
    8688       
    8789class SpecialChars_Callouts() :
     
    248250
    249251
    250 
    251252def Parse_CommentsLiteralStrings(lex, escaped_Callouts, marker, comments_Callouts, literalStrings_Callouts) :
    252253        #not entirely sure this code is correct once compiled
     
    254255        comment_starts=0
    255256        comment_ends=0
     257        marker.starts = 0
     258        marker.others = 0
     259        literalStrings_Callouts.starts = 0
     260        literalStrings_Callouts.ends = 0
     261
    256262        scan_characters = escaped_Callouts.UELParen | escaped_Callouts.UERParen | lex.Percent
    257263        cursor = pablo.ScanToFirst(scan_characters)
     
    292298        literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ literalStrings_Callouts.escapes
    293299        marker.mask = comments_Callouts.mask | literalStrings_Callouts.mask
     300        marker.starts |= literalStrings_Callouts.starts
     301        marker.others |= literalStrings_Callouts.ends | literalStrings_Callouts.escapes | literalStrings_Callouts.carriage_returns
    294302
    295303def Parse_Names(lex, marker, names_Callouts) :
     
    299307        names_Callouts.escapes = (pablo.Advance(pablo.Advance(lex.Hash))&pablo.Advance(lex.Hex)&lex.Hex)&pablo.SpanUpTo(names_Callouts.starts, names_Callouts.follows)
    300308        marker.mask |=names_Callouts.starts|(firstCharacter&~names_Callouts.follows)
     309        marker.starts |= names_Callouts.starts
     310        marker.others |= names_Callouts.follows | names_Callouts.escapes
     311
    301312
    302313def Parse_HexStrings(lex, marker, hexStrings_Callouts) :
     
    307318        hexStrings_Callouts.hex = lex.Hex & mask
    308319        marker.mask |= mask
     320        marker.starts |= hexStrings_Callouts.starts
     321        marker.others |= hexStrings_Callouts.ends | hexStrings_Callouts.hex
    309322
    310323def Parse_Numeric(lex, marker, numeric_Callouts) :
     
    313326        numeric_Callouts.follows =pablo.ScanThru(numeric_Callouts.starts, lex.Regular)
    314327        marker.mask |= numeric_Callouts.starts
     328        marker.starts |= numeric_Callouts.starts
     329        marker.others |= numeric_Callouts.follows
     330        # aftersign = pablo.Advance(numeric_Callouts.starts & lex.Sign) | (numeric_Callouts.starts &~ lex.Sign)
     331        # temp = pablo.ScanThru(aftersign, lex.Digit)
     332        # afterperiod = pablo.Advance(temp & lex.Period) | (temp &~ lex.Period)
     333        # numeric_Callouts.follows = pablo.ScanThru(afterperiod, lex.Digit)
     334        # numeric_Callouts.error = numeric_Callouts.follows &~ (lex.WS | lex.Delimiter)
     335        # marker.mask |= numeric_Callouts.starts
    315336
    316337def Parse_Keywords(lex, marker, keywords_Callouts) :
    317338        keywords_Callouts.starts = (lex.Regular &~ pablo.Advance(lex.Regular)) &~ marker.mask
    318339        keywords_Callouts.follows = pablo.ScanThru(keywords_Callouts.starts, lex.Regular)
     340        marker.starts |= keywords_Callouts.starts
     341        marker.others |= keywords_Callouts.follows
    319342       
    320343def Parse_SpecialChars(lex, marker, specialChars_Callouts) :
    321344        specialChars_Callouts.starts =  (lex.Special) &~ marker.mask
    322345        specialChars_Callouts.follows = pablo.Advance(specialChars_Callouts.starts)
    323        
     346        marker.starts |= specialChars_Callouts.starts
     347        marker.others |= specialChars_Callouts.follows
     348
    324349def Main(basis_bits, lex, parity, escaped_Callouts):
    325350                Classify_bytes(basis_bits, lex)
  • proto/PDF/pdf_demo.py

    r2618 r2629  
    6161class Marker() :
    6262        mask = 0
     63        starts = 0
     64        others = 0
    6365
    6466class Names_Callouts() :
     
    310312        literalStrings_Callouts.escapes = escaped_Callouts.escapes & literalStrings_Callouts.mask
    311313        literalStrings_Callouts.carriage_returns = lex.CR & literalStrings_Callouts.mask &~ literalStrings_Callouts.escapes
    312         marker.mask = comments_Callouts.mask | literalStrings_Callouts.mask
     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
    313317
    314318def Parse_Names(lex, marker, names_Callouts) :
     
    318322        names_Callouts.escapes = (pablo.Advance(pablo.Advance(lex.Hash))&pablo.Advance(lex.Hex)&lex.Hex)&pablo.SpanUpTo(names_Callouts.starts, names_Callouts.follows)
    319323        marker.mask |=names_Callouts.starts|(firstCharacter&~names_Callouts.follows)
     324        marker.starts |= names_Callouts.starts
     325        marker.others |= names_Callouts.follows | names_Callouts.escapes
    320326
    321327
     
    327333        hexStrings_Callouts.hex = lex.Hex & mask
    328334        marker.mask |= mask
     335        marker.starts |= hexStrings_Callouts.starts
     336        marker.others |= hexStrings_Callouts.ends | hexStrings_Callouts.hex
    329337
    330338def Parse_Numeric(lex, marker, numeric_Callouts) :
     
    333341        numeric_Callouts.follows =pablo.ScanThru(numeric_Callouts.starts, lex.Regular)
    334342        marker.mask |= numeric_Callouts.starts
    335 
     343        marker.starts |= numeric_Callouts.starts
     344        marker.others |= numeric_Callouts.follows
    336345        # aftersign = pablo.Advance(numeric_Callouts.starts & lex.Sign) | (numeric_Callouts.starts &~ lex.Sign)
    337346        # temp = pablo.ScanThru(aftersign, lex.Digit)
     
    344353        keywords_Callouts.starts = (lex.Regular &~ pablo.Advance(lex.Regular)) &~ marker.mask
    345354        keywords_Callouts.follows = pablo.ScanThru(keywords_Callouts.starts, lex.Regular)
     355        marker.starts |= keywords_Callouts.starts
     356        marker.others |= keywords_Callouts.follows
    346357       
    347358def Parse_SpecialChars(lex, marker, specialChars_Callouts) :
    348359        specialChars_Callouts.starts =  (lex.Special) &~ marker.mask
    349360        specialChars_Callouts.follows = pablo.Advance(specialChars_Callouts.starts)
    350 
     361        marker.starts |= specialChars_Callouts.starts
     362        marker.others |= specialChars_Callouts.follows
     363       
    351364def scan_to_next(stream) :
    352365        global position
     
    606619       
    607620       
    608         startsStream = literalStrings_Callouts.starts | names_Callouts.starts | hexStrings_Callouts.starts | numeric_Callouts.starts | keywords_Callouts.starts | specialChars_Callouts.starts
     621        startsStream = marker.starts #literalStrings_Callouts.starts | names_Callouts.starts | hexStrings_Callouts.starts | numeric_Callouts.starts | keywords_Callouts.starts | specialChars_Callouts.starts
    609622        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
     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
    611624        global position
    612625        position = 0
Note: See TracChangeset for help on using the changeset viewer.