source: proto/PDF/cb_template.cpp @ 5322

Last change on this file since 5322 was 3251, checked in by cameron, 6 years ago

Decimal point bug fix

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