source: proto/xmlschema/validation_template_onevec_shiporder.cpp @ 4368

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

script updated

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