source: proto/PDF/cb_template.cpp @ 3145

Last change on this file since 3145 was 3145, checked in by lindanl, 6 years ago

Use scanner instead of iterator.

File size: 22.6 KB
Line 
1#include <stdio.h>
2#include <stdlib.h>
3#include <errno.h>
4#include <sys/types.h>
5#include <sys/stat.h>
6
7#define LocalCarryDeclare(name, count)\
8CarryArray<count, 0> name;\
9
10#include "../../simd-lib/bitblock.hpp"
11#include "../../simd-lib/carryQ.hpp"
12#include "bitblock_iterator.hpp"
13#include "../../simd-lib/pabloSupport.hpp"
14#include "../../simd-lib/s2p.hpp"
15#include "../../simd-lib/p2s.hpp"
16#include "../simd-float.cpp"
17
18#include "../../simd-lib/perflib/perfsec.h"
19using namespace std;
20#include <iostream>
21#include <vector>
22
23int BLOCKS = 12;
24#define BUF_SIZE BLOCK_SIZE * BLOCKS
25
26
27#ifdef BUFFER_PROFILING
28        BOM_Table * s2p_lex_timer;
29        BOM_Table * parser_timer;
30        BOM_Table * postprocess_timer;
31
32#elif CODE_CLOCKER
33        #define NUM_EVENTS 1
34        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
35        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
36        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
37        int cal_size = 20;
38        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
39#else
40        void * s2p_lex_timer;
41        void * parser_timer;
42        void * postprocess_timer;
43#endif
44
45BitBlock EOF_mask = simd<1>::constant<1>();
46
47int pow_ten[8] = {1,10,100,1000,10000,100000,1000000,10000000};
48float inv_pow_ten[8] = {1.0,0.1,00.1,000.1,0000.1,00000.1,000000.1,0000000.1};
49
50static inline int Digit_postprocessing(char * source, int pos);
51
52@global
53
54static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
55static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
56
57void do_process(FILE *infile, FILE *outfile, int filesize);
58
59enum PDFTokenType {
60  str_token,
61  hex_token,
62  name_token,
63  int_token,
64  flt_token,
65  kw_token
66};
67
68union PDFToken { char * char_ptr; int idx;};
69
70typedef struct tokenStruct{
71  union PDFToken token;
72  int len;
73  enum PDFTokenType type;
74} TokenStruct;
75
76struct pdfOptr{
77  char * char_ptr;
78  int len;
79  int token_pos;
80};
81
82TokenStruct tokenArray[1000000];
83int token_idx=0;
84
85struct pdfOptr optrArray[1000000];
86int optr_idx=0;
87
88#define MAX_NUM 1000000
89int numbers[MAX_NUM];
90float num_rslt[MAX_NUM];
91float dec_pl[MAX_NUM];
92int num_idx=0;
93
94static inline int Digit_postprocessing(char * source, int pos) {
95    bool negative= false;
96    int num = 0;
97    int start_pos = -1;
98    if (source[pos] == '-')     {
99      pos++;
100      negative = true;
101    }
102    else if (source[pos] == '+')
103      pos++;
104
105    while ('0' <= source[pos] && source[pos] <= '9' || source[pos]=='.'){
106      if(source[pos]=='.'){
107        pos++;
108        start_pos = pos;
109        continue;
110      }
111      num = num * 10 + source[pos] - '0';
112      pos++;
113    }
114    if (negative) (num) = -(num);
115    numbers[num_idx] = num;
116    if(start_pos!=-1){
117      dec_pl[num_idx] = inv_pow_ten[pos - start_pos];
118      tokenArray[token_idx].type = flt_token;
119      tokenArray[token_idx].token.idx = num_idx;
120    }
121    else{
122      dec_pl[num_idx] = 1.0;
123      tokenArray[token_idx].type = int_token;
124      tokenArray[token_idx].token.idx = num_idx;
125    }
126    num_idx++;
127}
128
129/* s2p Definitions */
130static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
131  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
132        basis_bits.bit_0, basis_bits.bit_1, basis_bits.bit_2, basis_bits.bit_3, basis_bits.bit_4, basis_bits.bit_5, basis_bits.bit_6, basis_bits.bit_7);
133}
134
135static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
136  s2p_do_block(U8, basis_bits);
137  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
138  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
139  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
140  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
141  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
142  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
143  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
144  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
145}
146
147#define do_right16_shifts(vec,rshift1,rshift2,rshift4,rshift8)  \
148{BitBlock s2; \
149vec= simd<16>::sub(vec,simd<16>::srli<1>(simd_and(rshift1,vec)) ) ; \
150s2= simd_and(rshift2,vec) ; \
151vec= simd_or(simd<16>::srli<2>(s2) ,simd_xor(vec,s2) ) ; \
152s2= simd_and(rshift4,vec) ; \
153vec= simd_or(simd<16>::srli<4>(s2) ,simd_xor(vec,s2) ) ; \
154s2= simd_and(rshift8,vec) ; \
155vec= simd_or(simd<16>::srli<8>(s2) ,simd_xor(vec,s2) ) ; \
156}
157
158static inline void delinfo_16(BitBlock & del16_rshift1, BitBlock & del16_rshift2, BitBlock & del16_rshift4,
159                              BitBlock & del16_rshift8, BitBlock delmask){
160       
161        BitBlock del16_trans2;
162        BitBlock del16_trans4;
163        BitBlock del16_trans8;
164        BitBlock shift_bits;
165       
166        del16_rshift1= simd_xor(simd<16>::slli<1>(delmask),simd<16>::slli<2>(delmask));
167        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<2>(del16_rshift1));
168        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<4>(del16_rshift1));
169        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<8>(del16_rshift1));
170       
171        del16_trans2= simd_and(del16_rshift1,delmask);
172        del16_rshift2= simd_xor(simd<16>::slli<1>(del16_trans2),simd<16>::slli<2>(del16_trans2));
173        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<2>(del16_rshift2));
174        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<4>(del16_rshift2));
175        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<8>(del16_rshift2));
176       
177        del16_trans4= simd_and(del16_rshift2,del16_trans2);
178        del16_rshift4= simd_xor(simd<16>::slli<1>(del16_trans4),simd<16>::slli<2>(del16_trans4));
179        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<2>(del16_rshift4));
180        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<4>(del16_rshift4));
181        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<8>(del16_rshift4));
182       
183        del16_trans8= simd_and(del16_rshift4,del16_trans4);
184        del16_rshift8= simd_xor(simd<16>::slli<1>(del16_trans8),simd<16>::slli<2>(del16_trans8));
185        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<2>(del16_rshift8));
186        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<4>(del16_rshift8));
187        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<8>(del16_rshift8));
188       
189        del16_rshift1= simd_andc(del16_rshift1,delmask);
190        del16_rshift2= simd_andc(del16_rshift2,delmask);
191        del16_rshift4= simd_andc(del16_rshift4,delmask);
192        del16_rshift8= simd_andc(del16_rshift8,delmask);
193       
194        del16_rshift2= simd<16>::sub(del16_rshift2,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift2)));
195       
196        del16_rshift4= simd<16>::sub(del16_rshift4,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift4)));
197        shift_bits= simd_and(del16_rshift2,del16_rshift4);
198        del16_rshift4= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift4,shift_bits));
199       
200        del16_rshift8= simd<16>::sub(del16_rshift8,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift8)));
201        shift_bits= simd_and(del16_rshift2,del16_rshift8);
202        del16_rshift8= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift8,shift_bits));       
203        shift_bits= simd_and(del16_rshift4,del16_rshift8);
204        del16_rshift8= simd_or(simd<16>::srli<4>(shift_bits),simd_xor(del16_rshift8,shift_bits));
205}
206
207static inline void del_count(BitBlock delmask, BitBlock & u8_bytes_per_reg){
208
209        BitBlock delcounts_16 = simd<16>::popcount(delmask);
210        u8_bytes_per_reg = simd<16>::sub(simd<16>::constant<16>(), delcounts_16);
211}
212
213static inline void Build_ContentBuffer(Out_Callouts out_Callouts, Marker & marker, char ** content_buf_ptr, ubitblock * unitsums_per_reg, int blk){
214   
215    BytePack S[8];
216
217    if (bitblock::any(out_Callouts.delmask)) {
218            BitBlock shift1, shift2, shift4, shift8;
219            delinfo_16(shift1, shift2, shift4, shift8, out_Callouts.delmask);
220            do_right16_shifts(out_Callouts.bit_0, shift1, shift2, shift4, shift8);
221            do_right16_shifts(out_Callouts.bit_1, shift1, shift2, shift4, shift8);
222            do_right16_shifts(out_Callouts.bit_2, shift1, shift2, shift4, shift8);
223            do_right16_shifts(out_Callouts.bit_3, shift1, shift2, shift4, shift8);
224            do_right16_shifts(out_Callouts.bit_4, shift1, shift2, shift4, shift8);
225            do_right16_shifts(out_Callouts.bit_5, shift1, shift2, shift4, shift8);
226            do_right16_shifts(out_Callouts.bit_6, shift1, shift2, shift4, shift8);
227            do_right16_shifts(out_Callouts.bit_7, shift1, shift2, shift4, shift8);
228            do_right16_shifts(marker.starts, shift1, shift2, shift4, shift8);
229            do_right16_shifts(marker.ends, shift1, shift2, shift4, shift8);
230        }
231
232        ubitblock units_per_reg;
233       
234        p2s(out_Callouts.bit_0,out_Callouts.bit_1,out_Callouts.bit_2,out_Callouts.bit_3,
235            out_Callouts.bit_4,out_Callouts.bit_5,out_Callouts.bit_6,out_Callouts.bit_7,
236                          S[0], S[1],S[2] ,S[3] ,S[4] ,S[5] ,S[6] ,S[7]);
237         
238        for(int k=0; k<8; k++) units_per_reg._16[k] = 0;
239        del_count(out_Callouts.delmask,units_per_reg._128);
240       
241        unitsums_per_reg[blk+1]._128 = simd<16>::add(mvmd<16>::splat<7>(unitsums_per_reg[blk]._128), PartialSum16(units_per_reg._128));
242       
243        for(int j=0; j<8; j++){
244          bitblock::store_unaligned(S[j], (BytePack *) *content_buf_ptr);
245          *content_buf_ptr += units_per_reg._16[j];
246        }
247}
248/*
249static 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){   
250     
251  int pos = 0;
252 
253  if(!at_start){
254    if(at_optr){
255      optrArray[optr_idx].char_ptr = cb;
256    }
257    else{
258      if (tokenArray[token_idx].type == flt_token || tokenArray[token_idx].type == int_token){
259        num_idx--;
260        Digit_postprocessing(cb, 0);
261      }
262      else{
263        tokenArray[token_idx].token.char_ptr = cb;
264      }
265    }
266  }
267   
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*/
339static 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;
360  uint16_t * unit_sums = &(((uint16_t *) unitsums_per_reg)[7]);
361
362  ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_start(marker_starts, unit_sums, BLOCKS);
363  ForwardScannerWithBaseCounts16<BitBlock, ScanWord> iter_end(marker_ends, unit_sums, BLOCKS);
364  iter_start.scan_to_next();
365  iter_end.scan_to_next(); 
366  while(!iter_start.is_done()) {
367    pos = block_pos + (iter_start.get_pos());
368    if (cb[pos]== 0x2f){       
369      tokenArray[token_idx].type = name_token;
370      tokenArray[token_idx].token.char_ptr = &cb[pos];
371    }
372    else if(cb[pos]== 0x28){   
373      tokenArray[token_idx].type = str_token;
374      tokenArray[token_idx].token.char_ptr = &cb[pos];
375    }
376    else if (cb[pos]== 0x0c){   
377      tokenArray[token_idx].type = hex_token;
378      tokenArray[token_idx].token.char_ptr = &cb[pos];
379    }
380    else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
381      Digit_postprocessing(cb, pos);
382    }
383    else if ( (cb[pos]== 'n' && cb[pos+1]== 'u' && cb[pos+2]== 'l'  && cb[pos+3]== 'l')
384      || (cb[pos]== 't' && cb[pos+1]== 'r' && cb[pos+2]== 'u'  && cb[pos+3]== 'e')
385      || (cb[pos]== 'f' && cb[pos+1]== 'a' && cb[pos+2]== 'l'  && cb[pos+3]== 's' && cb[pos+3]== 'e')){
386     
387      tokenArray[token_idx].type = kw_token;
388      tokenArray[token_idx].token.char_ptr = &cb[pos]; 
389    }
390    else{
391      //operator
392      optrArray[optr_idx].char_ptr = &cb[pos];
393      optrArray[optr_idx].token_pos = token_idx-1;
394      at_optr = 1;
395    }
396    iter_start.scan_to_next(); 
397    if(iter_end.is_done()){
398      at_start = 0;
399      break;
400    }
401    len = block_pos + (iter_end.get_pos()) - pos;       
402    if(at_optr){
403      optrArray[optr_idx].len = len;
404      optr_idx++;
405      at_optr = 0;
406    }
407    else{
408      tokenArray[token_idx].len = len;
409      token_idx++;
410    }
411    iter_end.scan_to_next(); 
412    at_start = 1;
413  }
414 
415  if(!at_start){
416    base_pos = cb_size - pos;
417    memcpy(cb_new, &cb[pos], base_pos);
418  }
419  else
420    base_pos = 0;
421}
422
423#define MAX_CB  10000
424
425void do_process(FILE *infile, FILE *outfile, int filesize) {
426 
427  struct Basis_bits * basis_bits = (struct Basis_bits *)malloc(sizeof(struct Basis_bits)*BLOCKS);
428
429  struct Lex * lex = (struct Lex *)malloc(sizeof(struct Lex)*BLOCKS);
430
431  struct Parity parity;
432
433  struct Escape_Callouts escape_Callouts;
434
435  struct Out_Callouts out_Callouts;
436 
437  struct Marker marker;
438
439  BitBlock * marker_starts = (BitBlock *)malloc(sizeof(BitBlock)*BLOCKS);
440 
441  BitBlock * marker_ends = (BitBlock *)malloc(sizeof(BitBlock)*BLOCKS);
442
443  int block_base = 0;
444  int chars_read = 0;
445  int chars_avail = 0;
446  char * srcbuf = (char*)malloc(BUF_SIZE);
447  char * content_buf[MAX_CB];
448  content_buf[0] = (char*)malloc(BUF_SIZE*2);
449  char * content_buf_ptr =  content_buf[0];
450  int cb_idx = 0; 
451  ubitblock unitsums_per_reg[BLOCKS+1];
452  int at_start = 1;
453  int at_optr = 0;
454  int base_pos = 0;
455
456  unitsums_per_reg[0]._128 = simd<16>::constant<0>();
457  parity.odd = simd<2>::constant<1>();
458  parity.even = simd<2>::constant<2>();
459
460@stream_stmts
461
462  chars_read = fread((void *)srcbuf, 1, BUF_SIZE, infile);
463  chars_avail = chars_read; 
464 
465 
466 
467  s2p_do_block((BytePack *) &srcbuf[0], basis_bits[0]);
468  classify_bytes.do_block(basis_bits[0], lex[0]);
469
470while(chars_read){
471  // full buffer
472  if (chars_read == BUF_SIZE){
473   
474    for (int i = 1; i < BLOCKS; i++){
475      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
476      classify_bytes.do_block(basis_bits[i], lex[i]);
477    }
478
479    for (int i = 0; i < BLOCKS-1; i++){
480      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
481      match_Parens_With_Comments.do_block(lex[i], escape_Callouts, marker, out_Callouts);
482      parse_HexStrings.do_block(lex[i], marker, out_Callouts);
483      parse_Names.do_block(lex[i], marker, out_Callouts, lex[i+1]);
484      parse_Numeric.do_block(lex[i], marker, out_Callouts);
485      parse_Keywords.do_block(lex[i], marker, out_Callouts);
486      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker, parity, escape_Callouts, out_Callouts, lex[i+1]);
487      Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, i);
488      marker_starts[i] = marker.starts;
489      marker_ends[i] = marker.ends;
490    }
491       
492    chars_read = fread((void *)srcbuf, 1, BUF_SIZE, infile);
493    s2p_do_block((BytePack *) &srcbuf[0], basis_bits[0]);
494    classify_bytes.do_block(basis_bits[0], lex[0]);   
495    parse_Escaped.do_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, lex[0]);
496    match_Parens_With_Comments.do_block(lex[BLOCKS-1], escape_Callouts, marker, out_Callouts);
497    parse_HexStrings.do_block(lex[BLOCKS-1], marker, out_Callouts);
498    parse_Names.do_block(lex[BLOCKS-1], marker, out_Callouts, lex[0]);
499    parse_Numeric.do_block(lex[BLOCKS-1], marker, out_Callouts);
500    parse_Keywords.do_block(lex[BLOCKS-1], marker, out_Callouts);
501    prepare_content_buffer.do_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker, parity, escape_Callouts, out_Callouts, lex[0]);
502    Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, BLOCKS-1);
503    marker_starts[BLOCKS-1] = marker.starts;
504    marker_ends[BLOCKS-1] = marker.ends;
505
506    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); 
508//     ints_2_floats(numbers, dec_pl, num_rslt, num_idx);
509//      ints_x_floats(numbers, dec_pl, num_rslt, num_idx);
510//    simd_ints_2_floats(numbers, dec_pl, num_rslt, num_idx);
511    content_buf_ptr =  content_buf[cb_idx+1]+base_pos;
512    cb_idx++; 
513   
514  }
515 
516  //partial buffer
517  else{
518//      cout << "final buffer" << endl;
519    BLOCKS = chars_read/BLOCK_SIZE + 1;   
520 
521    for (int i = 1; i < BLOCKS; i++){
522      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
523      classify_bytes.do_block(basis_bits[i], lex[i]);
524    }
525   
526    for (int i = 0; i < BLOCKS-1; i++){
527      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
528      match_Parens_With_Comments.do_block(lex[i], escape_Callouts, marker, out_Callouts);
529      parse_HexStrings.do_block(lex[i], marker, out_Callouts);
530      parse_Names.do_block(lex[i], marker, out_Callouts, lex[i+1]);
531      parse_Numeric.do_block(lex[i], marker, out_Callouts);
532      parse_Keywords.do_block(lex[i], marker, out_Callouts);
533      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker, parity, escape_Callouts, out_Callouts, lex[i+1]);
534      Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, i);
535      marker_starts[i] = marker.starts;
536      marker_ends[i] = marker.ends;
537      chars_avail -= BLOCK_SIZE;
538    }
539     
540    /*final block*/
541//      cout << "final block" << endl;
542    EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
543    parse_Escaped.do_final_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
544    match_Parens_With_Comments.do_final_block(lex[BLOCKS-1], escape_Callouts, marker, out_Callouts, EOF_mask);
545    parse_HexStrings.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
546    parse_Names.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
547    parse_Numeric.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
548    parse_Keywords.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
549    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker, parity, escape_Callouts, out_Callouts, EOF_mask);
550    out_Callouts.delmask |= ~EOF_mask;         
551    Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, BLOCKS-1);
552    marker_starts[BLOCKS-1] = marker.starts;
553    marker_ends[BLOCKS-1] = marker.ends;
554    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); 
556    break;
557  }
558 
559  ints_x_floats(numbers, dec_pl, num_rslt, num_idx);
560}
561/*
562    print_register("marker.error",marker.error);
563   
564    for(int i=0;i<num_idx;i++)
565      printf("%i,%i\n",numbers[i],dec_pl[i]);*/
566/*   
567    for(int i=0; i<100;i++){
568      if(tokenArray[i].type==str_token){
569        printf("String: ");
570        for(int j=0; j<tokenArray[i].len; j++)
571          printf("%c",tokenArray[i].token.char_ptr[j]);
572        printf("\n");
573      }
574 
575      if(tokenArray[i].type==hex_token)
576        printf("Hex: %s\n",tokenArray[i].token.char_ptr);
577     
578      if(tokenArray[i].type==name_token){
579        printf("Name: ");
580        for(int j=0; j<tokenArray[i].len; j++)
581          printf("%c",tokenArray[i].token.char_ptr[j]);
582        printf("\n");
583      }
584     
585      if(tokenArray[i].type==int_token)
586        printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
587     
588      if(tokenArray[i].type==flt_token)
589        printf("Number: %f\n",num_rslt[tokenArray[i].token.idx]);
590     
591      if(tokenArray[i].type==kw_token){
592        printf("Key Word: ");
593        for(int j=0; j<tokenArray[i].len; j++)
594          printf("%c",tokenArray[i].token.char_ptr[j]);
595        printf("\n");
596      }
597    }
598   
599
600    for(int i=0;i<100;i++)  {
601        printf("len at %i is %i\n",i, optrArray[i].len);
602        for(int j=0; j<optrArray[i].len; j++)
603          printf("%c",optrArray[i].char_ptr[j]);
604        printf("\n");
605    }
606*/
607}
608
609
610int main(int argc, char * argv[]) {
611
612        char * infilename, * outfilename;
613        FILE *infile, *outfile;
614        struct stat fileinfo;
615
616        if (argc < 2) {
617                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
618                exit(-1);
619        }
620
621        infilename = argv[1];
622        stat(infilename, &fileinfo);
623        infile = fopen(infilename, "rb");
624        if (!infile) {
625                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
626                exit(-1);
627        }
628
629        if (argc < 3) outfile = stdout;
630        else {
631                outfilename = argv[2];
632                outfile = fopen(outfilename, "wb");
633                if (!outfile) {
634                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
635                        exit(-1);
636                }
637        }
638
639//      PERF_SEC_BIND(1);
640
641        PERF_SEC_INIT(s2p_lex_timer);
642        PERF_SEC_INIT(parser_timer);
643        PERF_SEC_INIT(postprocess_timer);
644
645        do_process(infile, outfile, fileinfo.st_size+1);
646
647        PERF_SEC_DUMP(s2p_lex_timer);
648        PERF_SEC_DUMP(parser_timer);
649        PERF_SEC_DUMP(postprocess_timer);
650
651        PERF_SEC_DESTROY(s2p_lex_timer);
652        PERF_SEC_DESTROY(parser_timer);
653        PERF_SEC_DESTROY(postprocess_timer);
654
655        fclose(infile);
656        fclose(outfile);
657
658        return(0);
659}
Note: See TracBrowser for help on using the repository browser.