source: proto/xmlschema/validation_template_onevec_po3.cpp @ 4170

Last change on this file since 4170 was 3559, checked in by shiyangy, 6 years ago

template checked in

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