source: proto/xmlschema/validation_template_onevec.cpp @ 3529

Last change on this file since 3529 was 3353, checked in by shiyangy, 6 years ago

template modified, validation_functions file added

File size: 51.7 KB
Line 
1
2#include <simd-lib/bitblock.hpp>
3#include <simd-lib/carryQ.hpp>
4#include <simd-lib/pabloSupport.hpp>
5
6#define LocalCarryDeclare(name, count)\
7CarryArray<count, 0> name;\
8
9#define assert_0_error(errkind, errstrm)
10
11BitBlock EOF_mask = simd<1>::constant<1>();
12
13//#define USE_FUNCTION_TEMPLATES
14//#define TEMPLATED_SIMD_LIB
15
16#define DEBUG 1
17//#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
18//#define SEGMENT_BLOCKS 12
19//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
20//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
21
22#define VECTOR_WIDTH 8
23#define VECTOR_TYPE (char)
24
25#include <stdio.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <sys/types.h>
29#include <sys/stat.h>
30#include <limits.h>
31
32#include <simd-lib/s2p.hpp>
33#include <simd-lib/buffer.hpp>
34#include <simd-lib/bitblock_iterator.hpp>
35#include <simd-lib/perflib/perfsec.h>
36
37//#include "../lib/lib_simd.h"
38#include "../symtab/pbgs_identity_symbol_table.h"
39
40#include <stack>
41#include <map>
42#include <vector>
43
44#include <queue>
45#include <string>
46
47typedef long ScanBlock;
48typedef BytePack BitBlock;
49
50using namespace std;
51
52//#include "../lib/carryQ.h"
53#include <xmldecl.h>
54//#include "xml_error.c"
55//#include "xmldecl.c"
56#include <namechars.h>
57#include <LineColTracker.hpp>
58#include <XMLTestSuiteError.h>
59
60// Define the mappings for pablo.assert_0(strm, errkind) statements which
61// compile to the the form assert_0_error(errkind, strm)
62#include <ErrorTracker.h>
63
64ErrorTracker error_tracker;
65#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
66
67#ifndef STL_ALIGNED_VECTOR
68#include <TagMatcher.hpp>
69#endif
70
71#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
72#warning "Compiling with experimental STL_ALIGNED_VECTOR."
73#include <vector>
74#include <simd-lib/stl_aligned_allocator.hpp>
75#endif
76
77#ifdef BUFFER_PROFILING
78        BOM_Table * parser_timer;
79
80#elif CODE_CLOCKER
81        #define NUM_EVENTS 1
82        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
83        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
84        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
85        int cal_size = 20;
86        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
87#else
88        void * parser_timer;
89#endif
90
91//////////////////////////////////////////////////////////////////////////////////////////
92// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
93//////////////////////////////////////////////////////////////////////////////////////////
94#define PADDING_BLOCKS 0
95#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
96#define COPYBACK_BLOCKS 2
97#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
98#define LOOKAHEAD_BLOCKS 1
99#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
100#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
101#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
102#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
103
104
105
106//int block_base=0;
107//int buffer_base=0;
108int buffer_last;
109FILE *gid_writein;
110#define ELEMENT_BUFFER_SIZE 30
111char element_name_buffer[ELEMENT_BUFFER_SIZE];
112int cross_buffer_flag = 0;
113//char * source;
114LineColTracker tracker;
115
116static inline int cfzl(long x){
117        unsigned long ux = x;
118        if (x<0){
119                ux = ULONG_MAX + x + 1;
120        }
121        if (ux==0)
122                return 8*sizeof(long);
123        int n;
124        n = 0;
125        while (1){
126                if ((ux%2) == 1){
127                        if(n==64){
128//                              cout << ux <<endl;
129                        }
130                        return n;               
131                }
132                n ++;
133                ux = ux >> 1;
134                //cout << "x = " << x << endl;
135        } 
136}
137
138static inline void print_gid_vec();
139/*
140static inline int cfzl(long x){
141 if (x ==0)
142  return 32;
143 int n=0;
144 if ((x & 0xFFFF0000) == 0) { n += 16; x =x << 16;} //1111 1111 1111 1111 0000 0000 0000 0000 // 16 bits from left are zero! so we omit 16left bits
145 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
146 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
147 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
148 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
149 return n;
150
151}
152*/
153static inline void ReportError(const char * error_msg, int error_pos_in_block) {
154  int error_line, error_column;
155  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
156  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
157}
158/*
159class ErrorTracker {
160public:
161    ErrorTracker() { noted_pos_in_block = -1;}
162
163    inline void NoteError(const char * error_msg, BitBlock err_strm) {
164      int pos_in_block = count_forward_zeroes(err_strm);
165      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
166        noted_pos_in_block = pos_in_block;
167        noted_error = error_msg;
168      }
169    }
170
171    inline void If_Error_Report_First() {
172      if (noted_pos_in_block > -1) {
173              int error_line, error_column;
174              ReportError(noted_error, noted_pos_in_block);
175              exit(-1);
176      }
177    }
178
179private:
180  const char * noted_error;
181  int noted_pos_in_block;
182};
183*/
184
185
186//BitBlock EOF_mask = simd_const_1(1);
187
188//ErrorTracker error_tracker;
189BitBlock elem_starts;
190int previous_block_last_elem_start;
191BytePack hashvalues[2];
192
193vector <int> gids;
194PBGSIdentitySymbolTable pbgs_symbol_table;
195
196#define MAX_COUNT 128
197vector <char> gid_vec[MAX_COUNT];
198int current_depth = 0;
199vector <int> pre_index;
200
201stack <vector<char>* > elem_vec_stack;
202map<char, vector<char>* > elem_vec_map;
203
204static inline int ScanBackwardPos(BitBlock * block, int pos)
205{
206//      cout << "pos " << pos << endl;
207    BitBlock s = block[0];
208    if (bitblock::any(block[0])){
209//      print_register("zero",block[0]);
210//      print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
211        }
212    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
213//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
214//              print_register("temp",temp);
215    if (bitblock::any(temp))
216    {
217        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
218//      cout << "block_size" << BLOCK_SIZE << endl;
219        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
220    }
221    else
222    {
223        //handle boundary case
224        return previous_block_last_elem_start - 1;
225    }
226}
227
228static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
229        int blk;
230        int block_pos = 0;
231        for (blk = 0; blk < blk_count; blk++) {
232                ScanBlock s = stream[blk];
233                while(s) {
234                        int code = (ProcessPos(cfzl(s) + block_pos));
235                        if (code) return code;
236                        s = s & (s-1);  // clear rightmost bit.
237                }
238                block_pos += 8 * sizeof(ScanBlock);
239        }
240        return 0;
241}
242
243static inline int compute_hash_value2(char *str,int lgth){
244        int hash = 5381;
245    int c;
246//      while (c = *str++){
247        for (int i = 0;i<lgth;i++){
248                c=*str++; 
249        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
250    }
251
252    return hash;
253}
254
255static inline int compute_hash_value (int lgth, int start)
256{
257    unsigned int offset_bit = start + 128;
258    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
259    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
260}
261/*
262template <int L>
263static inline int ElemEnd_grouping(int pos) {
264    int end = block_base + pos;
265    int start = end - L;
266    int hashvalue = compute_hash_value(L, start - block_base);
267    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
268    gids.push_back(gid);
269#if DEBUG
270    char* symbol = new char[L+1];
271    strncpy ( symbol, source + start, L );
272    symbol[L] ='\0';
273    printf ("%s | start: %i[%i] | end: %i[%i] | gid: %i | hashvalue: %i | symbol: %s\n", __FUNCTION__, start, start-buffer_base, end, end-buffer_base, gid, hashvalue, symbol );
274    delete symbol; symbol = 0;
275#endif
276    return gid;
277}
278
279template<>
280inline int ElemEnd_grouping<17>(int pos) {
281    int end = block_base + pos;
282    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
283    int lgth = end - start;
284    int hashvalue = compute_hash_value(lgth, start - block_base);
285    int gid = 0;
286
287//    if (lgth < 32)
288//    {
289//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
290//    }
291//    else
292    {
293        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
294    }
295    gids.push_back(gid);
296#if DEBUG
297    char* symbol = new char[lgth+1];
298    strncpy ( symbol, source + start, lgth );
299    symbol[lgth] ='\0';
300    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
301#endif
302    return gid;
303}
304*/
305
306inline char ElemEnd_grouping(char *source,int block_base,int pos) {
307    int end = block_base + pos;
308    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
309    ///////////////////////
310    //start could be negitive
311    //the element name falls in two buffers
312    ///////////////////////
313    char *name = source + start;
314    char name_buffer[50];
315   
316    if (start<0){
317            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
318        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
319        memmove (&name_buffer[-start],&source[0],50+start);
320        name = name_buffer;
321        //fprintf (gid_writein,"name_buffer %s",name);
322        fprintf(gid_writein,"name_buffer %s\n",name);
323    }
324//    cout << end << "  " << start << endl;
325    int lgth = end - start;
326//    int hashvalue = compute_hash_value(lgth,start-block_base);
327        int hashvalue = compute_hash_value2(name,lgth);
328    char gid = 0;
329
330
331//    if (lgth < 32)
332//    {
333//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
334//    }
335//    else
336
337        switch (lgth)
338    {
339    case 1:
340        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(name, hashvalue);
341        break;
342    case 2:
343        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(name, hashvalue);
344        break;
345    case 3:
346        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(name, hashvalue);
347        break;
348    case 4:
349        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(name, hashvalue);
350        break;
351    case 5:
352        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(name, hashvalue);
353        break;
354    case 6:
355        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(name, hashvalue);
356        break;
357    case 7:
358        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(name, hashvalue);
359        break;
360    case 8:
361        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(name, hashvalue);
362        break;
363    case 9:
364        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(name, hashvalue);
365        break;
366    case 10:
367        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(name, hashvalue);
368        break;
369    case 11:
370        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(name, hashvalue);
371        break;
372    case 12:
373        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(name, hashvalue);
374        break;
375    case 13:
376        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(name, hashvalue);
377        break;
378    case 14:
379        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(name, hashvalue);
380        break;
381    case 15:
382        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(name, hashvalue);
383        break;
384    case 16:
385        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(name, hashvalue);
386        break;
387    default:
388        gid = pbgs_symbol_table.Lookup_or_Insert_Name(name, hashvalue, lgth);
389        break;
390    }
391/*
392    {
393        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
394    }
395*/
396    gids.push_back(gid);
397#if DEBUG
398    char* symbol = new char[lgth+1];
399    strncpy ( symbol, source + start, lgth );
400    symbol[lgth] ='\0';
401//    printf ("%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
402    fprintf (gid_writein,"%s | start: %i[%i] | end: %i[%i] | lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__, start, start - block_base, end, end - block_base, lgth, hashvalue, gid, symbol);
403#endif
404    return gid;
405}
406
407//template <int L>
408static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count) {
409    int blk;
410    int block_pos = 0;
411//    cout << "cfzl():" << cfzl() << endl;
412//      long test = 6;
413//      test = (test & (test - 1));
414//      cout << "test" << endl;
415    for (blk = 0; blk < blk_count; blk++) {
416//      cout << "blk:" << blk << endl;
417   
418                ScanBlock s = stream[blk];
419                ScanBlock s2 = stream2[blk];
420//              cout << s << "  " << s2 << endl;
421//              print_register("s:",((BitBlock*)stream)[0]);
422                while(s | s2) {
423//                      cout << "cfzl(s):" << cfzl(s)<<endl;
424                    int end_pos = cfzl(s) + block_pos;
425//                  cout << "s2 " << s2 << endl;
426                    int end_tag = cfzl(s2) + block_pos;
427//              cout << "cfzl(s):" << cfzl(s)<<endl;
428//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
429//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
430                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
431//                      cout << "here" << endl;
432//                      cout << "closing tag" << endl;
433//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
434//                      cout << "1"<< endl;
435//                      cout << elem_vec_stack.size()<<endl;
436//                      cout << "2" << endl;
437//                      cout << elem_vec_stack.top()<<endl;
438                                if(!(gid_vec[current_depth].empty())){
439//                                      if(gid_vec.back() != 0){
440                                                gid_vec[current_depth].push_back(0);
441                                                if(current_depth !=0){
442                                                        current_depth = pre_index.back();
443                                                        pre_index.pop_back();
444                                                        fprintf (gid_writein,"%d\n",current_depth);
445                                                        gid_vec[current_depth].push_back(0);
446                                                }
447//                                      }
448                                }
449//                              cout << "before" << s2 << endl;
450                                s2 = s2 & (s2 - 1);
451//                              cout << "after" << s2 << endl;
452//                      cout << "s2 = " << s2 << endl;
453                }else{
454//                      cout << " end_pos == " << end_pos<<endl;
455//                      cout << " end_tag_pos == " << end_tag << endl;
456                        char gid = ElemEnd_grouping(source,block_base,end_pos);
457                        if (s!=0){
458                                s = s & (s-1);  // clear rightmost bit.
459                        }
460                        //else{
461                        //      s2 = s2 & (s2 - 1);
462                        //}
463                                if (gid != 0){
464                                        gid_vec[current_depth].push_back(gid);
465                                        fprintf (gid_writein,"%d\n",current_depth);
466                                        pre_index.push_back(current_depth);
467                                        current_depth = (int)gid;
468                                        gid_vec[current_depth].push_back(gid);
469                                        fprintf (gid_writein,"%d\n",current_depth);                     
470                                }
471                }
472                }
473                block_pos += 8 * sizeof(ScanBlock);
474//              print_gid_vec();
475    }
476    return 0;
477}
478
479void print_gid_vec(){
480        for (int j = 0; j < MAX_DEPTH; j++){
481                if(gid_vec[j].empty()){
482                        return;
483                }
484                for (int i = 0; i < gid_vec[j].size(); i++){
485                        cout << j << ":" << endl;
486                        cout << (int)gid_vec[j][i] << " ";
487                }
488        }
489        cout << endl;
490/*     
491        int i = 1;
492        int lst[256] = {0};
493        cout << elem_vec_map.size() << " vectors" << endl;
494        for (int i = 0;i < gids.size(); i++){
495                if (lst[gids[i]] == 0){
496                        cout << "gid: " << gids[i] << endl;
497                        lst[gids[i]] = 1;
498                        vector<char> *tmp = elem_vec_map[gids[i]];
499                        cout << "vector size:"<< (*tmp).size()<<endl;
500                        if ((*tmp).size()!=0){
501                                cout << "elements: ";
502                                for (int j = 0; j < (*tmp).size();j++){
503                                        cout << (int)(*tmp)[j] << " ";
504                                }
505                                cout << endl;
506                        }
507                        cout << endl;
508                }
509        }
510*/
511}
512/*
513static inline int NameStrt_check(int pos) {
514        int block_pos = block_base + pos;
515        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
516              ReportError("name start error", pos);
517              exit(-1);
518        }
519        return 0;
520}
521
522static inline int Name_check(int pos) {
523        int block_pos = block_base + pos;
524        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
525              ReportError("name error", pos);
526              exit(-1);
527        }
528        return 0;
529}
530
531static inline int PIName_check(int pos) {
532        int block_pos = block_base + pos;
533        int file_pos = block_pos+buffer_base;
534        printf ("%s:%i\n",__FUNCTION__,pos);
535        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
536              // "<?xml" legal at start of file.
537              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
538              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
539              exit(-1);
540        }
541        return 0;
542}
543
544static inline int CD_check(int pos) {
545        int block_pos = block_base + pos;
546        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
547              ReportError("CDATA error", pos);
548              exit(-1);
549        }
550        return 0;
551}
552
553static inline int GenRef_check(int pos) {
554        int block_pos = block_base + pos;
555        unsigned char* s = (unsigned char*)&source[block_pos];
556        if (!(at_Ref_gt<ASCII>(s)||at_Ref_lt<ASCII>(s)||at_Ref_amp<ASCII>(s)||at_Ref_quot<ASCII>(s)||at_Ref_apos<ASCII>(s))){
557                        cout << pos << endl;
558              ReportError("Undefined reference", pos);
559              exit(-1);
560        }
561        return 0;
562}
563
564static inline int HexRef_check(int pos) {
565        int block_pos = block_base + pos;
566        unsigned char* s = (unsigned char*)&source[block_pos];
567        int ch_val = 0;
568        while(at_HexDigit<ASCII>(s)){
569          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
570          if (ch_val> 0x10FFFF ){
571            ReportError("Illegal character reference", pos);
572            exit(-1);
573          }
574          s++;
575        }
576        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
577          ReportError("Illegal character reference", pos);
578          exit(-1);
579        }
580        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
581          ReportError("Illegal XML 1.0 character reference", pos);
582          exit(-1);
583        }
584        return 0;
585}
586
587static inline int DecRef_check(int pos) {
588        int block_pos = block_base + pos;
589        unsigned char* s = (unsigned char*)&source[block_pos];
590        int ch_val = 0;
591        while(at_HexDigit<ASCII>(s)){
592          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
593          if (ch_val> 0x10FFFF ){
594            ReportError("Illegal character reference", pos);
595            exit(-1);
596          }
597          s++;
598        }
599        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
600          ReportError("Illegal character reference", pos);
601          exit(-1);
602        }
603        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
604          ReportError("Illegal XML 1.0 character reference", pos);
605          exit(-1);
606        }
607        return 0;
608}
609
610static inline int AttRef_check(int pos) {
611        int block_pos = block_base + pos;
612        unsigned char* s = (unsigned char*)&source[block_pos];
613        int ch_val = 0;
614        if(s[0]=='#'){
615          s++;
616          if(s[0]=='x' || s[0]=='X'){
617            s++;
618            while(at_HexDigit<ASCII>(s)){
619              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
620              s++;
621            }
622          }
623          else{
624            while(at_HexDigit<ASCII>(s)){
625              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
626              s++;
627            }
628          }
629          if (ch_val==60){
630            ReportError("Attribute values contain '<' characters after reference expansion", pos);
631            exit(-1);
632          }
633        }
634        else if(at_Ref_lt<ASCII>(s)){
635          ReportError("Attribute values contain '<' characters after reference expansion", pos);
636          exit(-1);
637        }
638        return 0;
639}
640*/
641
642
643
644@global
645
646#include <simd-lib/transpose.hpp>
647#include <post_process.hpp>
648/*
649static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
650  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
651        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);
652}
653
654static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
655  s2p_do_block(U8, basis_bits);
656  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
657  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
658  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
659  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
660  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
661  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
662  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
663  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
664}
665*/
666static inline void print_basis_bits(Basis_bits & basis_bits){
667        print_register("bit0:",basis_bits.bit_0);
668        print_register("bit1:",basis_bits.bit_1);
669        print_register("bit2:",basis_bits.bit_2);
670        print_register("bit3:",basis_bits.bit_3);
671        print_register("bit4:",basis_bits.bit_4);
672        print_register("bit5:",basis_bits.bit_5);
673        print_register("bit6:",basis_bits.bit_6);
674        print_register("bit7:",basis_bits.bit_7);                                       
675}
676
677static inline void print_elem_vec(vector<char>* vec, int size, int depth){
678        cout << "vector " << depth << ":";
679        for (int i = 0; i<size ; i++){
680                cout << (int)(*vec)[i] <<" ";
681        }
682        cout << endl;
683}
684
685static inline void vec_scan(BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner,BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner,char* str,int index){
686        int current_pos = 0;
687        int next_pos = 0;
688        int match_pos = 0;
689        cout << str <<" = " << index <<endl;
690//      cout << "vec_scan" << endl;
691        if(f_vec_scanner.has_next()){
692                current_pos = f_vec_scanner.scan_to_next();
693//              cout << current_pos << endl;
694        }else{
695                return;
696        }
697        if (match_scanner.has_next()){
698                match_pos = match_scanner.scan_to_next();
699        }else{
700                printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
701                while(f_vec_scanner.has_next()){
702                        current_pos = f_vec_scanner.scan_to_next();
703                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
704                }
705                return;
706        }
707        while(1){
708                if(f_vec_scanner.has_next()){
709                        next_pos = f_vec_scanner.scan_to_next();
710                }else{
711                        next_pos = -1;
712                }
713                if (match_pos > next_pos && next_pos != -1){
714                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
715                }else if (next_pos == -1){
716                        break;
717                }else{
718                        if(match_scanner.has_next()){
719                                match_pos = match_scanner.scan_to_next();
720                        }else{
721                                printf("Mismatch found at pos of %s %d: %d.\n",str,index,next_pos);
722                                while(f_vec_scanner.has_next()){
723                                        current_pos = f_vec_scanner.scan_to_next();
724                                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
725                                }
726                                return;
727                        }
728                }
729                current_pos = next_pos;
730        }
731}
732
733static inline void validate_mul_block(){
734        struct Elem elem;
735        Validation_1 validation_1;
736//      Validation_2 validation_2;
737//      Validation_3 validation_3;
738//      Validation_4 validation_4;     
739        Validation_5 validation_5;
740        Validation_24 validation_24;
741        Validation_25 validation_25;
742        Validation_27 validation_27;
743        Validation_35 validation_35;
744        Validation_41 validation_41;
745        Validation_45 validation_45;
746       
747        struct Lex lex;
748       
749        struct Output output;
750
751        Classify_bytes classify_bytes;
752        int j;
753        for(j=0;j<MAX_COUNT;j++){
754        int lgth = gid_vec[j].size();
755                if(!gid_vec[j].empty())
756                        print_elem_vec(&(gid_vec[j]),lgth,j);
757        }
758        for(j=0;j<MAX_COUNT;j++){
759                int lgth = gid_vec[j].size();
760                int remaining = 0;
761                Basis_bits temp_basis_bits;
762                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
763                int i = 0;
764                int block_base;
765               
766                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
767                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
768                match_scanner.init();
769                f_vec_scanner.init();
770               
771                if(lgth != 0){ 
772                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
773                        for(i = 0;i < num_block; i++){
774                                block_base = i*BLOCK_SIZE;
775                       
776                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
777                                //print_elem_vec(&(gid_vec[j]),lgth,j);
778                                //print_basis_bits(temp_basis_bits);
779
780                                classify_bytes.do_block(temp_basis_bits,lex);
781                                switch (j){
782                                        case 1:
783                                        validation_1.do_block(lex,output);
784                                        f_vec_scanner.load_block(lex.cc1,i);
785                                        break;
786                                        /*
787                                        case 2:
788                                        validation_2.do_block(lex,output);
789                                        f_vec_scanner.load_block(lex.cc2,i);
790                                        break;
791                                        case 3:
792                                        validation_3.do_block(lex,output);
793                                        f_vec_scanner.load_block(lex.cc3,i);
794                                        break;
795                                        case 4:
796                                        validation_4.do_block(lex,output);
797                                        f_vec_scanner.load_block(lex.cc4,i);
798                                        break;
799                                        */
800                                        case 5:
801                                        validation_5.do_block(lex,output);
802                                        f_vec_scanner.load_block(lex.cc5,i);
803                                        break;
804                                        case 24:
805                                        validation_24.do_block(lex,output);
806                                        f_vec_scanner.load_block(lex.cc24,i);
807                                        print_register("cc24",lex.cc24);
808                                        print_register("match_24",output.matches);
809                                        break;
810                                        case 25:
811                                        validation_25.do_block(lex,output);
812                                        f_vec_scanner.load_block(lex.cc25,i);
813                                        break;
814                                        case 27:
815                                        validation_27.do_block(lex,output);
816                                        f_vec_scanner.load_block(lex.cc27,i);
817                                        break;
818                                        case 35:
819                                        validation_35.do_block(lex,output);
820                                        f_vec_scanner.load_block(lex.cc35,i);
821                                        break;
822                                        case 41:
823                                        validation_41.do_block(lex,output);
824                                        f_vec_scanner.load_block(lex.cc41,i);
825                                        break;
826                                        case 45:
827                                        validation_45.do_block(lex,output);
828                                        f_vec_scanner.load_block(lex.cc45,i);
829                                        break;
830                                }
831
832                                match_scanner.load_block(output.matches,i);
833                                /*
834                                switch (j){
835                                        case 1:
836                                        f_vec_scanner.load_block(lex.cc1,i);
837                                        break;
838                                        case 5:
839                                        f_vec_scanner.load_block(lex.cc5,i);
840                                        break;
841                                }
842                                */
843
844                        }
845                        if (remaining !=0){
846                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
847                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
848                                //print_elem_vec(&(gid_vec[j]),lgth,j);
849                                //print_basis_bits(temp_basis_bits);
850                       
851                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
852                                switch (j){
853                                        case 1:
854                                        validation_1.do_final_block(lex,output,EOF_mask);
855                                        f_vec_scanner.load_block(lex.cc1,i);
856                                        print_register("cc1",lex.cc1);
857                                        print_register("match_1",output.matches);
858                                        break;
859                                        case 5:
860                                        validation_5.do_final_block(lex,output,EOF_mask);
861                                        f_vec_scanner.load_block(lex.cc5,i);
862                                        print_register("cc5",lex.cc5);
863                                        print_register("match_5",output.matches);
864                                        break;
865                                        case 24:
866                                        validation_24.do_final_block(lex,output,EOF_mask);
867                                        f_vec_scanner.load_block(lex.cc24,i);
868                                        print_register("cc24",lex.cc24);
869                                        print_register("match_24",output.matches);
870                                        break;
871                                        case 25:
872                                        validation_25.do_final_block(lex,output,EOF_mask);
873                                        f_vec_scanner.load_block(lex.cc25,i);
874                                        break;
875                                        case 27:
876                                        validation_27.do_final_block(lex,output,EOF_mask);
877                                        f_vec_scanner.load_block(lex.cc27,i);
878                                        break;
879                                        case 35:
880                                        validation_35.do_final_block(lex,output,EOF_mask);
881                                        f_vec_scanner.load_block(lex.cc35,i);
882                                        break;
883                                        case 41:
884                                        validation_41.do_final_block(lex,output,EOF_mask);
885                                        f_vec_scanner.load_block(lex.cc41,i);
886                                        break;
887                                        case 45:
888                                        validation_45.do_final_block(lex,output,EOF_mask);
889                                        f_vec_scanner.load_block(lex.cc45,i);
890                                        break;
891                                }
892
893                                match_scanner.load_block(output.matches,i);
894                        }
895                }
896                if(lgth != 0){
897                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
898                }
899        }
900       
901/*     
902        for(j=0;j<MAX_COUNT;j++){
903                int lgth = gid_vec[j].size();
904                int remaining = 0;
905                Basis_bits temp_basis_bits;
906                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
907                int i = 0;
908                int block_base;
909       
910                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner_1;
911                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner_1;
912                match_scanner_1.init();
913                f_vec_scanner_1.init();
914                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner_5;
915                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner_5;
916                match_scanner_5.init();
917                f_vec_scanner_5.init();
918                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner_25;
919                BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner_25;
920                match_scanner_25.init();
921                f_vec_scanner_25.init();
922       
923                if(lgth != 0){ 
924                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
925                        for(i = 0;i < num_block; i++){
926                                block_base = i*BLOCK_SIZE;
927                       
928                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
929                                print_elem_vec(&(gid_vec[j]),lgth,j);
930                                print_basis_bits(temp_basis_bits);
931
932                                classify_bytes.do_block(temp_basis_bits,lex);
933                                validation_1.do_block(lex,output_1);
934                                validation_5.do_block(lex,output_5);
935                                validation_25.do_block(lex,output_25);
936
937                                match_scanner_1.load_block(output_1.matches,i);
938                                f_vec_scanner_1.load_block(lex.cc1,i);
939                                match_scanner_5.load_block(output_5.matches,i);
940                                f_vec_scanner_5.load_block(lex.cc5,i);
941                                match_scanner_25.load_block(output_25.matches,i);
942                                f_vec_scanner_25.load_block(lex.cc25,i);
943                                print_register("cc5",lex.cc5);
944                                print_register("cc25",lex.cc25);
945                                print_register("match_25",output_25.matches);
946
947                        }
948                        if (remaining !=0){
949                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
950                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
951                                print_elem_vec(&(gid_vec[j]),lgth,j);
952                                print_basis_bits(temp_basis_bits);
953                       
954                                classify_bytes.do_block(temp_basis_bits,lex);
955                                validation_1.do_block(lex,output_1);
956                                validation_5.do_block(lex,output_5);
957                                validation_25.do_block(lex,output_25);
958                       
959                                match_scanner_1.load_block(output_1.matches,i);
960                                f_vec_scanner_1.load_block(lex.cc1,i);
961                                match_scanner_5.load_block(output_5.matches,i);
962                                f_vec_scanner_5.load_block(lex.cc5,i);
963                                match_scanner_25.load_block(output_25.matches,i);
964                                f_vec_scanner_25.load_block(lex.cc25,i);
965                                print_register("cc25",lex.cc25);
966                        }
967                }
968                vec_scan(match_scanner_1,f_vec_scanner_1,"Element_1");
969                vec_scan(match_scanner_5,f_vec_scanner_5,"Element_5");
970                vec_scan(match_scanner_25,f_vec_scanner_25,"Element_25");
971        }
972*/
973}
974
975
976/*
977static inline void validate(){
978        struct Elem elem;
979        Validation_1 validation_1;
980        struct Lex lex;
981        struct Output output;
982        Classify_bytes classify_bytes;
983        cout << "vector size " << gid_vec.size() << endl;
984        int lgth = gid_vec.size();
985        int remaining = 0;
986        int current_pos = 0;
987        Basis_bits temp_basis_bits;
988
989        ForwardScanner<BitBlock, ScanWord> match_scanner;
990        ReverseScanner<BitBlock, ScanWord> vec_scanner;
991        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
992        int block_base = 0;
993        if (lgth != 0){
994                int i = 0;
995                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
996                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
997                for (i = 0;i < num_block; i++){
998//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
999                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
1000                        print_elem_vec(&(gid_vec),lgth);
1001                        print_basis_bits(temp_basis_bits);
1002                       
1003                        classify_bytes.do_block(temp_basis_bits,lex);
1004                        validation_1.do_block(lex,output);
1005                       
1006                        match_scanner.init(&output.matches);
1007                        vec_scanner.init(&lex.cc1);
1008                        match_scanner.scan_to_next();
1009                        f_vec_scanner.init(&lex.cc1);
1010                        match_scanner.scan_to_next();
1011                        f_vec_scanner.scan_to_next();
1012                        current_pos = f_vec_scanner.get_pos();
1013                        vec_scanner.move_to(match_scanner.get_pos());
1014                        vec_scanner.scan_to_next();
1015//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1016                        if (vec_scanner.get_pos() != current_pos){
1017                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
1018                        }
1019//                      out = simd_or(out,lex.cc1);
1020//                      print_register("out",out);
1021                       
1022                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
1023                                f_vec_scanner.scan_to_next();
1024                                while(!(match_scanner.is_done())){
1025                                        match_scanner.scan_to_next();
1026                                        if(match_scanner.get_pos()>0){
1027                                                vec_scanner.move_to(match_scanner.get_pos());
1028                                                vec_scanner.scan_to_next();
1029                                        }
1030                                        if (vec_scanner.get_pos() != current_pos){
1031                                                        break;
1032                                        }
1033                                }
1034                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1035                                if (f_vec_scanner.get_pos()>0){
1036                                        current_pos = f_vec_scanner.get_pos();
1037                                }
1038                                if (vec_scanner.get_pos() != current_pos){
1039                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
1040                                }
1041//                              out = simd_or(out,lex.cc1);
1042//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
1043//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1044//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
1045//                                      printf("Match found of element with id of '1'\n");                             
1046//                              }
1047                        }
1048                               
1049                       
1050//                      (BytePack*)(iter->second)
1051//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
1052                        cout << i ;
1053                        block_base += BLOCK_SIZE;
1054                }
1055                if (remaining !=0){
1056                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1057                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
1058                        print_elem_vec(&(gid_vec),lgth);
1059                        print_basis_bits(temp_basis_bits);
1060                       
1061                        classify_bytes.do_block(temp_basis_bits,lex);
1062                        validation_1.do_block(lex,output);
1063                        print_register("output.matches",output.matches);
1064                        print_register("lex.cc1",lex.cc1);
1065                        match_scanner.init(&output.matches);
1066                        vec_scanner.init(&lex.cc1);
1067                        f_vec_scanner.init(&lex.cc1);
1068                        match_scanner.scan_to_next();
1069                        f_vec_scanner.scan_to_next();
1070                        current_pos = f_vec_scanner.get_pos();
1071                        cout << "current_pos = " << current_pos << endl;
1072//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
1073//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1074                        vec_scanner.move_to(match_scanner.get_pos());
1075                        vec_scanner.scan_to_next();
1076                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1077                        if (vec_scanner.get_pos() != current_pos){
1078                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
1079                        }
1080//                      out = simd_or(out,lex.cc1);
1081//                      print_register("out",out);
1082                       
1083                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
1084                                f_vec_scanner.scan_to_next();
1085                                while(!(match_scanner.is_done())){
1086                                        match_scanner.scan_to_next();
1087                                        if(match_scanner.get_pos()>0){
1088                                                vec_scanner.move_to(match_scanner.get_pos());
1089                                                vec_scanner.scan_to_next();
1090                                        }
1091                                        if (vec_scanner.get_pos() != current_pos){
1092                                                        break;
1093                                        }
1094                                }
1095                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1096                                if (f_vec_scanner.get_pos()>0){
1097                                        current_pos = f_vec_scanner.get_pos();
1098                                }
1099                                if (vec_scanner.get_pos() != current_pos){
1100                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
1101                                }
1102//                              out = simd_or(out,lex.cc1);
1103//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
1104//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1105//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
1106//                                      printf("Match found of element with id of '1'\n");                             
1107//                              }
1108                        }
1109//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
1110                }
1111        }
1112/*
1113        vector<int> test;
1114        for(int i = 1;i <12; i++){
1115                test.push_back(i);
1116        }
1117//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
1118        Basis_bits temp_basis_bits;
1119        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
1120        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
1121        print_basis_bits(temp_basis_bits);
1122*/
1123/*
1124        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
1125                int i = 0;
1126                int lgth = (*(iter->second)).size();
1127                int remaining;
1128                if (lgth != 0){
1129                        cout <<"vector key "<< (int)iter->first << endl;
1130//                      cout <<"vector ptr" << iter->second<<endl;
1131               
1132                        cout <<"vector size: " << lgth << endl;
1133                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1134                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1135                        for (i = 0;i < num_block; i++){
1136                                Basis_bits temp_basis_bits;
1137                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
1138                                print_elem_vec(iter->second,lgth);
1139                                print_basis_bits(temp_basis_bits);
1140//                              (BytePack*)(iter->second)
1141                                cout << i ;
1142                        }
1143                        cout << endl;
1144                        if (remaining !=0){
1145                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
1146                                Basis_bits temp_basis_bits;
1147                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
1148                                print_elem_vec((iter->second)+i,lgth);
1149                                print_basis_bits(temp_basis_bits);
1150                        }
1151                }                       
1152        }
1153*/
1154/*
1155}
1156*/
1157
1158static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
1159
1160        elem_starts = tag_Callouts.ElemName_starts;
1161    hashvalues[1] = hash_data.Hash_value;
1162   
1163//    pre_index.push(0);
1164   
1165        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
1166       
1167        // Store the last starting position in case we hit boundary case
1168    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1169
1170    //copy current hash value data as previous one.
1171    memmove (&hashvalues[0], &hashvalues[1], 16);
1172}
1173/*
1174static inline void postprocess_do_block(Lex & lex, CtCDPI_Callouts & ctCDPI_Callouts, Ref_Callouts & ref_Callouts, Check_streams & check_streams, Tag_Callouts & tag_Callouts, Hash_data & hash_data, int chars_avail){
1175
1176
1177    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
1178    //      TagMatcher will crash if we feed a long symbol name.
1179    //      Sample file: test/long_sym_name.xml
1180
1181    tracker.StoreNewlines(lex.LF);
1182    elem_starts = tag_Callouts.ElemName_starts;
1183    hashvalues[1] = hash_data.Hash_value;
1184
1185        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
1186       
1187/*
1188    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
1189    {
1190        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1191    }
1192
1193    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
1194    {
1195        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1196    }
1197
1198    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
1199    {
1200        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1201    }
1202
1203    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
1204    {
1205        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1206    }
1207
1208    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
1209    {
1210        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1211    }
1212
1213    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
1214    {
1215        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1216    }
1217
1218    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
1219    {
1220        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1221    }
1222
1223    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
1224    {
1225        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1226    }
1227
1228    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
1229    {
1230        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1231    }
1232
1233    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
1234    {
1235        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1236    }
1237
1238    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
1239    {
1240        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1241    }
1242
1243    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
1244    {
1245        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1246    }
1247
1248    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
1249    {
1250        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1251    }
1252
1253    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
1254    {
1255        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1256    }
1257
1258    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
1259    {
1260        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1261    }
1262
1263    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
1264    {
1265        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1266    }
1267
1268    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
1269    {
1270        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1271    }
1272
1273*/
1274
1275
1276/*
1277    // Store the last starting position in case we hit boundary case
1278    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1279
1280    //copy current hash value data as previous one.
1281    memmove (&hashvalues[0], &hashvalues[1], 16);
1282
1283    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
1284      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
1285      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
1286    }
1287
1288    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
1289      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
1290    }
1291
1292    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
1293      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
1294    }
1295
1296    if (bitblock::any(ref_Callouts.GenRef_starts)){
1297      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
1298    }
1299
1300    if (bitblock::any(ref_Callouts.DecRef_starts)){
1301      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
1302    }
1303
1304    if (bitblock::any(ref_Callouts.HexRef_starts)){
1305      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
1306    }
1307
1308    if (bitblock::any(check_streams.att_refs)){
1309      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
1310    }
1311
1312//    error_tracker.If_Error_Report_First();
1313/*
1314    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1315    tracker.AdvanceBlock();
1316    */
1317    /*
1318}
1319*/
1320
1321static inline void print_GIDS()
1322{
1323    int span_count = gids.size();
1324    for(int i=0;i<span_count;i++) {
1325             cout << gids[i] << " ";
1326    }
1327    cout << endl;
1328}
1329
1330static inline int test(int)
1331{
1332    return 0;
1333}
1334
1335void do_process(FILE *infile, FILE *outfile) {
1336
1337        ///////////////
1338        //gid file
1339        ///////////////
1340        gid_writein = fopen("gid.out","w");
1341@decl
1342        #ifndef STL_ALIGNED_VECTOR
1343                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1344        #endif
1345        ///////////////////////////////////////////////////
1346        //preload element_IDs into symbol table from schema
1347        ///////////////////////////////////////////////////
1348        FILE *element_ID_in = fopen("../test/element_ID","r");
1349        char symbol[50];
1350        int index;
1351        if(element_ID_in == NULL){
1352                printf("Error opening element_ID file.\n");
1353                exit(0);
1354        }
1355        hashvalues[1] = hash_data.Hash_value;
1356        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
1357                int lgth = strlen(symbol);
1358                int hashvalue = compute_hash_value2(symbol,lgth);
1359//              cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
1360                int gid = 0;
1361                switch (lgth)
1362        {
1363                        case 1:
1364                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
1365                        break;
1366                        case 2:
1367                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
1368                        break;
1369                        case 3:
1370                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
1371                        break;
1372                        case 4:
1373                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
1374                        break;
1375                        case 5:
1376                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
1377                        break;
1378                        case 6:
1379                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
1380                        break;
1381                        case 7:
1382                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
1383                        break;
1384                        case 8:
1385                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
1386                        break;
1387                        case 9:
1388                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
1389                        break;
1390                        case 10:
1391                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
1392                        break;
1393                        case 11:
1394                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
1395                        break;
1396                        case 12:
1397                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
1398                        break;
1399                        case 13:
1400                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
1401                        break;
1402                        case 14:
1403                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
1404                        break;
1405                        case 15:
1406                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
1407                        break;
1408                        case 16:
1409                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
1410                        break;
1411                        default:
1412                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
1413                        break;         
1414                }
1415                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
1416        }       
1417        fclose(element_ID_in);
1418//      return;
1419
1420        int buffer_base = 0;
1421        int block_base = 0;
1422        int buffer_pos = 0;
1423        int block_pos = 0;
1424        int errpos = 0;
1425        int chars_avail = 0;
1426        int check_pos = 0;
1427        int chars_read = 0;
1428 
1429        //////////////////////////////////////////////////////////////////////////////////////////
1430    // Buffer Management
1431    //////////////////////////////////////////////////////////////////////////////////////////
1432                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1433                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
1434
1435                #ifdef STL_ALIGNED_VECTOR
1436                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
1437                        src_buffer.reserve(BUFFER_SIZE);
1438                #else
1439                        char * COPYBACK;
1440                        char * src_buffer;
1441                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1442                #endif
1443  /*
1444  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
1445
1446  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
1447  buffer_base = buf_pos;
1448  source = srcbuf;
1449  */
1450  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
1451  chars_avail = chars_read;
1452  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
1453
1454  if(chars_read<4){
1455    fprintf(stderr,"File is too short. Not well formed.\n");
1456    exit(-1);
1457  }
1458
1459  Entity_Info * e = new Entity_Info;
1460  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
1461
1462  if (e->code_unit_base == ASCII) {
1463
1464    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
1465
1466    decl_parser.ReadXMLInfo(*e);
1467
1468    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1469        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1470        exit(-1);
1471    }
1472  }
1473  else {
1474    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1475        exit(-1);
1476  }
1477
1478  if (e->content_start != 0) {
1479        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
1480        buffer_pos = e->content_start;
1481//      buffer_base = buffer_pos;
1482        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1483                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1484                        chars_avail = chars_read;
1485                }
1486                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1487  }
1488
1489        //////////////////////////////////////////////////////////////////////////////////////////
1490        // Read OVERLAP bytes to support post processing validation lookahead.
1491        //////////////////////////////////////////////////////////////////////////////////////////
1492        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1493        chars_avail = chars_read;
1494        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1495
1496@stream_stmts
1497
1498        #ifndef STL_ALIGNED_VECTOR
1499        matcher.setSrc((char *)&src_buffer[0]);
1500        #endif
1501
1502/* Full Buffers */
1503    int block_segment_num = 0;
1504    while (chars_avail >= SEGMENT_SIZE) {
1505      PERF_SEC_START(parser_timer);
1506      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1507//              cout << "loops" << ends;
1508                block_base = blk*BLOCK_SIZE;
1509        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
1510     
1511                @block_stmts
1512         
1513                tracker.StoreNewlines(lex.LF);
1514//              cout << "post start" << endl;
1515//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1516                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1517                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1518//              cout << "post done" << endl;
1519                #ifndef STL_ALIGNED_VECTOR
1520                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1521                #endif
1522                tracker.AdvanceBlock();
1523//              cout << "loop" << endl;
1524      }
1525      #ifndef STL_ALIGNED_VECTOR
1526      matcher.StreamScan(chars_avail);
1527      matcher.Advance_buffer();
1528      #endif
1529      PERF_SEC_END(parser_timer, chars_avail);
1530//        cout << "here" << endl;
1531      int bytes_left = chars_read - chars_avail;
1532     
1533      //////////////////
1534      //element name buffer, for scanning element name backwards
1535      /////////////////
1536      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
1537//      fprintf(gid_writein,"name_buffer\n");
1538      cross_buffer_flag = 1;
1539     
1540      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
1541      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
1542      chars_avail = chars_read;
1543//      cout << "here" << endl;
1544      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1545      buffer_pos += chars_avail;
1546      buffer_base = buffer_pos;
1547      block_segment_num++;
1548
1549  }
1550       
1551/* Final Partial Buffer */
1552    PERF_SEC_START(parser_timer);
1553
1554    block_pos = 0;
1555    int remaining = chars_avail;
1556
1557
1558
1559/* Full Blocks */
1560    while (remaining >= BLOCK_SIZE) {
1561          block_base = block_pos;
1562          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
1563         
1564          @block_stmts
1565         
1566          tracker.StoreNewlines(lex.LF);
1567//        cout << "post start1" << endl;
1568         
1569//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1570          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1571          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1572//        cout << "post end2" << endl;
1573          #ifndef STL_ALIGNED_VECTOR
1574          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1575          #endif
1576          tracker.AdvanceBlock();
1577          block_pos += BLOCK_SIZE;
1578          remaining -= BLOCK_SIZE;
1579    }
1580    block_base = block_pos;
1581        #ifdef USE_ANY_CARRY_TEST
1582    if (remaining > 0 || @any_carry) {
1583        #endif
1584          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1585          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
1586          @final_block_stmts
1587//        cout << "post start3" << endl;
1588//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
1589          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
1590          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
1591//        cout << "post end3" << endl;
1592          #ifndef STL_ALIGNED_VECTOR
1593      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1594          #endif
1595          tracker.AdvanceBlock();
1596        #ifdef USE_ANY_CARRY_TEST
1597    }
1598    #endif
1599    buffer_pos += chars_avail;
1600    buffer_base = buffer_pos;
1601        #ifndef STL_ALIGNED_VECTOR
1602    matcher.StreamScan(chars_avail);
1603    matcher.Advance_buffer();
1604//    tracker.Advance_buffer();
1605
1606   
1607    if (matcher.depth != 0) {
1608      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
1609      exit(-1);
1610     
1611     
1612    }
1613    #endif
1614    PERF_SEC_END(parser_timer, chars_avail);
1615//  print_GIDS();
1616//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
1617}
1618
1619
1620
1621int
1622main(int argc, char * argv[]) {
1623        char * infilename, * outfilename;
1624        FILE *infile, *outfile;
1625        struct stat fileinfo;
1626
1627        if (argc < 2) {
1628                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
1629                exit(-1);
1630        }
1631
1632        infilename = argv[1];
1633        stat(infilename, &fileinfo);
1634        infile = fopen(infilename, "rb");
1635        if (!infile) {
1636                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
1637                exit(-1);
1638        }
1639
1640        if (argc < 3) outfile = stdout;
1641        else {
1642                outfilename = argv[2];
1643                outfile = fopen(outfilename, "wb");
1644                if (!outfile) {
1645                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
1646                        exit(-1);
1647                }
1648        }
1649
1650//      PERF_SEC_BIND(1);
1651
1652        PERF_SEC_INIT(parser_timer);
1653
1654        do_process(infile, outfile);
1655       
1656#if DEBUG
1657//print_gid_vec();
1658#endif
1659        //cout << "validate start" << endl;
1660        //validate();
1661        validate_mul_block();
1662
1663        PERF_SEC_DUMP(parser_timer);
1664
1665        PERF_SEC_DESTROY(parser_timer);
1666
1667        fclose(infile);
1668        fclose(outfile);
1669
1670        printf ("Done procressing\n");
1671        return(0);
1672}
Note: See TracBrowser for help on using the repository browser.