source: proto/PDF/cb_template.cpp @ 2957

Last change on this file since 2957 was 2957, checked in by lindanl, 7 years ago

Read one segment at a time

File size: 18.7 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 "../../simd-lib/bitblock_iterator.hpp"
13#include "../../simd-lib/pabloSupport.hpp"
14#include "../../simd-lib/s2p.hpp"
15#include "../../simd-lib/p2s.hpp"
16#include <math.h>
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};
48
49static inline int Digit_postprocessing(char * source, int pos);
50
51@global
52
53static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits);
54static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask);
55
56void do_process(FILE *infile, FILE *outfile, int filesize);
57
58enum PDFTokenType {
59  str_token,
60  hex_token,
61  name_token,
62  int_token,
63  flt_token,
64  kw_token
65};
66
67union PDFToken { char * char_ptr; int idx;};
68
69typedef struct tokenStruct{
70  union PDFToken token;
71  int len;
72  enum PDFTokenType type;
73} TokenStruct;
74
75TokenStruct tokenArray[1000000];
76int token_idx=0;
77
78#define MAX_NUM 1000000
79int numbers[MAX_NUM];
80int dec_pl[MAX_NUM];
81int num_idx=0;
82
83static inline int Digit_postprocessing(char * source, int pos) {
84    bool negative= false;
85    int num = 0;
86    int start_pos = -1;
87    if (source[pos] == '-')     {
88      pos++;
89      negative = true;
90    }
91    else if (source[pos] == '+')
92      pos++;
93
94    while ('0' <= source[pos] && source[pos] <= '9' || source[pos]=='.'){
95      if(source[pos]=='.'){
96        pos++;
97        start_pos = pos;
98        continue;
99      }
100      num = num * 10 + source[pos] - '0';
101      pos++;
102    }
103    if (negative) (num) = -(num);
104    numbers[num_idx] = num;
105    if(start_pos!=-1){
106      dec_pl[num_idx] = pow_ten[pos - start_pos];
107      tokenArray[token_idx].type = flt_token;
108      tokenArray[token_idx].token.idx = num_idx;
109    }
110    else{
111      dec_pl[num_idx] = 1;
112      tokenArray[token_idx].type = int_token;
113      tokenArray[token_idx].token.idx = num_idx;
114    }
115    num_idx++;
116}
117
118/* s2p Definitions */
119static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
120  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
121        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);
122}
123
124static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
125  s2p_do_block(U8, basis_bits);
126  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
127  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
128  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
129  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
130  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
131  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
132  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
133  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
134}
135
136#define do_right16_shifts(vec,rshift1,rshift2,rshift4,rshift8)  \
137{BitBlock s2; \
138vec= simd<16>::sub(vec,simd<16>::srli<1>(simd_and(rshift1,vec)) ) ; \
139s2= simd_and(rshift2,vec) ; \
140vec= simd_or(simd<16>::srli<2>(s2) ,simd_xor(vec,s2) ) ; \
141s2= simd_and(rshift4,vec) ; \
142vec= simd_or(simd<16>::srli<4>(s2) ,simd_xor(vec,s2) ) ; \
143s2= simd_and(rshift8,vec) ; \
144vec= simd_or(simd<16>::srli<8>(s2) ,simd_xor(vec,s2) ) ; \
145}
146
147static inline void delinfo_16(BitBlock & del16_rshift1, BitBlock & del16_rshift2, BitBlock & del16_rshift4,
148                              BitBlock & del16_rshift8, BitBlock delmask){
149       
150        BitBlock del16_trans2;
151        BitBlock del16_trans4;
152        BitBlock del16_trans8;
153        BitBlock shift_bits;
154       
155        del16_rshift1= simd_xor(simd<16>::slli<1>(delmask),simd<16>::slli<2>(delmask));
156        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<2>(del16_rshift1));
157        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<4>(del16_rshift1));
158        del16_rshift1= simd_xor(del16_rshift1,simd<16>::slli<8>(del16_rshift1));
159       
160        del16_trans2= simd_and(del16_rshift1,delmask);
161        del16_rshift2= simd_xor(simd<16>::slli<1>(del16_trans2),simd<16>::slli<2>(del16_trans2));
162        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<2>(del16_rshift2));
163        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<4>(del16_rshift2));
164        del16_rshift2= simd_xor(del16_rshift2,simd<16>::slli<8>(del16_rshift2));
165       
166        del16_trans4= simd_and(del16_rshift2,del16_trans2);
167        del16_rshift4= simd_xor(simd<16>::slli<1>(del16_trans4),simd<16>::slli<2>(del16_trans4));
168        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<2>(del16_rshift4));
169        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<4>(del16_rshift4));
170        del16_rshift4= simd_xor(del16_rshift4,simd<16>::slli<8>(del16_rshift4));
171       
172        del16_trans8= simd_and(del16_rshift4,del16_trans4);
173        del16_rshift8= simd_xor(simd<16>::slli<1>(del16_trans8),simd<16>::slli<2>(del16_trans8));
174        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<2>(del16_rshift8));
175        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<4>(del16_rshift8));
176        del16_rshift8= simd_xor(del16_rshift8,simd<16>::slli<8>(del16_rshift8));
177       
178        del16_rshift1= simd_andc(del16_rshift1,delmask);
179        del16_rshift2= simd_andc(del16_rshift2,delmask);
180        del16_rshift4= simd_andc(del16_rshift4,delmask);
181        del16_rshift8= simd_andc(del16_rshift8,delmask);
182       
183        del16_rshift2= simd<16>::sub(del16_rshift2,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift2)));
184       
185        del16_rshift4= simd<16>::sub(del16_rshift4,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift4)));
186        shift_bits= simd_and(del16_rshift2,del16_rshift4);
187        del16_rshift4= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift4,shift_bits));
188       
189        del16_rshift8= simd<16>::sub(del16_rshift8,simd<16>::srli<1>(simd_and(del16_rshift1,del16_rshift8)));
190        shift_bits= simd_and(del16_rshift2,del16_rshift8);
191        del16_rshift8= simd_or(simd<16>::srli<2>(shift_bits),simd_xor(del16_rshift8,shift_bits));       
192        shift_bits= simd_and(del16_rshift4,del16_rshift8);
193        del16_rshift8= simd_or(simd<16>::srli<4>(shift_bits),simd_xor(del16_rshift8,shift_bits));
194}
195
196static inline void del_count(BitBlock delmask, BitBlock & u8_bytes_per_reg){
197
198        BitBlock delcounts_16 = simd<16>::popcount(delmask);
199        u8_bytes_per_reg = simd<16>::sub(simd<16>::constant<16>(), delcounts_16);
200}
201
202static inline void Build_ContentBuffer(Out_Callouts out_Callouts, Marker & marker, char ** content_buf_ptr, int * del_sum, int blk){
203   
204    BytePack S[8];
205
206    if (bitblock::any(out_Callouts.delmask)) {
207            BitBlock shift1, shift2, shift4, shift8;
208            delinfo_16(shift1, shift2, shift4, shift8, out_Callouts.delmask);
209            do_right16_shifts(out_Callouts.bit_0, shift1, shift2, shift4, shift8);
210            do_right16_shifts(out_Callouts.bit_1, shift1, shift2, shift4, shift8);
211            do_right16_shifts(out_Callouts.bit_2, shift1, shift2, shift4, shift8);
212            do_right16_shifts(out_Callouts.bit_3, shift1, shift2, shift4, shift8);
213            do_right16_shifts(out_Callouts.bit_4, shift1, shift2, shift4, shift8);
214            do_right16_shifts(out_Callouts.bit_5, shift1, shift2, shift4, shift8);
215            do_right16_shifts(out_Callouts.bit_6, shift1, shift2, shift4, shift8);
216            do_right16_shifts(out_Callouts.bit_7, shift1, shift2, shift4, shift8);
217            do_right16_shifts(marker.starts, shift1, shift2, shift4, shift8);
218            do_right16_shifts(marker.ends, shift1, shift2, shift4, shift8);
219        }
220
221        union {BitBlock i128; uint16_t i8[8];} units_per_reg;
222       
223        p2s(out_Callouts.bit_0,out_Callouts.bit_1,out_Callouts.bit_2,out_Callouts.bit_3,
224            out_Callouts.bit_4,out_Callouts.bit_5,out_Callouts.bit_6,out_Callouts.bit_7,
225                          S[0], S[1],S[2] ,S[3] ,S[4] ,S[5] ,S[6] ,S[7]);
226         
227        for(int k=0; k<8; k++) units_per_reg.i8[k] = 0;
228        del_count(out_Callouts.delmask,units_per_reg.i128);
229        for(int k=0; k<8; k++) {
230            del_sum[blk*8+k+1] = del_sum[blk*8+k] + (16-units_per_reg.i8[k]);
231        }
232
233        for(int j=0; j<8; j++){
234          bitblock::store_unaligned(S[j], (BytePack *) *content_buf_ptr);
235          *content_buf_ptr += units_per_reg.i8[j];
236        }
237}
238
239static inline void Postprocessing(char* cb, int cb_size, char* cb_new, Marker * marker, int * del_sum, int & at_start, int & base_pos){   
240     
241  int pos = 0;
242 
243  if(!at_start){ 
244    if (tokenArray[token_idx].type == name_token || 
245        tokenArray[token_idx].type == str_token || 
246        tokenArray[token_idx].type == hex_token ||
247        tokenArray[token_idx].type == kw_token){
248      tokenArray[token_idx].token.char_ptr = cb;
249    }
250    else{
251      num_idx--;
252      Digit_postprocessing(cb, 0);
253    }
254  }
255
256   
257  int block_pos = base_pos;
258  for(int i=0; i<BLOCKS; i++){
259    if(bitblock::any(simd_or(marker[i].starts,marker[i].ends))){
260      BitBlockForwardIterator iter_start;
261      BitBlockForwardIterator iter_end;
262      iter_start.init(&(marker[i].starts));
263      iter_end.init(&(marker[i].ends));
264      BitBlockForwardIterator end;
265      while(iter_start != end || iter_end != end) {
266        if(at_start){
267          pos = block_pos + (*iter_start);
268          pos = pos - del_sum[i*8 + (*iter_start)/16];
269          if (cb[pos]== 0x2f){ 
270            tokenArray[token_idx].type = name_token;
271            tokenArray[token_idx].token.char_ptr = &cb[pos];
272          }
273          else if(pos>0 && cb[pos-1]== 0x28){   
274            tokenArray[token_idx].type = str_token;
275            tokenArray[token_idx].token.char_ptr = &cb[pos];
276          }
277          else if (cb[pos]== 0x0c){     
278            tokenArray[token_idx].type = hex_token;
279            tokenArray[token_idx].token.char_ptr = &cb[pos];
280          }
281          else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
282            Digit_postprocessing(cb, pos);
283          }
284          else {
285            tokenArray[token_idx].type = kw_token;
286            tokenArray[token_idx].token.char_ptr = &cb[pos];   
287          }
288          iter_start++;
289          at_start = 0;
290        }
291        else{   
292          tokenArray[token_idx].len = base_pos + i*BLOCK_SIZE + (*iter_end) - pos;
293          iter_end++;
294          token_idx++;   
295          at_start = 1;
296        }
297      }
298    } 
299    block_pos += BLOCK_SIZE - del_sum[i*8+7];
300  }
301  if(!at_start){
302    base_pos = cb_size - pos;
303    if(base_pos<0){
304      cout << "in markup " << cb_size << "," << pos << "," << base_pos << endl;
305    }
306    memcpy(cb_new, cb, base_pos);
307  }
308  else
309    base_pos = 0;
310//   cout << cb_size << "," << pos << "," << base_pos << endl; 
311}
312
313#define MAX_CB  10000
314
315void do_process(FILE *infile, FILE *outfile, int filesize) {
316 
317  struct Basis_bits * basis_bits = (struct Basis_bits *)malloc(sizeof(struct Basis_bits)*BLOCKS);
318
319  struct Lex * lex = (struct Lex *)malloc(sizeof(struct Lex)*BLOCKS);
320
321  struct Parity parity;
322
323  struct Escape_Callouts escape_Callouts;
324
325  struct Out_Callouts out_Callouts;
326
327  struct Marker * marker = (struct Marker *)malloc(sizeof(struct Marker)*BLOCKS);
328
329  int block_base = 0;
330  int chars_read = 0;
331  int chars_avail = 0;
332  char * srcbuf = (char*)malloc(BUF_SIZE);
333  char * content_buf[MAX_CB];
334  content_buf[0] = (char*)malloc(BUF_SIZE*2);
335  char * content_buf_ptr =  content_buf[0];
336  int cb_idx = 0; 
337  int del_sum[BLOCKS*8];
338  del_sum[0] = 0;
339  int at_start = 1;
340  int base_pos = 0;
341
342  parity.odd = simd<2>::constant<1>();
343  parity.even = simd<2>::constant<2>();
344
345@stream_stmts
346
347  chars_read = fread((void *)srcbuf, 1, BUF_SIZE, infile);
348  chars_avail = chars_read; 
349 
350 
351 
352  s2p_do_block((BytePack *) &srcbuf[0], basis_bits[0]);
353  classify_bytes.do_block(basis_bits[0], lex[0]);
354
355while(chars_read){
356  // full buffer
357  if (chars_read == BUF_SIZE){
358   
359    for (int i = 1; i < BLOCKS; i++){
360      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
361      classify_bytes.do_block(basis_bits[i], lex[i]);
362    }
363
364    for (int i = 0; i < BLOCKS-1; i++){
365      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
366      parse_Comment.do_block(lex[i], escape_Callouts, marker[i], out_Callouts);
367      parse_String.do_block(escape_Callouts, marker[i], out_Callouts);
368      parse_HexStrings.do_block(lex[i], marker[i], out_Callouts);
369      parse_Names.do_block(lex[i], marker[i], out_Callouts, lex[i+1]);
370      parse_Numeric.do_block(lex[i], marker[i], out_Callouts);
371      parse_Keywords.do_block(lex[i], marker[i], out_Callouts);
372      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
373      Build_ContentBuffer(out_Callouts, marker[i], &content_buf_ptr, del_sum, i);
374    }
375       
376    chars_read = fread((void *)srcbuf, 1, BUF_SIZE, infile);
377    s2p_do_block((BytePack *) &srcbuf[0], basis_bits[0]);
378    classify_bytes.do_block(basis_bits[0], lex[0]);   
379    parse_Escaped.do_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, lex[0]);
380    parse_Comment.do_block(lex[BLOCKS-1], escape_Callouts, marker[BLOCKS-1], out_Callouts);
381    parse_String.do_block(escape_Callouts, marker[BLOCKS-1], out_Callouts);
382    parse_HexStrings.do_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts);
383    parse_Names.do_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, lex[0]);
384    parse_Numeric.do_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts);
385    parse_Keywords.do_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts);
386    prepare_content_buffer.do_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker[BLOCKS-1], parity, escape_Callouts, out_Callouts, lex[0]);
387    Build_ContentBuffer(out_Callouts, marker[BLOCKS-1], &content_buf_ptr, del_sum, BLOCKS-1);
388   
389    content_buf[cb_idx+1] = (char*)malloc(BUF_SIZE*2);
390    Postprocessing(content_buf[cb_idx], content_buf_ptr-content_buf[cb_idx], content_buf[cb_idx+1], marker, del_sum, at_start, base_pos); 
391     fwrite(content_buf[cb_idx], 1, content_buf_ptr-content_buf[cb_idx], outfile);
392    content_buf_ptr =  content_buf[cb_idx+1]+base_pos;
393    cb_idx++;     
394   
395   
396  }
397 
398  //partial buffer
399  else{
400//     cout << "final buffer" << endl;
401    BLOCKS = chars_read/BLOCK_SIZE + 1;   
402 
403    for (int i = 1; i < BLOCKS; i++){
404      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
405      classify_bytes.do_block(basis_bits[i], lex[i]);
406    }
407   
408    for (int i = 0; i < BLOCKS-1; i++){
409      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
410      parse_Comment.do_block(lex[i], escape_Callouts, marker[i], out_Callouts);
411      parse_String.do_block(escape_Callouts, marker[i], out_Callouts);
412      parse_HexStrings.do_block(lex[i], marker[i], out_Callouts);
413      parse_Names.do_block(lex[i], marker[i], out_Callouts, lex[i+1]);
414      parse_Numeric.do_block(lex[i], marker[i], out_Callouts);
415      parse_Keywords.do_block(lex[i], marker[i], out_Callouts);
416      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
417      Build_ContentBuffer(out_Callouts, marker[i], &content_buf_ptr, del_sum, i);
418      chars_avail -= BLOCK_SIZE;
419    }
420     
421    /*final block*/
422//      cout << "final block" << endl;
423    EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
424    parse_Escaped.do_final_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
425    parse_Comment.do_final_block(lex[BLOCKS-1], escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
426    parse_String.do_final_block(escape_Callouts, marker[BLOCKS-1], out_Callouts, EOF_mask);
427    parse_HexStrings.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
428    parse_Names.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
429    parse_Numeric.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
430    parse_Keywords.do_final_block(lex[BLOCKS-1], marker[BLOCKS-1], out_Callouts, EOF_mask);
431    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
432    out_Callouts.delmask |= ~EOF_mask;         
433    Build_ContentBuffer(out_Callouts, marker[BLOCKS-1], &content_buf_ptr, del_sum, BLOCKS-1);
434    content_buf[cb_idx+1] = (char*)malloc(BUF_SIZE*2);
435    Postprocessing(content_buf[cb_idx], content_buf_ptr-content_buf[cb_idx], content_buf[cb_idx+1], marker, del_sum, at_start, base_pos); 
436    break;
437  }
438}
439
440//      print_register("marker.error",marker.error);
441//   
442//     for(int i=0;i<num_idx;i++)
443//       printf("%i,%i\n",numbers[i],dec_pl[i]);
444/*   
445    for(int i=0; i<10;i++){
446      if(tokenArray[i].type==str_token){
447        printf("String: ");
448        for(int j=0; j<tokenArray[i].len; j++)
449          printf("%c",tokenArray[i].token.char_ptr[j]);
450        printf("\n");
451      }
452 
453      if(tokenArray[i].type==hex_token)
454        printf("Hex: %s\n",tokenArray[i].token.char_ptr);
455     
456      if(tokenArray[i].type==name_token){
457        printf("Name: ");
458        for(int j=0; j<tokenArray[i].len; j++)
459          printf("%c",tokenArray[i].token.char_ptr[j]);
460        printf("\n");
461      }
462     
463      if(tokenArray[i].type==int_token)
464        printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
465     
466      if(tokenArray[i].type==flt_token)
467        printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
468     
469      if(tokenArray[i].type==kw_token){
470        printf("Key Word: ");
471        for(int j=0; j<tokenArray[i].len; j++)
472          printf("%c",tokenArray[i].token.char_ptr[j]);
473        printf("\n");
474      }
475
476    }*/
477     
478
479}
480
481
482int main(int argc, char * argv[]) {
483
484        char * infilename, * outfilename;
485        FILE *infile, *outfile;
486        struct stat fileinfo;
487
488        if (argc < 2) {
489                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
490                exit(-1);
491        }
492
493        infilename = argv[1];
494        stat(infilename, &fileinfo);
495        infile = fopen(infilename, "rb");
496        if (!infile) {
497                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
498                exit(-1);
499        }
500
501        if (argc < 3) outfile = stdout;
502        else {
503                outfilename = argv[2];
504                outfile = fopen(outfilename, "wb");
505                if (!outfile) {
506                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
507                        exit(-1);
508                }
509        }
510
511//      PERF_SEC_BIND(1);
512
513        PERF_SEC_INIT(s2p_lex_timer);
514        PERF_SEC_INIT(parser_timer);
515        PERF_SEC_INIT(postprocess_timer);
516
517        do_process(infile, outfile, fileinfo.st_size+1);
518
519        PERF_SEC_DUMP(s2p_lex_timer);
520        PERF_SEC_DUMP(parser_timer);
521        PERF_SEC_DUMP(postprocess_timer);
522
523        PERF_SEC_DESTROY(s2p_lex_timer);
524        PERF_SEC_DESTROY(parser_timer);
525        PERF_SEC_DESTROY(postprocess_timer);
526
527        fclose(infile);
528        fclose(outfile);
529
530        return(0);
531}
Note: See TracBrowser for help on using the repository browser.