source: proto/PDF/cb_template.cpp @ 3136

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

use continuous output stream.

File size: 19.8 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 "../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]._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      BitBlockForwardIteratorWithBaseCounts16 iter_start;
272      BitBlockForwardIteratorWithBaseCounts16 iter_end;
273      iter_start.init(&(marker_starts[i]), unitsums_per_reg[i]._128);
274      iter_end.init(&(marker_ends[i]), unitsums_per_reg[i]._128);
275      BitBlockForwardIteratorWithBaseCounts16 end;
276      while(*iter_start != -1 || *iter_end != -1) {
277        if(at_start){
278          pos = block_pos + (*iter_start);
279          if (cb[pos]== 0x2f){ 
280            tokenArray[token_idx].type = name_token;
281            tokenArray[token_idx].token.char_ptr = &cb[pos];
282          }
283          else if(cb[pos]== 0x28){     
284            tokenArray[token_idx].type = str_token;
285            tokenArray[token_idx].token.char_ptr = &cb[pos];
286          }
287          else if (cb[pos]== 0x0c){     
288            tokenArray[token_idx].type = hex_token;
289            tokenArray[token_idx].token.char_ptr = &cb[pos];
290          }
291          else if (cb[pos]== '-' || cb[pos]== '+' || (cb[pos]>='0'&&cb[pos]<='9')){
292            Digit_postprocessing(cb, pos);
293          }
294          else if ( (cb[pos]== 'n' && cb[pos+1]== 'u' && cb[pos+2]== 'l'  && cb[pos+3]== 'l')
295            || (cb[pos]== 't' && cb[pos+1]== 'r' && cb[pos+2]== 'u'  && cb[pos+3]== 'e')
296            || (cb[pos]== 'f' && cb[pos+1]== 'a' && cb[pos+2]== 'l'  && cb[pos+3]== 's' && cb[pos+3]== 'e')){
297           
298            tokenArray[token_idx].type = kw_token;
299            tokenArray[token_idx].token.char_ptr = &cb[pos];   
300          }
301          else{
302            //operator
303            optrArray[optr_idx].char_ptr = &cb[pos];
304            optrArray[optr_idx].token_pos = token_idx-1;
305            at_optr = 1;
306          }
307          iter_start++;
308          at_start = 0;
309        }
310        else{
311          int len = block_pos + (*iter_end) - pos;     
312          if(at_optr){
313            optrArray[optr_idx].len = len;
314            optr_idx++;
315            at_optr = 0;
316          }
317          else{
318            tokenArray[token_idx].len = len;
319            token_idx++;
320          }
321          iter_end++; 
322          at_start = 1;
323        }
324      }
325    }   
326
327    block_pos += unitsums_per_reg[i]._16[7];
328  }
329  if(!at_start){
330    base_pos = cb_size - pos;
331//     if(base_pos<0){
332//       cout << "in markup " << cb_size << "," << pos << "," << base_pos << endl;
333//     }
334    memcpy(cb_new, &cb[pos], base_pos);
335  }
336  else
337    base_pos = 0;
338}
339
340#define MAX_CB  10000
341
342void do_process(FILE *infile, FILE *outfile, int filesize) {
343 
344  struct Basis_bits * basis_bits = (struct Basis_bits *)malloc(sizeof(struct Basis_bits)*BLOCKS);
345
346  struct Lex * lex = (struct Lex *)malloc(sizeof(struct Lex)*BLOCKS);
347
348  struct Parity parity;
349
350  struct Escape_Callouts escape_Callouts;
351
352  struct Out_Callouts out_Callouts;
353 
354  struct Marker marker;
355
356  BitBlock * marker_starts = (BitBlock *)malloc(sizeof(BitBlock)*BLOCKS);
357 
358  BitBlock * marker_ends = (BitBlock *)malloc(sizeof(BitBlock)*BLOCKS);
359
360  int block_base = 0;
361  int chars_read = 0;
362  int chars_avail = 0;
363  char * srcbuf = (char*)malloc(BUF_SIZE);
364  char * content_buf[MAX_CB];
365  content_buf[0] = (char*)malloc(BUF_SIZE*2);
366  char * content_buf_ptr =  content_buf[0];
367  int cb_idx = 0; 
368  ubitblock unitsums_per_reg[BLOCKS];
369  int at_start = 1;
370  int at_optr = 0;
371  int base_pos = 0;
372
373  parity.odd = simd<2>::constant<1>();
374  parity.even = simd<2>::constant<2>();
375
376@stream_stmts
377
378  chars_read = fread((void *)srcbuf, 1, BUF_SIZE, infile);
379  chars_avail = chars_read; 
380 
381 
382 
383  s2p_do_block((BytePack *) &srcbuf[0], basis_bits[0]);
384  classify_bytes.do_block(basis_bits[0], lex[0]);
385
386while(chars_read){
387  // full buffer
388  if (chars_read == BUF_SIZE){
389   
390    for (int i = 1; i < BLOCKS; i++){
391      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
392      classify_bytes.do_block(basis_bits[i], lex[i]);
393    }
394
395    for (int i = 0; i < BLOCKS-1; i++){
396      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
397      match_Parens_With_Comments.do_block(lex[i], escape_Callouts, marker, out_Callouts);
398      parse_HexStrings.do_block(lex[i], marker, out_Callouts);
399      parse_Names.do_block(lex[i], marker, out_Callouts, lex[i+1]);
400      parse_Numeric.do_block(lex[i], marker, out_Callouts);
401      parse_Keywords.do_block(lex[i], marker, out_Callouts);
402      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker, parity, escape_Callouts, out_Callouts, lex[i+1]);
403      Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, i);
404      marker_starts[i] = marker.starts;
405      marker_ends[i] = marker.ends;
406    }
407       
408    chars_read = fread((void *)srcbuf, 1, BUF_SIZE, infile);
409    s2p_do_block((BytePack *) &srcbuf[0], basis_bits[0]);
410    classify_bytes.do_block(basis_bits[0], lex[0]);   
411    parse_Escaped.do_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, lex[0]);
412    match_Parens_With_Comments.do_block(lex[BLOCKS-1], escape_Callouts, marker, out_Callouts);
413    parse_HexStrings.do_block(lex[BLOCKS-1], marker, out_Callouts);
414    parse_Names.do_block(lex[BLOCKS-1], marker, out_Callouts, lex[0]);
415    parse_Numeric.do_block(lex[BLOCKS-1], marker, out_Callouts);
416    parse_Keywords.do_block(lex[BLOCKS-1], marker, out_Callouts);
417    prepare_content_buffer.do_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker, parity, escape_Callouts, out_Callouts, lex[0]);
418    Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, BLOCKS-1);
419    marker_starts[BLOCKS-1] = marker.starts;
420    marker_ends[BLOCKS-1] = marker.ends;
421
422    content_buf[cb_idx+1] = (char*)malloc(BUF_SIZE*2);
423    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); 
424//     ints_2_floats(numbers, dec_pl, num_rslt, num_idx);
425//      ints_x_floats(numbers, dec_pl, num_rslt, num_idx);
426//    simd_ints_2_floats(numbers, dec_pl, num_rslt, num_idx);
427    content_buf_ptr =  content_buf[cb_idx+1]+base_pos;
428    cb_idx++; 
429   
430  }
431 
432  //partial buffer
433  else{
434//      cout << "final buffer" << endl;
435    BLOCKS = chars_read/BLOCK_SIZE + 1;   
436 
437    for (int i = 1; i < BLOCKS; i++){
438      s2p_do_block((BytePack *) &srcbuf[i*BLOCK_SIZE], basis_bits[i]);
439      classify_bytes.do_block(basis_bits[i], lex[i]);
440    }
441   
442    for (int i = 0; i < BLOCKS-1; i++){
443      parse_Escaped.do_block(lex[i], parity, escape_Callouts, out_Callouts, lex[i+1]);
444      match_Parens_With_Comments.do_block(lex[i], escape_Callouts, marker, out_Callouts);
445      parse_HexStrings.do_block(lex[i], marker, out_Callouts);
446      parse_Names.do_block(lex[i], marker, out_Callouts, lex[i+1]);
447      parse_Numeric.do_block(lex[i], marker, out_Callouts);
448      parse_Keywords.do_block(lex[i], marker, out_Callouts);
449      prepare_content_buffer.do_block(basis_bits[i], lex[i], marker, parity, escape_Callouts, out_Callouts, lex[i+1]);
450      Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, i);
451      marker_starts[i] = marker.starts;
452      marker_ends[i] = marker.ends;
453      chars_avail -= BLOCK_SIZE;
454    }
455     
456    /*final block*/
457//      cout << "final block" << endl;
458    EOF_mask = bitblock::srl(simd<1>::constant<1>(), convert(BLOCK_SIZE-chars_avail));
459    parse_Escaped.do_final_block(lex[BLOCKS-1], parity, escape_Callouts, out_Callouts, EOF_mask);
460    match_Parens_With_Comments.do_final_block(lex[BLOCKS-1], escape_Callouts, marker, out_Callouts, EOF_mask);
461    parse_HexStrings.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
462    parse_Names.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
463    parse_Numeric.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
464    parse_Keywords.do_final_block(lex[BLOCKS-1], marker, out_Callouts, EOF_mask);
465    prepare_content_buffer.do_final_block(basis_bits[BLOCKS-1], lex[BLOCKS-1], marker, parity, escape_Callouts, out_Callouts, EOF_mask);
466    out_Callouts.delmask |= ~EOF_mask;         
467    Build_ContentBuffer(out_Callouts, marker, &content_buf_ptr, unitsums_per_reg, BLOCKS-1);
468    marker_starts[BLOCKS-1] = marker.starts;
469    marker_ends[BLOCKS-1] = marker.ends;
470    content_buf[cb_idx+1] = (char*)malloc(BUF_SIZE*2);
471    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); 
472    break;
473  }
474}
475/*
476    print_register("marker.error",marker.error);
477   
478    for(int i=0;i<num_idx;i++)
479      printf("%i,%i\n",numbers[i],dec_pl[i]);*/
480   
481    for(int i=0; i<100;i++){
482      if(tokenArray[i].type==str_token){
483        printf("String: ");
484        for(int j=0; j<tokenArray[i].len; j++)
485          printf("%c",tokenArray[i].token.char_ptr[j]);
486        printf("\n");
487      }
488 
489      if(tokenArray[i].type==hex_token)
490        printf("Hex: %s\n",tokenArray[i].token.char_ptr);
491     
492      if(tokenArray[i].type==name_token){
493        printf("Name: ");
494        for(int j=0; j<tokenArray[i].len; j++)
495          printf("%c",tokenArray[i].token.char_ptr[j]);
496        printf("\n");
497      }
498     
499      if(tokenArray[i].type==int_token)
500        printf("Number: %i\n",numbers[tokenArray[i].token.idx]);
501     
502      if(tokenArray[i].type==flt_token)
503        printf("Number: %f\n",num_rslt[tokenArray[i].token.idx]);
504     
505      if(tokenArray[i].type==kw_token){
506        printf("Key Word: ");
507        for(int j=0; j<tokenArray[i].len; j++)
508          printf("%c",tokenArray[i].token.char_ptr[j]);
509        printf("\n");
510      }
511    }
512   
513/*
514    for(int i=0;i<100;i++)  {
515        printf("len at %i is %i\n",i, optrArray[i].len);
516        for(int j=0; j<optrArray[i].len; j++)
517          printf("%c",optrArray[i].char_ptr[j]);
518        printf("\n");
519    }*/
520
521}
522
523
524int main(int argc, char * argv[]) {
525
526        char * infilename, * outfilename;
527        FILE *infile, *outfile;
528        struct stat fileinfo;
529
530        if (argc < 2) {
531                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
532                exit(-1);
533        }
534
535        infilename = argv[1];
536        stat(infilename, &fileinfo);
537        infile = fopen(infilename, "rb");
538        if (!infile) {
539                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
540                exit(-1);
541        }
542
543        if (argc < 3) outfile = stdout;
544        else {
545                outfilename = argv[2];
546                outfile = fopen(outfilename, "wb");
547                if (!outfile) {
548                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
549                        exit(-1);
550                }
551        }
552
553//      PERF_SEC_BIND(1);
554
555        PERF_SEC_INIT(s2p_lex_timer);
556        PERF_SEC_INIT(parser_timer);
557        PERF_SEC_INIT(postprocess_timer);
558
559        do_process(infile, outfile, fileinfo.st_size+1);
560
561        PERF_SEC_DUMP(s2p_lex_timer);
562        PERF_SEC_DUMP(parser_timer);
563        PERF_SEC_DUMP(postprocess_timer);
564
565        PERF_SEC_DESTROY(s2p_lex_timer);
566        PERF_SEC_DESTROY(parser_timer);
567        PERF_SEC_DESTROY(postprocess_timer);
568
569        fclose(infile);
570        fclose(outfile);
571
572        return(0);
573}
Note: See TracBrowser for help on using the repository browser.