source: proto/PDF/cb_template.cpp @ 3129

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

Bug fixes.

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