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

Added token output for compiled version

File:
1 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++;
Note: See TracChangeset for help on using the changeset viewer.