Ignore:
Timestamp:
May 18, 2013, 3:14:22 PM (6 years ago)
Author:
lindanl
Message:

Add array parsing.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • proto/PDF/cb_template.cpp

    r3145 r3155  
    6363  int_token,
    6464  flt_token,
    65   kw_token
     65  kw_token,
     66  array_token
    6667};
    6768
     
    7879  int len;
    7980  int token_pos;
     81};
     82
     83struct buf_State{
     84  int at_start;
     85  int at_optr;
     86  int base_pos;
     87  int array_depth;
     88  int array_start_tokenidx; 
    8089};
    8190
     
    246255        }
    247256}
    248 /*
    249 static inline void Postprocessing(char* cb, int cb_size, char* cb_new, BitBlock * marker_starts, BitBlock * marker_ends, ubitblock * unitsums_per_reg, int & at_start, int & at_optr, int & base_pos){   
     257
     258static inline void Postprocessing(char* cb, int cb_size, char* cb_new, BitBlock * marker_starts, BitBlock * marker_ends, ubitblock * unitsums_per_reg, struct buf_State & buf_state){   
    250259     
    251260  int pos = 0;
    252  
    253   if(!at_start){
    254     if(at_optr){
     261  int len = 0;
     262 
     263  if(!buf_state.at_start){
     264    if(buf_state.at_optr){
    255265      optrArray[optr_idx].char_ptr = cb;
    256266    }
     
    266276  }
    267277   
    268   int block_pos = base_pos;
    269   for(int i=0; i<BLOCKS; i++){
    270     if(bitblock::any(simd_or(marker_starts[i],marker_ends[i]))){
    271       ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_start(&(marker_starts[i]), unitsums_per_reg[i]._128);
    272       ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_end(&(marker_ends[i]), unitsums_per_reg[i]._128);
    273       iter_start.scan_to_next();
    274       iter_end.scan_to_next();
    275       while(!iter_start.is_done() || !iter_end.is_done()) {
    276         if(at_start){
    277           pos = block_pos + (iter_start.get_pos());
    278           if (cb[pos]== 0x2f){ 
    279             tokenArray[token_idx].type = name_token;
    280             tokenArray[token_idx].token.char_ptr = &cb[pos];
    281           }
    282           else if(cb[pos]== 0x28){     
    283             tokenArray[token_idx].type = str_token;
    284             tokenArray[token_idx].token.char_ptr = &cb[pos];
    285           }
    286           else if (cb[pos]== 0x0c){     
    287             tokenArray[token_idx].type = hex_token;
    288             tokenArray[token_idx].token.char_ptr = &cb[pos];
    289           }
    290           else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
    291             Digit_postprocessing(cb, pos);
    292           }
    293           else if ( (cb[pos]== 'n' && cb[pos+1]== 'u' && cb[pos+2]== 'l'  && cb[pos+3]== 'l')
    294             || (cb[pos]== 't' && cb[pos+1]== 'r' && cb[pos+2]== 'u'  && cb[pos+3]== 'e')
    295             || (cb[pos]== 'f' && cb[pos+1]== 'a' && cb[pos+2]== 'l'  && cb[pos+3]== 's' && cb[pos+3]== 'e')){
    296            
    297             tokenArray[token_idx].type = kw_token;
    298             tokenArray[token_idx].token.char_ptr = &cb[pos];   
    299           }
    300           else{
    301             //operator
    302             optrArray[optr_idx].char_ptr = &cb[pos];
    303             optrArray[optr_idx].token_pos = token_idx-1;
    304             at_optr = 1;
    305           }
    306           iter_start.scan_to_next();
    307           at_start = 0;
    308         }
    309         else{
    310           int len = block_pos + (iter_end.get_pos()) - pos;     
    311           if(at_optr){
    312             optrArray[optr_idx].len = len;
    313             optr_idx++;
    314             at_optr = 0;
    315           }
    316           else{
    317             tokenArray[token_idx].len = len;
    318             token_idx++;
    319           }
    320           iter_end.scan_to_next();
    321           at_start = 1;
    322         }
    323       }
    324     }   
    325 
    326     block_pos += unitsums_per_reg[i]._16[7];
    327   }
    328   if(!at_start){
    329     base_pos = cb_size - pos;
    330 //     if(base_pos<0){
    331 //       cout << "in markup " << cb_size << "," << pos << "," << base_pos << endl;
    332 //     }
    333     memcpy(cb_new, &cb[pos], base_pos);
    334   }
    335   else
    336     base_pos = 0;
    337 }
    338 */
    339 static inline void Postprocessing(char* cb, int cb_size, char* cb_new, BitBlock * marker_starts, BitBlock * marker_ends, ubitblock * unitsums_per_reg, int & at_start, int & at_optr, int & base_pos){   
    340      
    341   int pos = 0;
    342   int len = 0;
    343  
    344   if(!at_start){
    345     if(at_optr){
    346       optrArray[optr_idx].char_ptr = cb;
    347     }
    348     else{
    349       if (tokenArray[token_idx].type == flt_token || tokenArray[token_idx].type == int_token){
    350         num_idx--;
    351         Digit_postprocessing(cb, 0);
    352       }
    353       else{
    354         tokenArray[token_idx].token.char_ptr = cb;
    355       }
    356     }
    357   }
    358    
    359   int block_pos = base_pos;
     278  int block_pos = buf_state.base_pos;
    360279  uint16_t * unit_sums = &(((uint16_t *) unitsums_per_reg)[7]);
    361280
     
    388307      tokenArray[token_idx].token.char_ptr = &cb[pos]; 
    389308    }
     309    else if(cb[pos] =='['){
     310      if(buf_state.array_depth==0)
     311        buf_state.array_start_tokenidx = token_idx;
     312      buf_state.array_depth++;     
     313      iter_start.scan_to_next();
     314      continue;
     315    }
     316    else if(cb[pos] ==']'){
     317      buf_state.array_depth--;
     318      if(buf_state.array_depth==0){
     319        tokenArray[token_idx].type = array_token;
     320        tokenArray[token_idx].token.idx = buf_state.array_start_tokenidx;
     321      }     
     322      token_idx++;
     323      iter_start.scan_to_next();
     324      continue;
     325    }
    390326    else{
    391327      //operator
    392328      optrArray[optr_idx].char_ptr = &cb[pos];
    393329      optrArray[optr_idx].token_pos = token_idx-1;
    394       at_optr = 1;
     330      buf_state.at_optr = 1;
    395331    }
    396332    iter_start.scan_to_next();
    397333    if(iter_end.is_done()){
    398       at_start = 0;
     334      buf_state.at_start = 0;
    399335      break;
    400336    }
    401337    len = block_pos + (iter_end.get_pos()) - pos;       
    402     if(at_optr){
     338    if(buf_state.at_optr){
    403339      optrArray[optr_idx].len = len;
    404340      optr_idx++;
    405       at_optr = 0;
     341      buf_state.at_optr = 0;
    406342    }
    407343    else{
     
    410346    }
    411347    iter_end.scan_to_next();
    412     at_start = 1;
     348    buf_state.at_start = 1;
    413349  }
    414350 
    415   if(!at_start){
    416     base_pos = cb_size - pos;
    417     memcpy(cb_new, &cb[pos], base_pos);
     351  if(!buf_state.at_start){
     352    buf_state.base_pos = cb_size - pos;
     353    memcpy(cb_new, &cb[pos], buf_state.base_pos);
    418354  }
    419355  else
    420     base_pos = 0;
     356    buf_state.base_pos = 0;
    421357}
    422358
     
    450386  int cb_idx = 0; 
    451387  ubitblock unitsums_per_reg[BLOCKS+1];
    452   int at_start = 1;
    453   int at_optr = 0;
    454   int base_pos = 0;
     388  struct buf_State buf_state;
     389  buf_state.at_start = 1;
     390  buf_state.at_optr = 0;
     391  buf_state.base_pos = 0;
     392  buf_state.array_depth = 0;
     393  buf_state.array_start_tokenidx = 0;
    455394
    456395  unitsums_per_reg[0]._128 = simd<16>::constant<0>();
     
    505444
    506445    content_buf[cb_idx+1] = (char*)malloc(BUF_SIZE*2);
    507     Postprocessing(content_buf[cb_idx], content_buf_ptr-content_buf[cb_idx], content_buf[cb_idx+1], marker_starts, marker_ends, unitsums_per_reg, at_start, at_optr, base_pos);
     446    Postprocessing(content_buf[cb_idx], content_buf_ptr-content_buf[cb_idx], content_buf[cb_idx+1], marker_starts, marker_ends, unitsums_per_reg, buf_state);
    508447//     ints_2_floats(numbers, dec_pl, num_rslt, num_idx);
    509448//      ints_x_floats(numbers, dec_pl, num_rslt, num_idx);
    510449//    simd_ints_2_floats(numbers, dec_pl, num_rslt, num_idx);
    511     content_buf_ptr =  content_buf[cb_idx+1]+base_pos;
     450    content_buf_ptr =  content_buf[cb_idx+1]+buf_state.base_pos;
    512451    cb_idx++; 
    513452   
     
    553492    marker_ends[BLOCKS-1] = marker.ends;
    554493    content_buf[cb_idx+1] = (char*)malloc(BUF_SIZE*2);
    555     Postprocessing(content_buf[cb_idx], content_buf_ptr-content_buf[cb_idx], content_buf[cb_idx+1], marker_starts, marker_ends, unitsums_per_reg, at_start, at_optr, base_pos); 
     494    Postprocessing(content_buf[cb_idx], content_buf_ptr-content_buf[cb_idx], content_buf[cb_idx+1], marker_starts, marker_ends, unitsums_per_reg, buf_state); 
    556495    break;
    557496  }
     
    564503    for(int i=0;i<num_idx;i++)
    565504      printf("%i,%i\n",numbers[i],dec_pl[i]);*/
    566 /*   
     505   
    567506    for(int i=0; i<100;i++){
    568507      if(tokenArray[i].type==str_token){
     
    595534        printf("\n");
    596535      }
     536      if(tokenArray[i].type==array_token){
     537        printf("Array: %i, %i\n", tokenArray[i].token.idx, i);
     538      }
    597539    }
    598540   
    599541
    600542    for(int i=0;i<100;i++)  {
    601         printf("len at %i is %i\n",i, optrArray[i].len);
     543//         printf("len at %i is %i\n",i, optrArray[i].len);
    602544        for(int j=0; j<optrArray[i].len; j++)
    603545          printf("%c",optrArray[i].char_ptr[j]);
    604546        printf("\n");
    605547    }
    606 */
     548
    607549}
    608550
Note: See TracChangeset for help on using the changeset viewer.