source: proto/xmlschema/validation_template_onevec_po2.cpp @ 4368

Last change on this file since 4368 was 3552, checked in by shiyangy, 6 years ago

test case added

File size: 70.8 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 BLOCK_SIZE (sizeof(SIMD_type) * 8)
17//#define SEGMENT_BLOCKS 12
18//#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
19//#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
20
21#define VECTOR_WIDTH 8
22#define VECTOR_TYPE (char)
23
24//#define DEBUG 1
25
26//#define DATATYPE 1
27
28//#define CONTENT_MODEL 1
29
30//#define SYMBOL_TABLE 1
31
32int Datatype = 0;
33int Content_model = 0;
34int Symbol = 0;
35int Data_gather = 0;
36int Content_gather = 0;
37
38int total_element = 0;
39int validated_element = 0;
40
41
42#include <stdio.h>
43#include <stdlib.h>
44#include <errno.h>
45#include <sys/types.h>
46#include <sys/stat.h>
47#include <limits.h>
48
49#include <simd-lib/s2p.hpp>
50#include <simd-lib/buffer.hpp>
51#include <simd-lib/bitblock_iterator.hpp>
52#include <simd-lib/perflib/perfsec.h>
53
54//#include "../lib/lib_simd.h"
55#include "../symtab/pbgs_identity_symbol_table.h"
56
57#include <stack>
58#include <map>
59#include <vector>
60
61#include <queue>
62#include <string>
63
64typedef long ScanBlock;
65typedef BytePack BitBlock;
66
67using namespace std;
68
69//#include "../lib/carryQ.h"
70#include <xmldecl.h>
71//#include "xml_error.c"
72//#include "xmldecl.c"
73#include <namechars.h>
74#include <LineColTracker.hpp>
75#include <XMLTestSuiteError.h>
76
77// Define the mappings for pablo.assert_0(strm, errkind) statements which
78// compile to the the form assert_0_error(errkind, strm)
79#include <ErrorTracker.h>
80
81ErrorTracker error_tracker;
82#define assert_0_error(errkind, errstrm) error_tracker.NoteError(errkind, errstrm);
83
84#ifndef STL_ALIGNED_VECTOR
85#include <TagMatcher.hpp>
86#endif
87
88#ifdef STL_ALIGNED_VECTOR // experimental, comment out TagMatcher code to use STL aligned memory vector
89#warning "Compiling with experimental STL_ALIGNED_VECTOR."
90#include <vector>
91#include <simd-lib/stl_aligned_allocator.hpp>
92#endif
93
94#ifdef BUFFER_PROFILING
95    BOM_Table * parser_timer;
96#elif PAPI
97                #define PAPI_EVENTS_COUNT 2
98                int PAPI_EVENTS[PAPI_EVENTS_COUNT] = {PAPI_TOT_CYC, PAPI_BR_MSP};       
99    CC * parser_timer;
100#else
101    void * parser_timer;
102#endif
103
104//////////////////////////////////////////////////////////////////////////////////////////
105// Buffer Management // WARNING: Do Not update #defines. Results in TagMatcher errors.
106//////////////////////////////////////////////////////////////////////////////////////////
107#define PADDING_BLOCKS 0
108#define PADDING_SIZE (BLOCK_SIZE * PADDING_BLOCKS)
109#define COPYBACK_BLOCKS 2
110#define COPYBACK_SIZE (BLOCK_SIZE * COPYBACK_BLOCKS)
111#define LOOKAHEAD_BLOCKS 1
112#define LOOKAHEAD_SIZE (BLOCK_SIZE * LOOKAHEAD_BLOCKS)
113#define SEGMENT_BLOCKS  12 // WARNING: TagMatcher.hpp causes xmlconf test suite failures for SEGMENT_BLOCKS < 3.
114#define SEGMENT_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
115#define BUFFER_SIZE (COPYBACK_SIZE + SEGMENT_SIZE + LOOKAHEAD_SIZE + PADDING_SIZE)
116
117
118
119//int block_base=0;
120//int buffer_base=0;
121int buffer_last;
122FILE *gid_writein;
123FILE *element_out;
124#define ELEMENT_BUFFER_SIZE 30
125#define MAX_COUNT 128
126char element_name_buffer[ELEMENT_BUFFER_SIZE];
127int cross_buffer_flag = 0;
128//char * source;
129LineColTracker tracker;
130
131#define CONTENT_BUFFER_SIZE BLOCK_SIZE
132
133#define MAX_CONTENT_COUNT 16
134char content_buffer[MAX_CONTENT_COUNT][CONTENT_BUFFER_SIZE];
135char content_lookahead_buffer[MAX_CONTENT_COUNT][CONTENT_BUFFER_SIZE];
136int content_buffer_pos[MAX_CONTENT_COUNT];
137int content_carry = 0;
138char gid;
139int content_start_carry = 0;
140int current_gid = 0;
141
142#define CONTENT_INDEX1 6
143#define CONTENT_INDEX2 7
144#define CONTENT_INDEX3 9
145#define CONTENT_INDEX4 10
146static inline int cfzl(long x) { if (x == 0) return sizeof(long)*8; else return __builtin_ctzl(x);}
147/*
148static inline int cfzl(long x) { if (x == 0) return sizeof(long)*8; else return __builtin_ctzl(x);}
149/*
150static inline int cfzl(long x){
151        unsigned long ux = x;
152        if (x<0){
153                ux = ULONG_MAX + x + 1;
154        }
155        if (ux==0)
156                return 8*sizeof(long);
157        int n;
158        n = 0;
159        while (1){
160                if ((ux%2) == 1){
161                        if(n==64){
162//                              cout << ux <<endl;
163                        }
164                        return n;               
165                }
166                n ++;
167                ux = ux >> 1;
168                //cout << "x = " << x << endl;
169        }
170}
171*/
172static inline void print_gid_vec();
173/*
174static inline int cfzl(long x){
175 if (x ==0)
176  return 32;
177 int n=0;
178 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
179 if ((x & 0xFF000000) == 0){ n = n +  8; x = x <<  8;} // 8 left bits are 0
180 if ((x & 0xF0000000) ==0){ n = n +  4; x = x <<  4;} // 4 left bits are 0
181 if ((x & 0xC0000000) == 0){ n =n +  2, x = x <<  2;}  // 110000....0 2 left bits are zero
182 if ((x & 0x80000000) == 0){n = n +  1, x = x <<  1;} // first left bit is zero
183 return n;
184
185}
186*/
187static inline void ReportError(const char * error_msg, int error_pos_in_block) {
188  int error_line, error_column;
189  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
190  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
191}
192/*
193class ErrorTracker {
194public:
195    ErrorTracker() { noted_pos_in_block = -1;}
196
197    inline void NoteError(const char * error_msg, BitBlock err_strm) {
198      int pos_in_block = count_forward_zeroes(err_strm);
199      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
200        noted_pos_in_block = pos_in_block;
201        noted_error = error_msg;
202      }
203    }
204
205    inline void If_Error_Report_First() {
206      if (noted_pos_in_block > -1) {
207              int error_line, error_column;
208              ReportError(noted_error, noted_pos_in_block);
209              exit(-1);
210      }
211    }
212
213private:
214  const char * noted_error;
215  int noted_pos_in_block;
216};
217*/
218
219
220//BitBlock EOF_mask = simd_const_1(1);
221
222//ErrorTracker error_tracker;
223BitBlock elem_starts;
224int previous_block_last_elem_start;
225BytePack hashvalues[2];
226
227vector <int> gids;
228PBGSIdentitySymbolTable pbgs_symbol_table;
229
230vector <char> gid_vec[MAX_COUNT];
231int current_depth = 0;
232vector <int> pre_index;
233
234stack <vector<char>* > elem_vec_stack;
235map<char, vector<char>* > elem_vec_map;
236
237@global
238
239#include <simd-lib/transpose.hpp>
240#include <post_process.hpp>
241
242static inline int ScanBackwardPos(BitBlock * block, int pos)
243{
244//      cout << "pos " << pos << endl;
245    BitBlock s = block[0];
246    if (bitblock::any(block[0])){
247//      print_register("zero",block[0]);
248//      print_register("t",simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
249        }
250    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), convert(pos))) );
251//      print_register("zero",simd_not(simd<128>::sll(simd<1>::constant<1>());
252//              print_register("temp",temp);
253    if (bitblock::any(temp))
254    {
255        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
256//      cout << "block_size" << BLOCK_SIZE << endl;
257        return BLOCK_SIZE - count_reverse_zeroes(temp) - 1;
258    }
259    else
260    {
261        //handle boundary case
262        return previous_block_last_elem_start - 1;
263    }
264}
265
266static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
267        int blk;
268        int block_pos = 0;
269        for (blk = 0; blk < blk_count; blk++) {
270                ScanBlock s = stream[blk];
271                while(s) {
272                        int code = (ProcessPos(cfzl(s) + block_pos));
273                        if (code) return code;
274                        s = s & (s-1);  // clear rightmost bit.
275                }
276                block_pos += 8 * sizeof(ScanBlock);
277        }
278        return 0;
279}
280
281static inline int compute_hash_value2(char *str,int lgth){
282        int hash = 5381;
283    int c;
284//      while (c = *str++){
285        for (int i = 0;i<lgth;i++){
286                c=*str++; 
287        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
288    }
289
290    return hash;
291}
292
293static inline int compute_hash_value (int lgth, int start)
294{
295    unsigned int offset_bit = start + 128;
296    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
297    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
298}
299
300static inline void print_basis_bits(Basis_bits & basis_bits){
301        print_register("bit0:",basis_bits.bit_0);
302        print_register("bit1:",basis_bits.bit_1);
303        print_register("bit2:",basis_bits.bit_2);
304        print_register("bit3:",basis_bits.bit_3);
305        print_register("bit4:",basis_bits.bit_4);
306        print_register("bit5:",basis_bits.bit_5);
307        print_register("bit6:",basis_bits.bit_6);
308        print_register("bit7:",basis_bits.bit_7);                                       
309}
310/*
311template <int L>
312static inline int ElemEnd_grouping(int pos) {
313    int end = block_base + pos;
314    int start = end - L;
315    int hashvalue = compute_hash_value(L, start - block_base);
316    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
317    gids.push_back(gid);
318#if DEBUG
319    char* symbol = new char[L+1];
320    strncpy ( symbol, source + start, L );
321    symbol[L] ='\0';
322    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 );
323    delete symbol; symbol = 0;
324#endif
325    return gid;
326}
327
328template<>
329inline int ElemEnd_grouping<17>(int pos) {
330    int end = block_base + pos;
331    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
332    int lgth = end - start;
333    int hashvalue = compute_hash_value(lgth, start - block_base);
334    int gid = 0;
335
336//    if (lgth < 32)
337//    {
338//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
339//    }
340//    else
341    {
342        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
343    }
344    gids.push_back(gid);
345#if DEBUG
346    char* symbol = new char[lgth+1];
347    strncpy ( symbol, source + start, lgth );
348    symbol[lgth] ='\0';
349    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);
350#endif
351    return gid;
352}
353*/
354
355static inline char ElemEnd_grouping(char *source,int block_base,int pos) {
356    int end = block_base + pos;
357    int start = ScanBackwardPos(&elem_starts, pos) + block_base;
358    ///////////////////////
359    //start could be negitive
360    //the element name falls in two buffers
361    ///////////////////////
362    char *name = source + start;
363    char name_buffer[50];
364   
365    if (start<0){
366#ifdef DEBUG
367            fprintf(gid_writein,"name_buffer %s\n",element_name_buffer);
368#endif
369        memmove (&name_buffer[0],&element_name_buffer[ELEMENT_BUFFER_SIZE+start],-start);       
370        memmove (&name_buffer[-start],&source[0],50+start);
371        name = name_buffer;
372        //fprintf (gid_writein,"name_buffer %s",name);
373#ifdef DEBUG
374        fprintf(gid_writein,"name_buffer %s\n",name);
375#endif
376    }
377//    cout << end << "  " << start << endl;
378    int lgth = end - start;
379//    int hashvalue = compute_hash_value(lgth,start-block_base);
380        int hashvalue = compute_hash_value2(name,lgth);
381    char gid = 0;
382
383
384//    if (lgth < 32)
385//    {
386//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
387//    }
388//    else
389
390        switch (lgth)
391    {
392    case 1:
393        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(name, hashvalue);
394        break;
395    case 2:
396        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(name, hashvalue);
397        break;
398    case 3:
399        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(name, hashvalue);
400        break;
401    case 4:
402        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(name, hashvalue);
403        break;
404    case 5:
405        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(name, hashvalue);
406        break;
407    case 6:
408        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(name, hashvalue);
409        break;
410    case 7:
411        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(name, hashvalue);
412        break;
413    case 8:
414        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(name, hashvalue);
415        break;
416    case 9:
417        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(name, hashvalue);
418        break;
419    case 10:
420        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(name, hashvalue);
421        break;
422    case 11:
423        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(name, hashvalue);
424        break;
425    case 12:
426        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(name, hashvalue);
427        break;
428    case 13:
429        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(name, hashvalue);
430        break;
431    case 14:
432        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(name, hashvalue);
433        break;
434    case 15:
435        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(name, hashvalue);
436        break;
437    case 16:
438        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(name, hashvalue);
439        break;
440    default:
441        gid = pbgs_symbol_table.Lookup_or_Insert_Name(name, hashvalue, lgth);
442        break;
443    }
444/*
445    {
446        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
447    }
448*/
449    gids.push_back(gid);
450#ifdef DEBUG
451    char* symbol = new char[lgth+1];
452    strncpy ( symbol, source + start, lgth );
453    symbol[lgth] ='\0';
454//    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);
455    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);
456#endif
457    return gid;
458}
459
460static inline int print_source(char* source, int lgth ,int seg){
461        char ret[128];
462        int j;
463        for (int i=0;i<seg;i++){
464                for(j=0;j<lgth;j++){
465                        if(source[i*lgth+j]!='\n')
466                                ret[j] = source[i*lgth + j];
467                        else
468                                ret[j] = ' ';
469                }
470                ret[j] = '\0';
471//              cout << ret << endl;
472        }
473        return 0;
474}
475
476Validate_content_6 validate_content_6;
477Validate_content_7 validate_content_7;
478Validate_content_9 validate_content_9;
479Validate_content_10 validate_content_10;
480
481static inline void validate_data_type(int char_aval, int gid_index){
482        struct Lex lex;
483        struct Output output;
484        Classify_bytes_Validate_utf8 classify_bytes_Validate_utf8;
485        U8 u8;
486        Basis_bits temp_basis_bits;
487#ifdef DEBUG
488        cout << "current gid: " << gid_index << endl;
489#endif
490//      Validate_content_5 validate_content_5;
491       
492        if(char_aval == BLOCK_SIZE){
493                s2p_do_block((BytePack*)(&content_buffer[gid_index]), temp_basis_bits);
494#ifdef DEBUG
495                print_basis_bits(temp_basis_bits);
496#endif
497                classify_bytes_Validate_utf8.do_block(temp_basis_bits,lex,u8);
498#ifdef  DEBUG
499                cout << content_buffer[gid_index] << endl;
500               
501                print_register("digit:",lex.Digit);
502                print_register("dot:",lex.Dot);
503                print_register("namescan:",lex.NameScan);
504                print_register("P_N:",lex.P_H_sign);
505                print_register("content_end:",lex.content_end);
506#endif
507                if (gid_index == CONTENT_INDEX1){
508                        validate_content_6.do_block(lex,output);
509                }else if (gid_index == CONTENT_INDEX2){
510                        validate_content_7.do_block(lex,output);
511                }else if (gid_index == CONTENT_INDEX3){
512                        validate_content_9.do_block(lex,output);
513                }else if (gid_index == CONTENT_INDEX4){
514                        validate_content_10.do_block(lex,output);
515                }
516#ifdef DEBUG
517                print_register("output:",output.matches);
518                print_register("output.tem:",output.tem);
519#endif
520        }else{
521                int remaining = BLOCK_SIZE -char_aval;
522                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
523                s2p_do_final_block((BytePack*)(&content_buffer[gid_index]), temp_basis_bits,EOF_mask);
524                classify_bytes_Validate_utf8.do_final_block(temp_basis_bits,lex,u8,EOF_mask);
525                if (gid_index == CONTENT_INDEX1){
526                        validate_content_6.do_final_block(lex,output,EOF_mask);
527                }else if (gid_index == CONTENT_INDEX2){
528                        validate_content_7.do_final_block(lex,output,EOF_mask);
529                }else if (gid_index == CONTENT_INDEX3){
530                        validate_content_9.do_final_block(lex,output,EOF_mask);
531                }else if (gid_index == CONTENT_INDEX4){
532                        validate_content_10.do_final_block(lex,output,EOF_mask);
533                }
534        }
535}
536
537static inline int gid_in_list(char gid, int* list, int ln){
538        for (int i = 0; i < ln ; i++){
539                if (int(gid) == list[i]){       
540                        return 1;
541                }
542        }
543        return 0;
544}
545
546
547//template <int L>
548static inline int StreamScanLengthGrouping(char *source,int block_base,ScanBlock * stream, ScanBlock * stream2, int blk_count,ScanBlock * stream3,ScanBlock * stream4) {
549    int blk;
550    int block_pos = 0;
551//    cout << "cfzl():" << cfzl() << endl;
552//      long test = 6;
553//      test = (test & (test - 1));
554//      cout << "test" << endl;
555    for (blk = 0; blk < blk_count; blk++) {
556//      cout << "blk:" << blk << endl;
557   
558                ScanBlock s = stream[blk];
559                ScanBlock s2 = stream2[blk];
560                ScanBlock s3 = stream3[blk];
561                ScanBlock s4 = stream4[blk];
562                int end_content;
563                int start_content;
564                int content_lgth;
565                int content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[current_gid];
566               
567//              cout << "block_pos " << block_pos <<endl;
568//#ifdef DATATYPE
569if(Symbol && Datatype)  {
570                if (content_start_carry == 1 && (current_gid == CONTENT_INDEX1 || current_gid == CONTENT_INDEX2 || current_gid == CONTENT_INDEX3 || current_gid == CONTENT_INDEX4)){
571//                      cout << "****" << endl;
572                        start_content = cfzl(s3) + block_pos;
573                                        if (cfzl(s3) != 8*sizeof(ScanBlock)){
574                                                content_start_carry = 0;
575                                        }
576                                       
577                                        end_content = cfzl(s4) + block_pos;
578                                        while(end_content < start_content){
579                                                s4 = s4 & (s4-1);
580                                                end_content = cfzl(s4) + block_pos;
581                                        }
582        //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
583                                        if(cfzl(s4)==8*sizeof(ScanBlock)){
584                                                content_carry = 1;
585        //                              cout << "end_of_block" << endl;
586                                        }
587                                        content_lgth = end_content - start_content;
588//                                      cout << end_content << " " << start_content <<endl;
589//                                      cout << "lgth: " << content_lgth << endl;
590                                        content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[current_gid];
591                                        int full_content = 0;
592                                        int buffer_full = 0;
593                                        if(content_carry != 1){
594                                                if(content_aval > content_lgth-2 && content_lgth > 2){
595                                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_lgth-2);
596                                                        char temp = '#';
597                                                        content_buffer_pos[current_gid] += content_lgth-2;
598                                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&temp,1);
599                                                        content_buffer_pos[current_gid] ++;
600//                                                      cout << "@@" <<endl;
601//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
602                                                }else{
603                                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_aval);
604                                                        full_content = 1;
605                                               
606                                                        content_buffer_pos[current_gid] += content_aval;
607                                                        memmove(&content_lookahead_buffer[current_gid][0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
608//                                                      cout << "@@@" <<endl;
609//                                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
610                                                        content_buffer_pos[current_gid] = content_lgth-2-content_aval;
611                                                        buffer_full = 1;
612                                                }
613                                        }else{
614                                                if(content_aval > content_lgth-1 && content_lgth > 1){
615//                                                      cout << "@" << endl;
616//                                              cout << content_aval << "   " << content_lgth << endl;
617                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_lgth-1);
618//                                              printf("%.*s\n",content_lgth-1,&content_buffer[content_buffer_pos]);
619                                                        content_buffer_pos[current_gid] += content_lgth-1;
620//                                                      full_content = 1;       
621                                                }else if(content_aval < content_lgth-1){
622//                                                      cout << "@@@@" << endl;
623//                                                      cout << content_aval << "   " << content_lgth << endl;
624                                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_aval);
625                                               
626                                                        content_buffer_pos[current_gid] += content_aval;
627                                                        memmove(&content_lookahead_buffer[current_gid][0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
628        //                                              full_content = 1;
629                                                        content_buffer_pos[current_gid] = content_lgth-1-content_aval;
630                                                        buffer_full = 1;
631                                                }
632                                        }
633                                        if (buffer_full == 1){
634        //                              cout << "buffer_full" << endl;
635        //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
636        //                              cout << content_buffer << endl << endl;
637if(!Data_gather)
638                                                validate_data_type(CONTENT_BUFFER_SIZE,current_gid);
639                                                memmove(&content_buffer[current_gid][0],&content_lookahead_buffer[current_gid][0],content_buffer_pos[current_gid]);
640                                                if (full_content == 1){
641                                                        char temp = '#';
642                                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&temp,1);
643                                                        content_buffer_pos[current_gid] ++;
644                                                        full_content = 0;
645                                                }
646                                                buffer_full = 0;
647                                        }
648                }else if (content_carry == 1){
649                end_content = cfzl(s4) + block_pos;
650                start_content = block_pos-1;
651                content_lgth = end_content-block_pos;
652                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[current_gid];
653                if (cfzl(s4) != 8*sizeof(ScanBlock)){
654                        content_carry = 0;
655                        s4 = s4 & (s4-1);
656                }
657                int buffer_full = 0;
658                if (content_carry !=1){
659                                if(content_aval > content_lgth-1 && content_lgth > 1){
660//                                      cout << "##" << endl;
661        //                      cout << "lgth " << content_lgth << endl;
662                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[block_pos+block_base],content_lgth-1);
663//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
664//                                      cout << "content_lgth " << content_lgth <<endl;
665//                                      printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
666                                        content_buffer_pos[current_gid] += content_lgth-1;
667                                        char temp = '#';
668                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&temp,1);
669                                        content_buffer_pos[current_gid] ++;
670        //                      content_buffer[content_buffer_pos] = '\0';
671        //                      cout << "^^^" << endl;
672        //                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-1 << endl;
673        //                      cout << content_buffer << endl;
674                                }else if (content_lgth == 0){
675                                        content_buffer[current_gid][content_buffer_pos[current_gid]-1] = '#';
676                                }else if (content_aval > 0 && content_lgth == 1){
677//                                      cout << "###" << endl;
678                                        content_buffer[current_gid][content_buffer_pos[current_gid]] = '#';
679                                        content_buffer_pos[current_gid]++;
680                                        if(content_buffer_pos[current_gid] == CONTENT_BUFFER_SIZE){
681if(!Data_gather)
682                                                validate_data_type(CONTENT_BUFFER_SIZE,current_gid);
683                                                content_buffer_pos[current_gid] = 0;
684                                        }
685                                }else if (content_aval <= content_lgth-1){
686//                                      cout << "@@@@@@@@@@@@@@@@@@" << endl;
687                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[block_pos+block_base],content_aval);
688                                        memmove(&content_lookahead_buffer[current_gid][0],&source[block_pos+block_base+content_aval],content_lgth-1-content_aval);
689//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
690//                                      cout << "content_lgth " << content_lgth <<endl;
691//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
692                                        content_buffer_pos[current_gid] = content_lgth-1-content_aval;
693        //                              content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
694        //                              cout << content_buffer << endl << endl;
695if(!Data_gather)
696                                        validate_data_type(CONTENT_BUFFER_SIZE,current_gid);
697                                        memmove(&content_buffer[current_gid][0],&content_lookahead_buffer[current_gid][0],content_buffer_pos[current_gid]);
698                                        if (content_lgth-1 < CONTENT_BUFFER_SIZE){
699                                                content_buffer[current_gid][content_buffer_pos[current_gid]] = '#';
700                                                content_buffer_pos[current_gid] ++;
701                                        }
702                                }
703                }else{
704                        if(content_aval > content_lgth){
705//                                      cout << "##*" << endl;
706//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
707//                                      cout << "content_lgth " << content_lgth <<endl;
708                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[block_pos+block_base],content_lgth);
709//                                      printf("%.*s\n",content_lgth+content_buffer_pos,content_buffer);
710                                        content_buffer_pos[current_gid] += content_lgth;
711                                }else if (content_aval <= content_lgth){
712//                                      cout << "@@@@@@@@@@@@@@@@@@*" << endl;
713                                        memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[block_pos+block_base],content_aval);
714                                        memmove(&content_lookahead_buffer[current_gid][0],&source[block_pos+block_base+content_aval],content_lgth-content_aval);
715//                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;
716//                                      cout << "content_lgth " << content_lgth <<endl;
717//                                      printf("%.*s\n",content_aval,&content_buffer[content_buffer_pos]);
718                                        content_buffer_pos[current_gid] = content_lgth-content_aval;
719if(!Data_gather)
720                                        validate_data_type(CONTENT_BUFFER_SIZE,current_gid);
721                                        memmove(&content_buffer[current_gid][0],&content_lookahead_buffer[current_gid][0],content_buffer_pos[current_gid]);
722                                }                       
723                }
724            }
725}
726//#endif
727//              print_source(&source[block_base],sizeof(ScanBlock)*8,2);
728//              print_register("start_content:",((BitBlock*)stream3)[0]);
729//              print_register("end_content:",((BitBlock*)stream4)[0]);
730//              cout << s << "  " << s2 << endl;
731//              print_register("s:",((BitBlock*)stream)[0]);
732                while(s | s2) {
733//                      cout << "cfzl(s):" << cfzl(s)<<endl;
734                    int end_pos = cfzl(s) + block_pos;
735//                  cout << "s2 " << s2 << endl;
736                    int end_tag = cfzl(s2) + block_pos;
737//              cout << "cfzl(s):" << cfzl(s)<<endl;
738//              cout << "cfzl(s2):" << cfzl(s2)<<endl;
739//                      cout << (end_tag < end_pos && s2 != 0)<< "||" <<(s == 0 && s2 != 0)  << endl;
740                        if ((end_tag < end_pos && s2 != 0) | (s == 0 && s2 != 0)){
741//                      cout << "here" << endl;
742//                      cout << "closing tag" << endl;
743//                      cout << "endtag:" << end_tag << " " << end_pos<<endl;
744//                      cout << "1"<< endl;
745//                      cout << elem_vec_stack.size()<<endl;
746//                      cout << "2" << endl;
747//                      cout << elem_vec_stack.top()<<endl;
748if(Content_model){
749                                if(!(gid_vec[current_depth].empty())){
750//                                      if(gid_vec.back() != 0){
751                                                gid_vec[current_depth].push_back(0);
752                                                if(current_depth !=0){
753                                                        current_depth = pre_index.back();
754                                                        pre_index.pop_back();
755#ifdef DEBUG
756                                                        fprintf (gid_writein,"%d\n",current_depth);
757#endif
758                                                        gid_vec[current_depth].push_back(0);
759                                                }
760//                                      }
761                                }
762}
763//                              cout << "before" << s2 << endl;
764                                s2 = s2 & (s2 - 1);
765//                              cout << "after" << s2 << endl;
766//                              cout << "s2 = " << s2 << endl;
767                }else{
768//                      cout << " end_pos == " << end_pos<<endl;
769//                      cout << " end_tag_pos == " << end_tag << endl;
770                        gid = ElemEnd_grouping(source,block_base,end_pos);
771                        current_gid = gid;
772//#ifdef DATATYPE
773if(Symbol && Datatype){
774//                      printf("%d\n",int(gid));
775                        if ((current_gid == CONTENT_INDEX1 || current_gid == CONTENT_INDEX2 || current_gid == CONTENT_INDEX3 || current_gid == CONTENT_INDEX4 )){
776//                              cout << "source : ";
777//                              printf("%.*s\n",sizeof(ScanBlock)*8,&source[block_base]);
778                                        start_content = cfzl(s3) + block_pos;
779                                        while(start_content < end_pos){
780                                                s3 = s3 & (s3-1);
781                                                start_content = cfzl(s3) + block_pos;
782                                        }
783                                        if (cfzl(s3) == 8*sizeof(ScanBlock)){
784                                                content_start_carry = 1;
785                                        }
786                                        if (content_start_carry != 1){
787                //                      cout << "end_pos " << end_pos <<endl;
788                //                      char temp[20];
789                //                      memmove(temp,&source[end_pos+block_base],20);
790                //                      cout << "source: " << temp << endl;
791                                                //cout << "start_content " << start_content << endl;
792                                       
793                                                end_content = cfzl(s4) + block_pos;
794                                                while(end_content < start_content){
795                                                        s4 = s4 & (s4-1);
796                                                        end_content = cfzl(s4) + block_pos;
797                                                }
798                //                      cout << "cfzl" << cfzl(s4) << " " <<sizeof(ScanBlock) <<endl;
799                                                if(cfzl(s4)==8*sizeof(ScanBlock)){
800                                                        content_carry = 1;
801                //                              cout << "end_of_block" << endl;
802                                                }
803                                                content_lgth = end_content - start_content;
804//                                              cout << end_content << " " << start_content <<endl;
805//                                              cout << "lgth: " << content_lgth << endl;
806                                                content_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[current_gid];
807                                                int full_content = 0;
808                                                int buffer_full = 0;
809                                                if(content_carry != 1){
810                                                        if(content_aval > content_lgth-2 && content_lgth > 2){
811                                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_lgth-2);
812                                                                char temp = '#';
813                                                                content_buffer_pos[current_gid] += content_lgth-2;
814                                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&temp,1);
815                                                                content_buffer_pos[current_gid] ++;
816                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << endl;
817//                                                              cout << "@@" <<endl;
818//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_lgth-2 << endl;
819                                                        }else{
820                                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_aval);
821                                                                full_content = 1;
822                                               
823                                                                content_buffer_pos[current_gid] += content_aval;
824                                                                memmove(&content_lookahead_buffer[current_gid][0],&source[start_content+block_base+1+content_aval],content_lgth-2-content_aval);
825//                                                              cout << "@@@" <<endl;
826//                                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
827                                                                content_buffer_pos[current_gid] = content_lgth-2-content_aval;
828                                                                buffer_full = 1;
829                                                        }
830                                                }else{
831                                                        if(content_aval > content_lgth-1 && content_lgth > 1){
832//                                                              cout << "@" << endl;
833//                                                              cout << content_aval << "   " << content_lgth << endl;
834                                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_lgth-1);
835//                                                              printf("%.*s\n",content_lgth-1+content_buffer_pos,content_buffer);
836                                                                content_buffer_pos[current_gid] += content_lgth-1;
837        //                                                      full_content = 1;
838                //                                      cout << content_carry << endl;
839                //                                      cout << content_buffer << endl << endl;
840                //                                      cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE<< "            "<< content_lgth-1 << endl;             
841                                                        }else if(content_aval < content_lgth-1){
842//                                                              cout << "@@@@" << endl;
843//                                                              cout << content_aval << "   " << content_lgth << endl;
844                                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&source[start_content+block_base+1],content_aval);
845                                               
846                                                                content_buffer_pos[current_gid] += content_aval;
847                                                                memmove(&content_lookahead_buffer[current_gid][0],&source[start_content+block_base+1+content_aval],content_lgth-1-content_aval);
848                //                                              full_content = 1;
849                //                                              cout << content_buffer_pos << "         " << CONTENT_BUFFER_SIZE << "           "<< content_aval << endl;       
850                                                                content_buffer_pos[current_gid] = content_lgth-1-content_aval;
851                                                                buffer_full = 1;
852                                                        }
853                                                }
854                                                if (buffer_full == 1){
855                //                              cout << "buffer_full" << endl;
856                //                                  content_buffer[CONTENT_BUFFER_SIZE-1] = '\0';
857                //                              cout << content_buffer << endl << endl;
858                                                        validate_data_type(CONTENT_BUFFER_SIZE,current_gid);
859                                                        memmove(&content_buffer[current_gid][0],&content_lookahead_buffer[current_gid][0],content_buffer_pos[current_gid]);
860                                                        if (full_content == 1){
861                                                                char temp = '#';
862                                                                memmove(&content_buffer[current_gid][content_buffer_pos[current_gid]],&temp,1);
863                                                                content_buffer_pos[current_gid] ++;
864                                                                full_content = 0;
865                                                        }
866                                                        buffer_full = 0;
867                                                }
868                                        }
869                        }
870}
871//#endif                       
872//                      content_buffer[content_buffer_pos] = '\0';
873//                      cout << content_buffer << endl;
874                        if (s!=0){
875                                s = s & (s-1);  // clear rightmost bit.
876                        }
877                        //else{
878                        //      s2 = s2 & (s2 - 1);
879                        //}
880if(Content_model){
881                                if (gid != 0){
882                                        gid_vec[current_depth].push_back(gid);
883#ifdef DEBUG
884                                        fprintf (gid_writein,"%d\n",current_depth);
885#endif
886                                        pre_index.push_back(current_depth);
887                                        current_depth = (int)gid;
888                                        gid_vec[current_depth].push_back(gid);
889#ifdef DEBUG
890                                        fprintf (gid_writein,"%d\n",current_depth);                     
891#endif
892                                }
893}
894                }       
895                }
896                block_pos += 8 * sizeof(ScanBlock);
897//              print_gid_vec();
898    }
899    return 0;
900}
901
902void print_gid_vec(){
903        for (int j = 0; j < MAX_DEPTH; j++){
904                if(gid_vec[j].empty()){
905                        return;
906                }
907                for (int i = 0; i < gid_vec[j].size(); i++){
908                        cout << j << ":" << endl;
909                        cout << (int)gid_vec[j][i] << " ";
910                }
911        }
912        cout << endl;
913/*     
914        int i = 1;
915        int lst[256] = {0};
916        cout << elem_vec_map.size() << " vectors" << endl;
917        for (int i = 0;i < gids.size(); i++){
918                if (lst[gids[i]] == 0){
919                        cout << "gid: " << gids[i] << endl;
920                        lst[gids[i]] = 1;
921                        vector<char> *tmp = elem_vec_map[gids[i]];
922                        cout << "vector size:"<< (*tmp).size()<<endl;
923                        if ((*tmp).size()!=0){
924                                cout << "elements: ";
925                                for (int j = 0; j < (*tmp).size();j++){
926                                        cout << (int)(*tmp)[j] << " ";
927                                }
928                                cout << endl;
929                        }
930                        cout << endl;
931                }
932        }
933*/
934}
935/*
936static inline int NameStrt_check(int pos) {
937        int block_pos = block_base + pos;
938        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
939              ReportError("name start error", pos);
940              exit(-1);
941        }
942        return 0;
943}
944
945static inline int Name_check(int pos) {
946        int block_pos = block_base + pos;
947        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
948              ReportError("name error", pos);
949              exit(-1);
950        }
951        return 0;
952}
953
954static inline int PIName_check(int pos) {
955        int block_pos = block_base + pos;
956        int file_pos = block_pos+buffer_base;
957        printf ("%s:%i\n",__FUNCTION__,pos);
958        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
959              // "<?xml" legal at start of file.
960              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
961              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
962              exit(-1);
963        }
964        return 0;
965}
966
967static inline int CD_check(int pos) {
968        int block_pos = block_base + pos;
969        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
970              ReportError("CDATA error", pos);
971              exit(-1);
972        }
973        return 0;
974}
975
976static inline int GenRef_check(int pos) {
977        int block_pos = block_base + pos;
978        unsigned char* s = (unsigned char*)&source[block_pos];
979        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))){
980                        cout << pos << endl;
981              ReportError("Undefined reference", pos);
982              exit(-1);
983        }
984        return 0;
985}
986
987static inline int HexRef_check(int pos) {
988        int block_pos = block_base + pos;
989        unsigned char* s = (unsigned char*)&source[block_pos];
990        int ch_val = 0;
991        while(at_HexDigit<ASCII>(s)){
992          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
993          if (ch_val> 0x10FFFF ){
994            ReportError("Illegal character reference", pos);
995            exit(-1);
996          }
997          s++;
998        }
999        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
1000          ReportError("Illegal character reference", pos);
1001          exit(-1);
1002        }
1003        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
1004          ReportError("Illegal XML 1.0 character reference", pos);
1005          exit(-1);
1006        }
1007        return 0;
1008}
1009
1010static inline int DecRef_check(int pos) {
1011        int block_pos = block_base + pos;
1012        unsigned char* s = (unsigned char*)&source[block_pos];
1013        int ch_val = 0;
1014        while(at_HexDigit<ASCII>(s)){
1015          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
1016          if (ch_val> 0x10FFFF ){
1017            ReportError("Illegal character reference", pos);
1018            exit(-1);
1019          }
1020          s++;
1021        }
1022        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
1023          ReportError("Illegal character reference", pos);
1024          exit(-1);
1025        }
1026        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
1027          ReportError("Illegal XML 1.0 character reference", pos);
1028          exit(-1);
1029        }
1030        return 0;
1031}
1032
1033static inline int AttRef_check(int pos) {
1034        int block_pos = block_base + pos;
1035        unsigned char* s = (unsigned char*)&source[block_pos];
1036        int ch_val = 0;
1037        if(s[0]=='#'){
1038          s++;
1039          if(s[0]=='x' || s[0]=='X'){
1040            s++;
1041            while(at_HexDigit<ASCII>(s)){
1042              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
1043              s++;
1044            }
1045          }
1046          else{
1047            while(at_HexDigit<ASCII>(s)){
1048              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
1049              s++;
1050            }
1051          }
1052          if (ch_val==60){
1053            ReportError("Attribute values contain '<' characters after reference expansion", pos);
1054            exit(-1);
1055          }
1056        }
1057        else if(at_Ref_lt<ASCII>(s)){
1058          ReportError("Attribute values contain '<' characters after reference expansion", pos);
1059          exit(-1);
1060        }
1061        return 0;
1062}
1063*/
1064
1065
1066
1067
1068/*
1069static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
1070  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
1071        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);
1072}
1073
1074static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
1075  s2p_do_block(U8, basis_bits);
1076  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
1077  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
1078  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
1079  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
1080  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
1081  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
1082  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
1083  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
1084}
1085*/
1086
1087static inline void print_elem_vec(vector<char>* vec, int size, int depth){
1088        cout << "vector " << depth << ":";
1089        for (int i = 0; i<size ; i++){
1090                cout << (int)(*vec)[i] <<" ";
1091        }
1092        cout << endl;
1093}
1094
1095static 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){
1096        int current_pos = 0;
1097        int next_pos = 0;
1098        int match_pos = 0;
1099//      cout << str <<" = " << index <<endl;
1100//      cout << "vec_scan" << endl;
1101        cout << f_vec_scanner.get_final_pos() << "&&" << endl;
1102        if(f_vec_scanner.has_next()){
1103                current_pos = f_vec_scanner.scan_to_next();
1104//              cout << current_pos << endl;
1105        }else{
1106                return;
1107        }
1108        if (match_scanner.has_next()){
1109                match_pos = match_scanner.scan_to_next();
1110        }else{
1111                printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1112                while(f_vec_scanner.has_next()){
1113                        current_pos = f_vec_scanner.scan_to_next();
1114                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1115                }
1116                return;
1117        }
1118        while(1){
1119                if(f_vec_scanner.has_next()){
1120                        next_pos = f_vec_scanner.scan_to_next();
1121                }else{
1122                        next_pos = -1;
1123                }
1124                if(next_pos > match_pos){
1125                        cout <<"##" << next_pos << "  " << match_pos << endl; 
1126                        current_pos = next_pos;
1127                        match_pos = match_scanner.scan_to_next();
1128                        continue;
1129                }else if(next_pos == -1){
1130                        break;
1131                }else if(next_pos < match_pos){
1132                        cout << next_pos << "  " << match_pos << endl; 
1133                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1134                        current_pos = next_pos;
1135                }
1136        }
1137/*     
1138        while(1){
1139                if(f_vec_scanner.has_next()){
1140                        next_pos = f_vec_scanner.scan_to_next();
1141                }else{
1142                        next_pos = -1;
1143                }
1144                if (match_pos > next_pos && next_pos != -1){
1145                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1146                }else if (next_pos == -1){
1147                        break;
1148                }else{
1149                        if(match_scanner.has_next()){
1150                                match_pos = match_scanner.scan_to_next();
1151                        }else{
1152                                printf("Mismatch found at pos of %s %d: %d.\n",str,index,next_pos);
1153                                while(f_vec_scanner.has_next()){
1154                                        current_pos = f_vec_scanner.scan_to_next();
1155                                        printf("Mismatch found at pos of %s %d: %d.\n",str,index,current_pos);
1156                                }
1157                                return;
1158                        }
1159                }
1160                current_pos = next_pos;
1161        }
1162*/
1163}
1164
1165static inline void validate_mul_block(){
1166//      FILE *element_out = fopen("element.out","w");
1167        struct Elem elem;
1168        Validation_2 validation_2;
1169        Validation_3 validation_3;
1170        Validation_4 validation_4;
1171        Validation_5 validation_5;
1172        Validation_6 validation_6;
1173        Validation_7 validation_7;
1174        Validation_8 validation_8;
1175        Validation_9 validation_9;
1176        Validation_10 validation_10;
1177        Validation_11 validation_11;
1178       
1179        struct Lex lex;
1180       
1181        struct Output output;
1182
1183        Classify_bytes classify_bytes;
1184        int j;
1185#ifdef DEBUG
1186        for(j=0;j<MAX_COUNT;j++){
1187        int lgth = gid_vec[j].size();
1188                if(!gid_vec[j].empty())
1189                        print_elem_vec(&(gid_vec[j]),lgth,j);
1190        }
1191#endif
1192/*
1193        for(j=0;j<MAX_COUNT;j++){
1194                int lgth = gid_vec[j].size();
1195                if (lgth == 0){
1196                        break;
1197                }
1198                fprintf(element_out,"%d\n",lgth);
1199        }
1200        fclose(element_out);
1201*/
1202        int lgth;
1203        for(j=0;j<MAX_COUNT;j++){
1204                lgth = gid_vec[j].size();
1205                int remaining = 0;
1206                Basis_bits temp_basis_bits;
1207                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1208                int i = 0;
1209                int block_base;
1210                if(lgth != 0){ 
1211                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1212                        for(i = 0;i < num_block; i++){
1213                                block_base = i*BLOCK_SIZE;
1214                               
1215                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
1216                                classify_bytes.do_block(temp_basis_bits,lex);
1217                                switch (j){
1218                                        case 2:
1219                                        validation_2.do_block(lex,output);
1220#ifdef DEBUG                           
1221                                        print_register("cc2",lex.cc2);
1222                                        print_register("match_2",output.matches);
1223#endif
1224                                        break;
1225                                        case 3:
1226                                        validation_3.do_block(lex,output);
1227                                        break;
1228                                        case 4:
1229                                        validation_4.do_block(lex,output);
1230                                        break;
1231                                        case 5:
1232                                        validation_5.do_block(lex,output);
1233                                        break;
1234                                        case 6:
1235                                        validation_6.do_block(lex,output);
1236                                        break;
1237                                        case 7:
1238                                        validation_7.do_block(lex,output);
1239                                        break;
1240                                        case 8:
1241                                        validation_8.do_block(lex,output);
1242#ifdef DEBUG
1243                                        print_register("cc8",lex.cc8);
1244                                        print_register("match_8",output.matches);
1245#endif
1246                                        break;
1247                                        case 9:
1248                                        validation_9.do_block(lex,output);
1249                                        break;
1250                                        case 10:
1251                                        validation_10.do_block(lex,output);
1252                                        break;
1253                                        case 11:
1254                                        validation_11.do_block(lex,output);
1255#ifdef DEBUG
1256                                        print_register("cc11",lex.cc10);
1257                                        print_register("match_11",output.matches);
1258#endif
1259                                        break;
1260                                }
1261                        }
1262                        if (remaining !=0){
1263                                block_base = i*BLOCK_SIZE;
1264                                //cout << "block_base " << block_base << endl;
1265                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1266                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
1267                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
1268                                switch (j){
1269                                        case 2:
1270                                        validation_2.do_final_block(lex,output,EOF_mask);
1271#ifdef DEBUG
1272//                                      cout << remaining << endl;
1273                                        print_register("cc2",lex.cc2);
1274//                                      print_register("cc3",lex.cc3);
1275//                                      print_register("cc4",lex.cc4);
1276//                                      print_register("cc9",lex.cc9);
1277                                        print_register("match_2",output.matches);
1278#endif
1279                                        break;
1280                                        case 3:
1281                                        validation_3.do_final_block(lex,output,EOF_mask);
1282                                        break;
1283                                        case 4:
1284                                        validation_4.do_final_block(lex,output,EOF_mask);
1285                                        break;
1286                                        case 5:
1287                                        validation_5.do_final_block(lex,output,EOF_mask);
1288                                        break;
1289                                        case 6:
1290                                        validation_6.do_final_block(lex,output,EOF_mask);
1291                                        break;
1292                                        case 7:
1293                                        validation_7.do_final_block(lex,output,EOF_mask);
1294                                        break;
1295                                        case 8:
1296                                        validation_8.do_final_block(lex,output,EOF_mask);
1297#ifdef DEBUG
1298                                        print_register("cc8",lex.cc8);
1299                                        print_register("match_8",output.matches);
1300#endif
1301                                        break;
1302                                        case 9:
1303                                        validation_9.do_final_block(lex,output,EOF_mask);
1304                                        break;
1305                                        case 10:
1306                                        validation_10.do_final_block(lex,output,EOF_mask);
1307                                        break;
1308                                        case 11:
1309                                        validation_11.do_final_block(lex,output,EOF_mask);
1310#ifdef DEBUG
1311                                        print_register("cc11",lex.cc11);
1312                                        print_register("match_11",output.matches);
1313#endif
1314                                        break;
1315                                }
1316                        }
1317                }
1318        }
1319}
1320
1321
1322
1323/*
1324
1325static inline void validate_mul_block(){
1326        struct Elem elem;
1327        Validation_2 validation_2;
1328//      Validation_2 validation_2;
1329        Validation_4 validation_4;
1330        Validation_9 validation_9;
1331//      Validation_4 validation_4;     
1332//      Validation_5 validation_5;
1333//      Validation_24 validation_24;
1334//      Validation_25 validation_25;
1335//      Validation_27 validation_27;
1336//      Validation_35 validation_35;
1337//      Validation_41 validation_41;
1338//      Validation_45 validation_45;
1339       
1340        struct Lex lex;
1341       
1342        struct Output output;
1343
1344        Classify_bytes classify_bytes;
1345        int j;
1346#ifdef DEBUG
1347        for(j=0;j<MAX_COUNT;j++){
1348        int lgth = gid_vec[j].size();
1349                if(!gid_vec[j].empty())
1350                        print_elem_vec(&(gid_vec[j]),lgth,j);
1351        }
1352#endif
1353        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> match_scanner;
1354        BitStreamScanner<BitBlock, uint64_t,uint64_t, 32> f_vec_scanner;
1355        match_scanner.init();
1356        f_vec_scanner.init();
1357        int lgth;
1358        for(j=0;j<MAX_COUNT;j++){
1359                lgth = gid_vec[j].size();
1360                int remaining = 0;
1361                Basis_bits temp_basis_bits;
1362                const int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1363                int i = 0;
1364                int block_base;
1365               
1366                if(lgth != 0){ 
1367                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1368                        for(i = 0;i < num_block; i++){
1369                                block_base = i*BLOCK_SIZE;
1370                                //cout << "block_base " << block_base << endl;
1371                       
1372                                s2p_do_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits);
1373                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
1374                                //print_basis_bits(temp_basis_bits);
1375
1376                                classify_bytes.do_block(temp_basis_bits,lex);
1377                                switch (j){
1378                                        case 2:
1379                                        validation_2.do_block(lex,output);
1380                                        f_vec_scanner.load_block(lex.cc2,i);
1381#ifdef DEBUG                           
1382                                        print_register("cc2",lex.cc2);
1383                                        print_register("match_2",output.matches);
1384#endif
1385                                        break;
1386                                        case 4:
1387                                        validation_4.do_block(lex,output);
1388                                        f_vec_scanner.load_block(lex.cc4,i);
1389#ifdef DEBUG
1390                                        print_register("cc4",lex.cc4);
1391                                        print_register("match_4",output.matches);
1392#endif
1393                                        break;
1394                                        case 9:
1395                                        validation_9.do_block(lex,output);
1396                                        f_vec_scanner.load_block(lex.cc9,i);
1397#ifdef DEBUG
1398                                        print_register("cc9",lex.cc9);
1399                                        print_register("match_9",output.matches);
1400#endif
1401                                        break;
1402                                }
1403
1404                                match_scanner.load_block(output.matches,i);
1405
1406                        }
1407                        if (remaining !=0){
1408                                block_base = i*BLOCK_SIZE;
1409                                //cout << "block_base " << block_base << endl;
1410                                BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1411                                s2p_do_final_block((BytePack*)(&(gid_vec[j][block_base])), temp_basis_bits,EOF_mask);
1412                                //print_elem_vec(&((vector*)(gid_vec[j][block_base])),BLOCK_SIZE,j);
1413                                //print_basis_bits(temp_basis_bits);
1414                                //print_elem_vec((vector<char>*)(gid_vec[j][block_base]),remaining,j);
1415                       
1416                                classify_bytes.do_final_block(temp_basis_bits,lex,EOF_mask);
1417                                switch (j){
1418                                        case 2:
1419                                        validation_2.do_final_block(lex,output,EOF_mask);
1420                                        f_vec_scanner.load_block(lex.cc2,i);
1421#ifdef DEBUG
1422//                                      cout << remaining << endl;
1423                                        print_register("cc2",lex.cc2);
1424//                                      print_register("cc3",lex.cc3);
1425//                                      print_register("cc4",lex.cc4);
1426//                                      print_register("cc9",lex.cc9);
1427                                        print_register("match_2",output.matches);
1428#endif
1429                                        break;
1430                                        case 4:
1431                                        validation_4.do_final_block(lex,output,EOF_mask);
1432                                        f_vec_scanner.load_block(lex.cc4,i);
1433#ifdef DEBUG
1434                                        print_register("cc4",lex.cc4);
1435                                        print_register("match_4",output.matches);
1436#endif
1437                                        break;
1438                                        case 9:
1439                                        validation_9.do_final_block(lex,output,EOF_mask);
1440                                        f_vec_scanner.load_block(lex.cc9,i);
1441#ifdef DEBUG
1442                                        print_register("cc9",lex.cc9);
1443                                        print_register("match_9",output.matches);
1444#endif
1445                                        break;
1446                                }
1447                               
1448                                match_scanner.load_block(output.matches,i);
1449                        }
1450                }
1451        }
1452        if(lgth != 0){
1453                        vec_scan(match_scanner,f_vec_scanner,"Element",j);     
1454        }
1455       
1456
1457}
1458
1459
1460*/
1461
1462/*
1463static inline void validate(){
1464        struct Elem elem;
1465        Validation_1 validation_1;
1466        struct Lex lex;
1467        struct Output output;
1468        Classify_bytes classify_bytes;
1469        cout << "vector size " << gid_vec.size() << endl;
1470        int lgth = gid_vec.size();
1471        int remaining = 0;
1472        int current_pos = 0;
1473        Basis_bits temp_basis_bits;
1474
1475        ForwardScanner<BitBlock, ScanWord> match_scanner;
1476        ReverseScanner<BitBlock, ScanWord> vec_scanner;
1477        ForwardScanner<BitBlock, ScanWord> f_vec_scanner;
1478        int block_base = 0;
1479        if (lgth != 0){
1480                int i = 0;
1481                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1482                remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1483                for (i = 0;i < num_block; i++){
1484//                      s2p_do_block((BytePack*)(vector_11[i]),temp_basis_bits);
1485                        s2p_do_block((BytePack*)(&(gid_vec[i])), temp_basis_bits);
1486                        print_elem_vec(&(gid_vec),lgth);
1487                        print_basis_bits(temp_basis_bits);
1488                       
1489                        classify_bytes.do_block(temp_basis_bits,lex);
1490                        validation_1.do_block(lex,output);
1491                       
1492                        match_scanner.init(&output.matches);
1493                        vec_scanner.init(&lex.cc1);
1494                        match_scanner.scan_to_next();
1495                        f_vec_scanner.init(&lex.cc1);
1496                        match_scanner.scan_to_next();
1497                        f_vec_scanner.scan_to_next();
1498                        current_pos = f_vec_scanner.get_pos();
1499                        vec_scanner.move_to(match_scanner.get_pos());
1500                        vec_scanner.scan_to_next();
1501//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1502                        if (vec_scanner.get_pos() != current_pos){
1503                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
1504                        }
1505//                      out = simd_or(out,lex.cc1);
1506//                      print_register("out",out);
1507                       
1508                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
1509                                f_vec_scanner.scan_to_next();
1510                                while(!(match_scanner.is_done())){
1511                                        match_scanner.scan_to_next();
1512                                        if(match_scanner.get_pos()>0){
1513                                                vec_scanner.move_to(match_scanner.get_pos());
1514                                                vec_scanner.scan_to_next();
1515                                        }
1516                                        if (vec_scanner.get_pos() != current_pos){
1517                                                        break;
1518                                        }
1519                                }
1520                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1521                                if (f_vec_scanner.get_pos()>0){
1522                                        current_pos = f_vec_scanner.get_pos();
1523                                }
1524                                if (vec_scanner.get_pos() != current_pos){
1525                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
1526                                }
1527//                              out = simd_or(out,lex.cc1);
1528//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
1529//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1530//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
1531//                                      printf("Match found of element with id of '1'\n");                             
1532//                              }
1533                        }
1534                               
1535                       
1536//                      (BytePack*)(iter->second)
1537//                      validate_Elem_Vec.do_block(elem, temp_basis_bits);
1538                        cout << i ;
1539                        block_base += BLOCK_SIZE;
1540                }
1541                if (remaining !=0){
1542                        BitBlock EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
1543                        s2p_do_final_block((BytePack*)(&(gid_vec[i])), temp_basis_bits,EOF_mask);
1544                        print_elem_vec(&(gid_vec),lgth);
1545                        print_basis_bits(temp_basis_bits);
1546                       
1547                        classify_bytes.do_block(temp_basis_bits,lex);
1548                        validation_1.do_block(lex,output);
1549                        print_register("output.matches",output.matches);
1550                        print_register("lex.cc1",lex.cc1);
1551                        match_scanner.init(&output.matches);
1552                        vec_scanner.init(&lex.cc1);
1553                        f_vec_scanner.init(&lex.cc1);
1554                        match_scanner.scan_to_next();
1555                        f_vec_scanner.scan_to_next();
1556                        current_pos = f_vec_scanner.get_pos();
1557                        cout << "current_pos = " << current_pos << endl;
1558//                      cout << "match_scanner_pos = " << match_scanner.get_pos()<< endl;
1559//                      cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1560                        vec_scanner.move_to(match_scanner.get_pos());
1561                        vec_scanner.scan_to_next();
1562                        cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1563                        if (vec_scanner.get_pos() != current_pos){
1564                                printf("#Mismatch found at pos: %d.\n",current_pos+block_base);
1565                        }
1566//                      out = simd_or(out,lex.cc1);
1567//                      print_register("out",out);
1568                       
1569                        while(!(match_scanner.is_done() || f_vec_scanner.is_done())){
1570                                f_vec_scanner.scan_to_next();
1571                                while(!(match_scanner.is_done())){
1572                                        match_scanner.scan_to_next();
1573                                        if(match_scanner.get_pos()>0){
1574                                                vec_scanner.move_to(match_scanner.get_pos());
1575                                                vec_scanner.scan_to_next();
1576                                        }
1577                                        if (vec_scanner.get_pos() != current_pos){
1578                                                        break;
1579                                        }
1580                                }
1581                                cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1582                                if (f_vec_scanner.get_pos()>0){
1583                                        current_pos = f_vec_scanner.get_pos();
1584                                }
1585                                if (vec_scanner.get_pos() != current_pos){
1586                                        printf("Mismatch found at pos: %d.\n",current_pos+block_base);
1587                                }
1588//                              out = simd_or(out,lex.cc1);
1589//                              cout << "match_scanner_pos = " << match_scanner.get_pos() << endl;
1590//                              cout << "vec_scanner_pos = " << vec_scanner.get_pos() << endl;
1591//                              if(match_scanner.get_pos() == vec_scanner.get_pos()){
1592//                                      printf("Match found of element with id of '1'\n");                             
1593//                              }
1594                        }
1595//                      validate_Elem_Vec.do_final_block(elem, temp_basis_bits, EOF_mask);
1596                }
1597        }
1598/*
1599        vector<int> test;
1600        for(int i = 1;i <12; i++){
1601                test.push_back(i);
1602        }
1603//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
1604        Basis_bits temp_basis_bits;
1605        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
1606        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
1607        print_basis_bits(temp_basis_bits);
1608*/
1609/*
1610        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
1611                int i = 0;
1612                int lgth = (*(iter->second)).size();
1613                int remaining;
1614                if (lgth != 0){
1615                        cout <<"vector key "<< (int)iter->first << endl;
1616//                      cout <<"vector ptr" << iter->second<<endl;
1617               
1618                        cout <<"vector size: " << lgth << endl;
1619                        int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
1620                        remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
1621                        for (i = 0;i < num_block; i++){
1622                                Basis_bits temp_basis_bits;
1623                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
1624                                print_elem_vec(iter->second,lgth);
1625                                print_basis_bits(temp_basis_bits);
1626//                              (BytePack*)(iter->second)
1627                                cout << i ;
1628                        }
1629                        cout << endl;
1630                        if (remaining !=0){
1631                                BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
1632                                Basis_bits temp_basis_bits;
1633                                s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
1634                                print_elem_vec((iter->second)+i,lgth);
1635                                print_basis_bits(temp_basis_bits);
1636                        }
1637                }                       
1638        }
1639*/
1640/*
1641}
1642*/
1643
1644static inline void vectoring(Tag_Callouts & tag_Callouts, Hash_data & hash_data,char *source,int block_base){
1645
1646        elem_starts = tag_Callouts.ElemName_starts;
1647    hashvalues[1] = hash_data.Hash_value;
1648   
1649//    pre_index.push(0);
1650   
1651        StreamScanLengthGrouping(source,block_base,(ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock),(ScanBlock *) &tag_Callouts.Content_starts,(ScanBlock *) &tag_Callouts.EndTag_marks);
1652       
1653        // Store the last starting position in case we hit boundary case
1654    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1655
1656    //copy current hash value data as previous one.
1657    memmove (&hashvalues[0], &hashvalues[1], 16);
1658}
1659/*
1660static 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){
1661
1662
1663    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
1664    //      TagMatcher will crash if we feed a long symbol name.
1665    //      Sample file: test/long_sym_name.xml
1666
1667    tracker.StoreNewlines(lex.LF);
1668    elem_starts = tag_Callouts.ElemName_starts;
1669    hashvalues[1] = hash_data.Hash_value;
1670
1671        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
1672       
1673/*
1674    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
1675    {
1676        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1677    }
1678
1679    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
1680    {
1681        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1682    }
1683
1684    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
1685    {
1686        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1687    }
1688
1689    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
1690    {
1691        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1692    }
1693
1694    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
1695    {
1696        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1697    }
1698
1699    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
1700    {
1701        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1702    }
1703
1704    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
1705    {
1706        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1707    }
1708
1709    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
1710    {
1711        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1712    }
1713
1714    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
1715    {
1716        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1717    }
1718
1719    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
1720    {
1721        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1722    }
1723
1724    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
1725    {
1726        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1727    }
1728
1729    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
1730    {
1731        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1732    }
1733
1734    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
1735    {
1736        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1737    }
1738
1739    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
1740    {
1741        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1742    }
1743
1744    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
1745    {
1746        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1747    }
1748
1749    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
1750    {
1751        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1752    }
1753
1754    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
1755    {
1756        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
1757    }
1758
1759*/
1760
1761
1762/*
1763    // Store the last starting position in case we hit boundary case
1764    previous_block_last_elem_start = - count_reverse_zeroes(elem_starts);
1765
1766    //copy current hash value data as previous one.
1767    memmove (&hashvalues[0], &hashvalues[1], 16);
1768
1769    if (bitblock::any(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
1770      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
1771      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
1772    }
1773
1774    if (bitblock::any(ctCDPI_Callouts.PI_name_starts)){
1775      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
1776    }
1777
1778    if (bitblock::any(ctCDPI_Callouts.CD_starts)){
1779      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
1780    }
1781
1782    if (bitblock::any(ref_Callouts.GenRef_starts)){
1783      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
1784    }
1785
1786    if (bitblock::any(ref_Callouts.DecRef_starts)){
1787      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
1788    }
1789
1790    if (bitblock::any(ref_Callouts.HexRef_starts)){
1791      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
1792    }
1793
1794    if (bitblock::any(check_streams.att_refs)){
1795      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
1796    }
1797
1798//    error_tracker.If_Error_Report_First();
1799/*
1800    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
1801    tracker.AdvanceBlock();
1802    */
1803    /*
1804}
1805*/
1806
1807static inline void print_GIDS()
1808{
1809    int span_count = gids.size();
1810    for(int i=0;i<span_count;i++) {
1811             cout << gids[i] << " ";
1812    }
1813    cout << endl;
1814}
1815
1816static inline int test(int)
1817{
1818    return 0;
1819}
1820
1821void do_process(FILE *infile, FILE *outfile) {
1822
1823        ///////////////
1824        //gid file
1825        ///////////////
1826        gid_writein = fopen("gid.out","w");
1827@decl
1828        #ifndef STL_ALIGNED_VECTOR
1829                TagMatcher<SEGMENT_SIZE,LOOKAHEAD_SIZE> matcher;
1830        #endif
1831//#ifdef SYMBOL_TABLE
1832        if(Symbol){
1833        ///////////////////////////////////////////////////
1834        //preload element_IDs into symbol table from schema
1835        ///////////////////////////////////////////////////
1836        FILE *element_ID_in = fopen("../test/element_ID","r");
1837        char symbol[50];
1838        int index;
1839        if(element_ID_in == NULL){
1840                printf("Error opening element_ID file.\n");
1841                exit(0);
1842        }
1843        hashvalues[1] = hash_data.Hash_value;
1844        while(fscanf(element_ID_in,"%s %d\n",&symbol[0],&index)==2){
1845                int lgth = strlen(symbol);
1846                int hashvalue = compute_hash_value2(symbol,lgth);
1847//              cout << symbol <<" "<< lgth<<" "<<hashvalue << endl;
1848                int gid = 0;
1849                switch (lgth)
1850        {
1851                        case 1:
1852                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(symbol, hashvalue);
1853                        break;
1854                        case 2:
1855                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(symbol, hashvalue);
1856                        break;
1857                        case 3:
1858                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(symbol, hashvalue);
1859                        break;
1860                        case 4:
1861                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(symbol, hashvalue);
1862                        break;
1863                        case 5:
1864                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(symbol, hashvalue);
1865                        break;
1866                        case 6:
1867                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(symbol, hashvalue);
1868                        break;
1869                        case 7:
1870                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(symbol, hashvalue);
1871                        break;
1872                        case 8:
1873                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(symbol, hashvalue);
1874                        break;
1875                        case 9:
1876                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(symbol, hashvalue);
1877                        break;
1878                        case 10:
1879                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(symbol, hashvalue);
1880                        break;
1881                        case 11:
1882                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(symbol, hashvalue);
1883                        break;
1884                        case 12:
1885                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(symbol, hashvalue);
1886                        break;
1887                        case 13:
1888                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(symbol, hashvalue);
1889                        break;
1890                        case 14:
1891                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(symbol, hashvalue);
1892                        break;
1893                        case 15:
1894                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(symbol, hashvalue);
1895                        break;
1896                        case 16:
1897                        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(symbol, hashvalue);
1898                        break;
1899                        default:
1900                        gid = pbgs_symbol_table.Lookup_or_Insert_Name(symbol, hashvalue, lgth);
1901                        break;         
1902                }
1903#ifdef DEBUG
1904                fprintf (gid_writein,"%s |  lgth: %i | hashvalue: %i | gid: %i | symbol: %s\n", __FUNCTION__,  lgth, hashvalue, gid, symbol);
1905#endif
1906        }       
1907        fclose(element_ID_in);
1908        }
1909//#endif
1910//      return;
1911
1912        int buffer_base = 0;
1913        int block_base = 0;
1914        int buffer_pos = 0;
1915        int block_pos = 0;
1916        int errpos = 0;
1917        int chars_avail = 0;
1918        int check_pos = 0;
1919        int chars_read = 0;
1920 
1921        //////////////////////////////////////////////////////////////////////////////////////////
1922    // Buffer Management
1923    //////////////////////////////////////////////////////////////////////////////////////////
1924                //      BitBlock buf[(BUFFER_SIZE)/sizeof(BitBlock)];
1925                //      uint8_t * src_buffer = (uint8_t *)buf + COPYBACK_SIZE;
1926
1927                #ifdef STL_ALIGNED_VECTOR
1928                        std::vector<uint8_t, AAllocator<uint8_t> > src_buffer;
1929                        src_buffer.reserve(BUFFER_SIZE);
1930                #else
1931                        char * COPYBACK;
1932                        char * src_buffer;
1933                        ALLOC_STATIC_ALIGNED_BYTE_BUFFER_WITH_COPYBACK(COPYBACK, src_buffer);
1934                #endif
1935  /*
1936  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+LOOKAHEAD_SIZE*2)/sizeof(SIMD_type)];
1937
1938  char * srcbuf = ((char *) buf) + LOOKAHEAD_SIZE;
1939  buffer_base = buf_pos;
1940  source = srcbuf;
1941  */
1942  chars_read = fread((void *)&src_buffer[0], 1, SEGMENT_SIZE, infile);
1943  chars_avail = chars_read;
1944  if (chars_avail > BUFFER_SIZE) chars_avail = SEGMENT_SIZE;
1945
1946  if(chars_read<4){
1947    fprintf(stderr,"File is too short. Not well formed.\n");
1948    exit(-1);
1949  }
1950
1951  Entity_Info * e = new Entity_Info;
1952  e->AnalyzeSignature((unsigned char *)&src_buffer[0]);
1953
1954  if (e->code_unit_base == ASCII) {
1955
1956    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)&src_buffer[0]);
1957
1958    decl_parser.ReadXMLInfo(*e);
1959
1960    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
1961        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
1962        exit(-1);
1963    }
1964  }
1965  else {
1966    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
1967        exit(-1);
1968  }
1969
1970  if (e->content_start != 0) {
1971        memmove(&src_buffer[0], &src_buffer[e->content_start], chars_read - e->content_start);
1972        buffer_pos = e->content_start;
1973//      buffer_base = buffer_pos;
1974        if ((chars_avail-e->content_start) < SEGMENT_SIZE) {
1975                        chars_read = chars_avail - e->content_start + fread(&src_buffer[chars_avail-e->content_start], 1, e->content_start, infile);
1976                        chars_avail = chars_read;
1977                }
1978                if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1979  }
1980
1981        //////////////////////////////////////////////////////////////////////////////////////////
1982        // Read OVERLAP bytes to support post processing validation lookahead.
1983        //////////////////////////////////////////////////////////////////////////////////////////
1984        chars_read = chars_avail + fread(&src_buffer[chars_avail], 1, LOOKAHEAD_SIZE, infile);
1985        chars_avail = chars_read;
1986        if (chars_avail >= SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
1987
1988@stream_stmts
1989
1990        #ifndef STL_ALIGNED_VECTOR
1991        matcher.setSrc((char *)&src_buffer[0]);
1992        #endif
1993
1994/* Full Buffers */
1995    int block_segment_num = 0;
1996    while (chars_avail >= SEGMENT_SIZE) {
1997      PERF_SEC_START(parser_timer);
1998      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
1999//              cout << "loops" << ends;
2000                block_base = blk*BLOCK_SIZE;
2001        s2p_do_block((BytePack *) &src_buffer[block_base], basis_bits);
2002     
2003                @block_stmts
2004         
2005                tracker.StoreNewlines(lex.LF);
2006//              cout << "post start" << endl;
2007//              postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
2008                postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
2009//#ifdef SYMBOL_TABLE
2010                if(Symbol)
2011                vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
2012//#endif
2013//              cout << "post done" << endl;
2014                #ifndef STL_ALIGNED_VECTOR
2015                matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2016                #endif
2017                tracker.AdvanceBlock();
2018//              cout << "loop" << endl;
2019      }
2020      #ifndef STL_ALIGNED_VECTOR
2021      matcher.StreamScan(chars_avail);
2022      matcher.Advance_buffer();
2023      #endif
2024      PERF_SEC_END(parser_timer, chars_avail);
2025//        cout << "here" << endl;
2026      int bytes_left = chars_read - chars_avail;
2027     
2028      //////////////////
2029      //element name buffer, for scanning element name backwards
2030      /////////////////
2031      memmove(&element_name_buffer[0],&src_buffer[SEGMENT_SIZE-ELEMENT_BUFFER_SIZE],ELEMENT_BUFFER_SIZE);
2032//      fprintf(gid_writein,"name_buffer\n");
2033      cross_buffer_flag = 1;
2034     
2035      memmove(&src_buffer[0], &src_buffer[SEGMENT_SIZE], LOOKAHEAD_SIZE);
2036      chars_read = fread(&src_buffer[LOOKAHEAD_SIZE],1,SEGMENT_SIZE, infile) + LOOKAHEAD_SIZE;
2037      chars_avail = chars_read;
2038//      cout << "here" << endl;
2039      if (chars_avail > SEGMENT_SIZE) chars_avail = SEGMENT_SIZE;
2040      buffer_pos += chars_avail;
2041      buffer_base = buffer_pos;
2042      block_segment_num++;
2043
2044  }
2045       
2046/* Final Partial Buffer */
2047    PERF_SEC_START(parser_timer);
2048
2049    block_pos = 0;
2050    int remaining = chars_avail;
2051
2052
2053
2054/* Full Blocks */
2055    while (remaining >= BLOCK_SIZE) {
2056          block_base = block_pos;
2057          s2p_do_block((BytePack *) &src_buffer[block_pos], basis_bits);
2058         
2059          @block_stmts
2060         
2061          tracker.StoreNewlines(lex.LF);
2062//        cout << "post start1" << endl;
2063         
2064//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
2065          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
2066//#ifdef SYMBOL_TABLE
2067        if(Symbol)
2068          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
2069//#endif
2070//        cout << "post end2" << endl;
2071          #ifndef STL_ALIGNED_VECTOR
2072          matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2073          #endif
2074          tracker.AdvanceBlock();
2075          block_pos += BLOCK_SIZE;
2076          remaining -= BLOCK_SIZE;
2077    }
2078    block_base = block_pos;
2079        #ifdef USE_ANY_CARRY_TEST
2080    if (remaining > 0 || @any_carry) {
2081        #endif
2082          EOF_mask = bitblock::srl(simd<1>::constant<1>(),convert(BLOCK_SIZE-remaining));
2083          s2p_do_final_block((BytePack *) &src_buffer[block_pos], basis_bits, EOF_mask);
2084          @final_block_stmts
2085//        cout << "post start3" << endl;
2086//        postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
2087          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, (char *)&src_buffer[0], buffer_base, block_base, chars_avail, tracker);
2088//#ifdef SYMBOL_TABLE
2089        if(Symbol)
2090          vectoring(tag_Callouts,hash_data,(char *)&src_buffer[0],block_base);
2091//#endif
2092//        cout << "post end3" << endl;
2093          #ifndef STL_ALIGNED_VECTOR
2094      matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
2095          #endif
2096          tracker.AdvanceBlock();
2097        #ifdef USE_ANY_CARRY_TEST
2098    }
2099    #endif
2100    buffer_pos += chars_avail;
2101    buffer_base = buffer_pos;
2102        #ifndef STL_ALIGNED_VECTOR
2103    matcher.StreamScan(chars_avail);
2104    matcher.Advance_buffer();
2105//    tracker.Advance_buffer();
2106
2107   
2108    if (matcher.depth != 0) {
2109      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
2110      exit(-1);
2111     
2112     
2113    }
2114    #endif
2115    PERF_SEC_END(parser_timer, chars_avail);
2116//  print_GIDS();
2117//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
2118}
2119
2120
2121
2122int
2123main(int argc, char * argv[]) {
2124        char * infilename, * outfilename;
2125        FILE *infile, *outfile;
2126        struct stat fileinfo;
2127
2128        if (argc < 2) {
2129                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
2130                exit(-1);
2131        }
2132
2133        infilename = argv[1];
2134        stat(infilename, &fileinfo);
2135        infile = fopen(infilename, "rb");
2136        if (!infile) {
2137                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
2138                exit(-1);
2139        }
2140
2141        if (argc < 3) outfile = stdout;
2142        else {
2143                outfilename = argv[2];
2144                outfile = fopen(outfilename, "wb");
2145                if (!outfile) {
2146                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
2147                        exit(-1);
2148                }
2149        }
2150
2151        if (argc == 4){
2152                if(strcmp(argv[3],"-s")==0){
2153                        Symbol = 1;
2154                        Content_model = 0;
2155                        Datatype = 0;
2156                        //Debug = 0;
2157                }else if(strcmp(argv[3],"-c")==0){
2158                        Symbol = 1;
2159                        Content_model = 1;
2160                        Datatype = 0;
2161                        Content_gather = 0;
2162                }else if(strcmp(argv[3],"-d")==0){
2163                        Symbol = 1;
2164                        Content_model = 0;
2165                        Datatype = 1;
2166                }else if(strcmp(argv[3],"-a")==0){
2167                        Symbol = 1;
2168                        Content_model = 1;
2169                        Datatype = 1;
2170                }else if(strcmp(argv[3],"-g")==0){
2171                        Symbol = 1;
2172                        Datatype = 1;
2173                        Data_gather = 1;
2174                        Content_model = 0;
2175                }else if(strcmp(argv[3],"-v")==0){
2176                        Symbol = 1;
2177                        Content_model = 1;
2178                        Datatype = 0;
2179                        Content_gather = 1;
2180                }
2181        }
2182
2183//      PERF_SEC_BIND(1);
2184
2185        PERF_SEC_INIT(parser_timer);
2186
2187        do_process(infile, outfile);
2188       
2189#if DEBUG
2190//print_gid_vec();
2191#endif
2192        //cout << "validate start" << endl;
2193        //validate();
2194//#ifdef CONTENT_MODEL
2195        if(Symbol && Content_model && !Content_gather){
2196                validate_mul_block();
2197        }
2198        if(Symbol && Datatype){
2199                int char_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[CONTENT_INDEX1];
2200//              cout << char_aval <<endl;
2201                validate_data_type(char_aval,CONTENT_INDEX1);
2202                char_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[CONTENT_INDEX2];
2203                validate_data_type(char_aval,CONTENT_INDEX2);
2204                char_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[CONTENT_INDEX3];
2205                validate_data_type(char_aval,CONTENT_INDEX3);
2206                char_aval = CONTENT_BUFFER_SIZE - content_buffer_pos[CONTENT_INDEX4];
2207                validate_data_type(char_aval,CONTENT_INDEX4);
2208        }
2209//#endif
2210        PERF_SEC_DUMP(parser_timer);
2211
2212        PERF_SEC_DESTROY(parser_timer);
2213
2214        fclose(infile);
2215        fclose(outfile);
2216
2217        printf ("Done procressing\n");
2218        return(0);
2219}
Note: See TracBrowser for help on using the repository browser.