source: proto/xmlschema/schema_template.cpp @ 2948

Last change on this file since 2948 was 2219, checked in by shiyangy, 7 years ago

project checkin

File size: 26.9 KB
Line 
1#define USE_FUNCTION_TEMPLATES
2#define TEMPLATED_SIMD_LIB
3
4#define DEBUG 1
5#define BLOCK_SIZE (sizeof(SIMD_type) * 8)
6#define SEGMENT_BLOCKS 12
7#define BUFFER_SIZE (BLOCK_SIZE * SEGMENT_BLOCKS)
8#define OVERLAP_BUFSIZE 2*(sizeof(SIMD_type))
9
10#define VECTOR_WIDTH 8
11#define VECTOR_TYPE (char)
12
13#include <stdio.h>
14#include <stdlib.h>
15#include <errno.h>
16#include <sys/types.h>
17#include <sys/stat.h>
18#include "../lib/lib_simd.h"
19#include "../lib/symtab/pbgs_identity_symbol_table.h"
20#include <stack>
21#include <map>
22
23#include <queue>
24#include <string>
25
26typedef long ScanBlock;
27typedef SIMD_type BytePack;
28typedef SIMD_type BitBlock;
29
30using namespace std;
31
32#include "../lib/carryQ.h"
33#include "xmldecl.h"
34#include "xml_error.c"
35#include "xmldecl.c"
36#include "namechars.h"
37
38#include "../lib/perflib/perfsec.h"
39#include "../lib/s2p.h"
40
41#include "TagMatcher.h"
42#include "LineColTracker.h"
43
44#ifdef BUFFER_PROFILING
45        BOM_Table * parser_timer;
46
47#elif CODE_CLOCKER
48        #define NUM_EVENTS 1
49        int Events[NUM_EVENTS] = {PAPI_TOT_CYC};
50        //int Events[NUM_EVENTS] = {PAPI_L2_DCM};
51        //int Events[NUM_EVENTS] = {PAPI_TOT_CYC, PAPI_BR_MSP};
52        int cal_size = 20;
53        CC * parser_timer = new CC(Events,NUM_EVENTS,cal_size);
54#else
55        void * parser_timer;
56#endif
57
58int block_base=0;
59int buffer_base=0;
60int buffer_last;
61char * source;
62LineColTracker tracker;
63
64static inline void ReportError(const char * error_msg, int error_pos_in_block) {
65  int error_line, error_column;
66  tracker.get_Line_and_Column(error_pos_in_block, error_line, error_column);
67  fprintf(stderr, "%s at line %i, column %i\n", error_msg, error_line, error_column);
68}
69
70class ErrorTracker {
71public:
72    ErrorTracker() { noted_pos_in_block = -1;}
73
74    inline void NoteError(const char * error_msg, BitBlock err_strm) {
75      int pos_in_block = count_forward_zeroes(err_strm);
76      if ((noted_pos_in_block == -1) || (noted_pos_in_block > pos_in_block)) {
77        noted_pos_in_block = pos_in_block;
78        noted_error = error_msg;
79      }
80    }
81
82    inline void If_Error_Report_First() {
83      if (noted_pos_in_block > -1) {
84              int error_line, error_column;
85              ReportError(noted_error, noted_pos_in_block);
86              exit(-1);
87      }
88    }
89
90private:
91  const char * noted_error;
92  int noted_pos_in_block;
93};
94
95
96TagMatcher matcher;
97BitBlock EOF_mask = simd_const_1(1);
98
99ErrorTracker error_tracker;
100BitBlock elem_starts;
101int previous_block_last_elem_start;
102BytePack hashvalues[2];
103
104vector <int> gids;
105PBGSIdentitySymbolTable pbgs_symbol_table;
106
107stack <vector<char>* > elem_vec_stack;
108map<char, vector<char>* > elem_vec_map;
109
110static inline int ScanBackwardPos(BitBlock * block, int pos)
111{
112    BitBlock s = block[0];
113    BitBlock temp = simd_and( s, simd_not(simd<128>::sll(simd<1>::constant<1>(), sisd_from_int(pos))) );
114
115    if (bitblock_has_bit(temp))
116    {
117        // sizeof (BitBlock)*8 - cbzl( s & ~(~0 << pos)) - 1;
118        return BLOCK_SIZE - count_backward_zeroes (temp) - 1;
119    }
120    else
121    {
122        //handle boundary case
123        return previous_block_last_elem_start - 1;
124    }
125}
126
127static inline int StreamScan(ScanBlock * stream, int blk_count, int ProcessPos(int)) {
128        int blk;
129        int block_pos = 0;
130        for (blk = 0; blk < blk_count; blk++) {
131                ScanBlock s = stream[blk];
132                while(s) {
133                        int code = (ProcessPos(cfzl(s) + block_pos));
134                        if (code) return code;
135                        s = s & (s-1);  // clear rightmost bit.
136                }
137                block_pos += 8 * sizeof(ScanBlock);
138        }
139        return 0;
140}
141
142static inline int compute_hash_value (int lgth, int start)
143{
144    unsigned int offset_bit = start + 128;
145    uint64_t stream = *((uint64_t*)(((uint32_t*)hashvalues)+(offset_bit>>5)));
146    return stream >> (offset_bit & 0x1F) & ~(~0 << lgth);
147}
148/*
149template <int L>
150static inline int ElemEnd_grouping(int pos) {
151    int end = block_base + pos;
152    int start = end - L;
153    int hashvalue = compute_hash_value(L, start - block_base);
154    int gid = pbgs_symbol_table.Lookup_or_Insert_Name<L>(source + start, hashvalue);
155    gids.push_back(gid);
156#if DEBUG
157    char* symbol = new char[L+1];
158    strncpy ( symbol, source + start, L );
159    symbol[L] ='\0';
160    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 );
161    delete symbol; symbol = 0;
162#endif
163    return gid;
164}
165
166template<>
167inline int ElemEnd_grouping<17>(int pos) {
168    int end = block_base + pos;
169    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
170    int lgth = end - start;
171    int hashvalue = compute_hash_value(lgth, start - block_base);
172    int gid = 0;
173
174//    if (lgth < 32)
175//    {
176//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
177//    }
178//    else
179    {
180        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
181    }
182    gids.push_back(gid);
183#if DEBUG
184    char* symbol = new char[lgth+1];
185    strncpy ( symbol, source + start, lgth );
186    symbol[lgth] ='\0';
187    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);
188#endif
189    return gid;
190}
191*/
192
193inline char ElemEnd_grouping(int pos) {
194    int end = block_base + pos;
195    int start = ScanBackwardPos (&elem_starts, pos) + block_base;
196    int lgth = end - start;
197    int hashvalue = compute_hash_value(lgth, start - block_base);
198    char gid = 0;
199
200//    if (lgth < 32)
201//    {
202//      gid = pbgs_symbol_table.Lookup_or_Insert_Name_32(source + start, hashvalue, lgth);
203//    }
204//    else
205
206        switch (lgth)
207    {
208    case 1:
209        gid = pbgs_symbol_table.Lookup_or_Insert_Name<1>(source + start, hashvalue);
210        break;
211    case 2:
212        gid = pbgs_symbol_table.Lookup_or_Insert_Name<2>(source + start, hashvalue);
213        break;
214    case 3:
215        gid = pbgs_symbol_table.Lookup_or_Insert_Name<3>(source + start, hashvalue);
216        break;
217    case 4:
218        gid = pbgs_symbol_table.Lookup_or_Insert_Name<4>(source + start, hashvalue);
219        break;
220    case 5:
221        gid = pbgs_symbol_table.Lookup_or_Insert_Name<5>(source + start, hashvalue);
222        break;
223    case 6:
224        gid = pbgs_symbol_table.Lookup_or_Insert_Name<6>(source + start, hashvalue);
225        break;
226    case 7:
227        gid = pbgs_symbol_table.Lookup_or_Insert_Name<7>(source + start, hashvalue);
228        break;
229    case 8:
230        gid = pbgs_symbol_table.Lookup_or_Insert_Name<8>(source + start, hashvalue);
231        break;
232    case 9:
233        gid = pbgs_symbol_table.Lookup_or_Insert_Name<9>(source + start, hashvalue);
234        break;
235    case 10:
236        gid = pbgs_symbol_table.Lookup_or_Insert_Name<10>(source + start, hashvalue);
237        break;
238    case 11:
239        gid = pbgs_symbol_table.Lookup_or_Insert_Name<11>(source + start, hashvalue);
240        break;
241    case 12:
242        gid = pbgs_symbol_table.Lookup_or_Insert_Name<12>(source + start, hashvalue);
243        break;
244    case 13:
245        gid = pbgs_symbol_table.Lookup_or_Insert_Name<13>(source + start, hashvalue);
246        break;
247    case 14:
248        gid = pbgs_symbol_table.Lookup_or_Insert_Name<14>(source + start, hashvalue);
249        break;
250    case 15:
251        gid = pbgs_symbol_table.Lookup_or_Insert_Name<15>(source + start, hashvalue);
252        break;
253    case 16:
254        gid = pbgs_symbol_table.Lookup_or_Insert_Name<16>(source + start, hashvalue);
255        break;
256    default:
257        gid = pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
258        break;
259    }
260/*
261    {
262        gid = (char)pbgs_symbol_table.Lookup_or_Insert_Name(source + start, hashvalue, lgth);
263    }
264*/
265    gids.push_back(gid);
266#if DEBUG
267    char* symbol = new char[lgth+1];
268    strncpy ( symbol, source + start, lgth );
269    symbol[lgth] ='\0';
270    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);
271#endif
272    return gid;
273}
274
275//template <int L>
276static inline int StreamScanLengthGrouping(ScanBlock * elemName_ends, ScanBlock * endTag_marks, ScanBlock * attName_ends, int blk_count) {
277    int blk;
278    int block_pos = 0;
279    for (blk = 0; blk < blk_count; blk++, block_pos += 8 * sizeof(ScanBlock)) {
280                ScanBlock s = elemName_ends[blk];
281                ScanBlock s2 = endTag_marks[blk];
282                ScanBlock s3 = attName_ends[blk];
283                int elem_type = 0;
284                int att_type = 0;
285                while(s | s2 | s3) {
286                        int pos_elem = cfzl(s);
287                        int pos_att = cfzl(s3);
288                        if (pos_elem < pos_att && s != 0){//elem_name occurs first
289                                elem_type = get_elem_type();
290                                //element type is an int
291                                //"element" is 1
292                                //                             
293                        }else if(pos_elem > pos_att && s3 != 0){// attribute occurs first
294                                att_type = get_att_type();
295                                //"name" is 1
296                                //
297                                switch(att_type){
298                                        case 1:
299                                                if (elem_type == 1){
300                                                       
301                                                }
302                                                break;
303                                }
304                        }
305                }
306    }
307    return 0;
308}
309
310void print_vecs(){
311        int i = 1;
312        cout << elem_vec_map.size() << " vectors" << endl; 
313        for (int i = 0;i < gids.size(); i++){
314                cout << "gid: " << gids[i] << endl;
315                vector<char> *tmp = elem_vec_map[gids[i]];
316                cout << "vector size:"<< (*tmp).size()<<endl;
317                cout << "elements: ";
318                if ((*tmp).size()!=0){
319                        for (int j = 0; j < (*tmp).size();j++){
320                                cout << (*tmp)[j] << " ";
321                        }
322                }
323                cout << endl;
324        }
325/*
326        for(int i = 0;i < gids.size();i++){
327                cout << " i : " << i << endl;
328                vector<short int> *tmp = elem_vec_map[gids[i]];
329                cout << "found" << endl;
330                cout << "map size:" << elem_vec_map.size()<< endl;
331                for (map<short int, vector<short int>* >::iterator pos = elem_vec_map.begin(); pos != elem_vec_map.end(); pos++){
332                        cout << "vector size" << (pos->second)->size() << endl;
333                }
334                cout << "size:" << tmp->size()<< endl;
335               
336                for (int j = 0;j < tmp->size();j++){
337                        cout <<tmp[j]<<" ";
338                }
339
340        }
341*/
342}
343
344static inline int NameStrt_check(int pos) {
345        int block_pos = block_base + pos;
346        if(XML_10_UTF8_NameStrt_bytes((unsigned char*)&source[block_pos]) == 0){
347              ReportError("name start error", pos);
348              exit(-1);
349        }
350        return 0;
351}
352
353static inline int Name_check(int pos) {
354        int block_pos = block_base + pos;
355        if(XML_10_UTF8_NameChar_bytes((unsigned char*)&source[block_pos]) == 0){
356              ReportError("name error", pos);
357              exit(-1);
358        }
359        return 0;
360}
361
362static inline int PIName_check(int pos) {
363        int block_pos = block_base + pos;
364        int file_pos = block_pos+buffer_base;
365        printf ("%s:%i\n",__FUNCTION__,pos);
366        if (at_XxMmLll<ASCII>((unsigned char*)&source[block_pos]) && (source[block_pos+3]=='?' || source[block_pos+3]<= ' ')) {
367              // "<?xml" legal at start of file.
368              if ((file_pos == 2) && at_XmlDecl_start<ASCII>((unsigned char*)&source[0])) return 0;
369              ReportError("[Xx][Mm][Ll] illegal as PI name", pos);
370              exit(-1);
371        }
372        return 0;
373}
374
375static inline int CD_check(int pos) {
376        int block_pos = block_base + pos;
377        if (!at_CDATA1<ASCII>((unsigned char*)&source[block_pos])){
378              ReportError("CDATA error", pos);
379              exit(-1);
380        }
381        return 0;
382}
383
384static inline int GenRef_check(int pos) {
385        int block_pos = block_base + pos;
386        unsigned char* s = (unsigned char*)&source[block_pos];
387        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))){
388              ReportError("Undefined reference", pos);
389              exit(-1);
390        }
391        return 0;
392}
393
394static inline int HexRef_check(int pos) {
395        int block_pos = block_base + pos;
396        unsigned char* s = (unsigned char*)&source[block_pos];
397        int ch_val = 0;
398        while(at_HexDigit<ASCII>(s)){
399          ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
400          if (ch_val> 0x10FFFF ){
401            ReportError("Illegal character reference", pos);
402            exit(-1);
403          }
404          s++;
405        }
406        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
407          ReportError("Illegal character reference", pos);
408          exit(-1);
409        }
410        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
411          ReportError("Illegal XML 1.0 character reference", pos);
412          exit(-1);
413        }
414        return 0;
415}
416
417static inline int DecRef_check(int pos) {
418        int block_pos = block_base + pos;
419        unsigned char* s = (unsigned char*)&source[block_pos];
420        int ch_val = 0;
421        while(at_HexDigit<ASCII>(s)){
422          ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
423          if (ch_val> 0x10FFFF ){
424            ReportError("Illegal character reference", pos);
425            exit(-1);
426          }
427          s++;
428        }
429        if ((ch_val == 0x0) || ((ch_val | 0x7FF) == 0xDFFF)|| ((ch_val | 0x1) == 0xFFFF)){
430          ReportError("Illegal character reference", pos);
431          exit(-1);
432        }
433        else if (((ch_val < 0x20) && (ch_val != 0x9) && (ch_val != 0xD) && (ch_val != 0xA))){
434          ReportError("Illegal XML 1.0 character reference", pos);
435          exit(-1);
436        }
437        return 0;
438}
439
440static inline int AttRef_check(int pos) {
441        int block_pos = block_base + pos;
442        unsigned char* s = (unsigned char*)&source[block_pos];
443        int ch_val = 0;
444        if(s[0]=='#'){
445          s++;
446          if(s[0]=='x' || s[0]=='X'){
447            s++;
448            while(at_HexDigit<ASCII>(s)){
449              ch_val = HexVal<ASCII>(s[0]) + (ch_val<<4);
450              s++;
451            }
452          }
453          else{
454            while(at_HexDigit<ASCII>(s)){
455              ch_val = DigitVal<ASCII>(s[0]) + ch_val*10;
456              s++;
457            }
458          }
459          if (ch_val==60){
460            ReportError("Attribute values contain '<' characters after reference expansion", pos);
461            exit(-1);
462          }
463        }
464        else if(at_Ref_lt<ASCII>(s)){
465          ReportError("Attribute values contain '<' characters after reference expansion", pos);
466          exit(-1);
467        }
468        return 0;
469}
470
471
472
473@global
474
475
476
477static inline void s2p_do_block(BytePack U8[], Basis_bits & basis_bits) {
478  s2p(U8[0], U8[1], U8[2], U8[3], U8[4], U8[5], U8[6], U8[7],
479        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);
480}
481
482static inline void s2p_do_final_block(BytePack U8[], Basis_bits & basis_bits, BitBlock EOF_mask) {
483  s2p_do_block(U8, basis_bits);
484  basis_bits.bit_0 = simd_and(basis_bits.bit_0, EOF_mask);
485  basis_bits.bit_1 = simd_and(basis_bits.bit_1, EOF_mask);
486  basis_bits.bit_2 = simd_and(basis_bits.bit_2, EOF_mask);
487  basis_bits.bit_3 = simd_and(basis_bits.bit_3, EOF_mask);
488  basis_bits.bit_4 = simd_and(basis_bits.bit_4, EOF_mask);
489  basis_bits.bit_5 = simd_and(basis_bits.bit_5, EOF_mask);
490  basis_bits.bit_6 = simd_and(basis_bits.bit_6, EOF_mask);
491  basis_bits.bit_7 = simd_and(basis_bits.bit_7, EOF_mask);
492}
493
494static inline void print_basis_bits(Basis_bits & basis_bits){
495        print_bit_block("bit0:",basis_bits.bit_0);
496        print_bit_block("bit1:",basis_bits.bit_1);
497        print_bit_block("bit2:",basis_bits.bit_2);
498        print_bit_block("bit3:",basis_bits.bit_3);
499        print_bit_block("bit4:",basis_bits.bit_4);
500        print_bit_block("bit5:",basis_bits.bit_5);
501        print_bit_block("bit6:",basis_bits.bit_6);
502        print_bit_block("bit7:",basis_bits.bit_7);                                     
503}
504
505static inline void print_elem_vec(vector<char>* vec, int size){
506        cout << "vector: ";
507        for (int i = 0; i<size ; i++){
508                cout << (int)(*vec)[i] <<" ";
509        }
510        cout << endl;
511}
512
513static inline void validate_vecs(){
514/*
515        vector<int> test;
516        for(int i = 1;i <12; i++){
517                test.push_back(i);
518        }
519//      int test[] = {1,2,3,4,5,6,7,8,9,10,11};
520        Basis_bits temp_basis_bits;
521        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-44));
522        s2p_do_final_block((BytePack*)(&(test[0])), temp_basis_bits,EOF_mask);
523        print_basis_bits(temp_basis_bits);
524*/
525
526        for (map<char, vector<char>* > ::const_iterator iter = elem_vec_map.begin(); iter!= elem_vec_map.end(); ++iter){
527                int i = 0;
528                cout <<"vector key "<< iter->first << " vector ptr" << iter->second<<endl;
529                int lgth = (*(iter->second)).size();
530                cout <<"vector size: " << lgth << endl;
531                int num_block = lgth /(BLOCK_SIZE *8 / VECTOR_WIDTH);
532                int remaining = lgth %(BLOCK_SIZE *8 / VECTOR_WIDTH);
533                if (lgth != 0){
534                        for (i = 0;i < num_block; i++){
535                                Basis_bits temp_basis_bits;
536                                s2p_do_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits);
537                                print_elem_vec(iter->second,lgth);
538                                print_basis_bits(temp_basis_bits);
539//                              (BytePack*)(iter->second)
540                                cout << i ;
541                        }
542                        cout << endl;
543                }
544                if (remaining !=0){
545                        BitBlock EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
546                        Basis_bits temp_basis_bits;
547                        s2p_do_final_block(((BytePack*)(&(*(iter->second))[i])), temp_basis_bits,EOF_mask);
548                        print_elem_vec((iter->second)+i,lgth);
549                        print_basis_bits(temp_basis_bits);
550                }                       
551        }
552}
553
554static 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){
555
556
557    //NOTE: We are NOT handling the case for an extremely long symbol name (length > 1541).
558    //      TagMatcher will crash if we feed a long symbol name.
559    //      Sample file: test/long_sym_name.xml
560
561    tracker.StoreNewlines(lex.LF);
562    elem_starts = tag_Callouts.ElemName_starts;
563    hashvalues[1] = hash_data.Hash_value;
564
565        StreamScanLengthGrouping((ScanBlock *) &tag_Callouts.ElemName_ends,(ScanBlock *) &tag_Callouts.Tag_closing, sizeof(BitBlock)/sizeof(ScanBlock));
566       
567/*
568    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_1) )
569    {
570        StreamScanLengthGrouping<1>((ScanBlock *) &tag_Callouts.ElemName_ends_1,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
571    }
572
573    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_2) )
574    {
575        StreamScanLengthGrouping<2>((ScanBlock *) &tag_Callouts.ElemName_ends_2,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
576    }
577
578    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_3) )
579    {
580        StreamScanLengthGrouping<3>((ScanBlock *) &tag_Callouts.ElemName_ends_3,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
581    }
582
583    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_4) )
584    {
585        StreamScanLengthGrouping<4>((ScanBlock *) &tag_Callouts.ElemName_ends_4,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
586    }
587
588    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_5) )
589    {
590        StreamScanLengthGrouping<5>((ScanBlock *) &tag_Callouts.ElemName_ends_5,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
591    }
592
593    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_6) )
594    {
595        StreamScanLengthGrouping<6>((ScanBlock *) &tag_Callouts.ElemName_ends_6,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
596    }
597
598    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_7) )
599    {
600        StreamScanLengthGrouping<7>((ScanBlock *) &tag_Callouts.ElemName_ends_7,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
601    }
602
603    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_8) )
604    {
605        StreamScanLengthGrouping<8>((ScanBlock *) &tag_Callouts.ElemName_ends_8,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
606    }
607
608    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_9) )
609    {
610        StreamScanLengthGrouping<9>((ScanBlock *) &tag_Callouts.ElemName_ends_9,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
611    }
612
613    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_10) )
614    {
615        StreamScanLengthGrouping<10>((ScanBlock *) &tag_Callouts.ElemName_ends_10,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
616    }
617
618    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_11) )
619    {
620        StreamScanLengthGrouping<11>((ScanBlock *) &tag_Callouts.ElemName_ends_11,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
621    }
622
623    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_12) )
624    {
625        StreamScanLengthGrouping<12>((ScanBlock *) &tag_Callouts.ElemName_ends_12,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
626    }
627
628    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_13) )
629    {
630        StreamScanLengthGrouping<13>((ScanBlock *) &tag_Callouts.ElemName_ends_13,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
631    }
632
633    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_14) )
634    {
635        StreamScanLengthGrouping<14>((ScanBlock *) &tag_Callouts.ElemName_ends_14,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
636    }
637
638    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_15) )
639    {
640        StreamScanLengthGrouping<15>((ScanBlock *) &tag_Callouts.ElemName_ends_15,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
641    }
642
643    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_16) )
644    {
645        StreamScanLengthGrouping<16>((ScanBlock *) &tag_Callouts.ElemName_ends_16,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
646    }
647
648    if ( bitblock_has_bit(tag_Callouts.ElemName_ends_17_and_longer) )
649    {
650        StreamScanLengthGrouping<17>((ScanBlock *) &tag_Callouts.ElemName_ends_17_and_longer,(ScanBlock *) &tag_Callouts.EndTag_marks, sizeof(BitBlock)/sizeof(ScanBlock));
651    }
652
653*/
654
655#if DEBUG
656cout <<"gid_vectors:"<<endl;
657print_vecs();
658
659
660#endif
661
662    // Store the last starting position in case we hit boundary case
663    previous_block_last_elem_start = - count_backward_zeroes (elem_starts);
664
665    //copy current hash value data as previous one.
666    memmove (&hashvalues[0], &hashvalues[1], 16);
667
668    if (bitblock_has_bit(simd_or(check_streams.non_ascii_name_starts, check_streams.non_ascii_names))) {
669      StreamScan((ScanBlock *) &check_streams.non_ascii_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), NameStrt_check);
670      StreamScan((ScanBlock *) &check_streams.non_ascii_names, sizeof(BitBlock)/sizeof(ScanBlock), Name_check);
671    }
672
673    if (bitblock_has_bit(ctCDPI_Callouts.PI_name_starts)){
674      StreamScan((ScanBlock *) &ctCDPI_Callouts.PI_name_starts, sizeof(BitBlock)/sizeof(ScanBlock), PIName_check);
675    }
676
677    if (bitblock_has_bit(ctCDPI_Callouts.CD_starts)){
678      StreamScan((ScanBlock *) &ctCDPI_Callouts.CD_starts, sizeof(BitBlock)/sizeof(ScanBlock), CD_check);
679    }
680
681    if (bitblock_has_bit(ref_Callouts.GenRef_starts)){
682      StreamScan((ScanBlock *) &ref_Callouts.GenRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), GenRef_check);
683    }
684
685    if (bitblock_has_bit(ref_Callouts.DecRef_starts)){
686      StreamScan((ScanBlock *) &ref_Callouts.DecRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), DecRef_check);
687    }
688
689    if (bitblock_has_bit(ref_Callouts.HexRef_starts)){
690      StreamScan((ScanBlock *) &ref_Callouts.HexRef_starts, sizeof(BitBlock)/sizeof(ScanBlock), HexRef_check);
691    }
692
693    if (bitblock_has_bit(check_streams.att_refs)){
694      StreamScan((ScanBlock *) &check_streams.att_refs, sizeof(BitBlock)/sizeof(ScanBlock), AttRef_check);
695    }
696
697    error_tracker.If_Error_Report_First();
698
699    matcher.store_streams(check_streams.tag_marks, check_streams.name_follows, check_streams.misc_mask, chars_avail);
700    tracker.AdvanceBlock();
701}
702
703static inline void print_GIDS()
704{
705    int span_count = gids.size();
706    for(int i=0;i<span_count;i++) {
707             cout << gids[i] << " ";
708    }
709    cout << endl;
710}
711
712static inline int test(int)
713{
714    return 0;
715}
716
717void do_process(FILE *infile, FILE *outfile) {
718
719@decl
720  int buf_pos = 0;
721  int block_pos = 0;
722  int errpos = 0;
723  int chars_avail = 0;
724  int check_pos = 0;
725  int chars_read = 0;
726  BytePack buf[(BUFFER_SIZE+BLOCK_SIZE+OVERLAP_BUFSIZE*2)/sizeof(SIMD_type)];
727
728  char * srcbuf = ((char *) buf) + OVERLAP_BUFSIZE;
729  buffer_base = buf_pos;
730  source = srcbuf;
731  chars_read = fread((void *)srcbuf, 1, BUFFER_SIZE + OVERLAP_BUFSIZE, infile);
732  chars_avail = chars_read;
733  if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
734
735  matcher.setSrc(srcbuf);
736
737  if(chars_read<4){
738    fprintf(stderr,"File is too short. Not well formed.\n");
739    exit(-1);
740  }
741
742  Entity_Info * e = new Entity_Info;
743  e->AnalyzeSignature((unsigned char *)srcbuf);
744
745  if (e->code_unit_base == ASCII) {
746
747    XML_Decl_Parser<ASCII> decl_parser((unsigned char *)srcbuf);
748
749    decl_parser.ReadXMLInfo(*e);
750
751    if (e->code_unit_size != SingleByte || (e->has_encoding_decl && (!at_UTF_8(e->encoding)))){
752        fprintf(stderr,"Sorry, this xmlwf demo only works for UTF-8.\n");
753        exit(-1);
754    }
755  }
756  else {
757    fprintf(stderr,"Sorry, this xmlwf demo does not process EBCDIC.\n");
758        exit(-1);
759  }
760
761  if (e->content_start != 0) {
762        memmove(&srcbuf[0], &srcbuf[e->content_start], chars_read - e->content_start);
763        buf_pos = e->content_start;
764        buffer_base = buf_pos;
765        if (chars_avail == BUFFER_SIZE) {
766                chars_read = chars_read - e->content_start +
767                             fread(&srcbuf[chars_read-e->content_start], 1, e->content_start, infile);
768                chars_avail = chars_read;
769                if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
770        }
771        else {
772          chars_read -=e->content_start;
773          chars_avail -=e->content_start;
774        }
775  }
776
777@stream_stmts
778
779        vector<char> *root = new vector<char>;
780        elem_vec_stack.push(root);
781        cout<<"root_size "<<elem_vec_stack.size()<<endl;
782       
783        elem_vec_map[0] = root;
784
785/* Full Buffers */
786    int block_segment_num = 0;
787    while (chars_avail == BUFFER_SIZE) {
788      PERF_SEC_START(parser_timer);
789      for (int blk = 0; blk < SEGMENT_BLOCKS; blk++) {
790          block_base = blk*BLOCK_SIZE;
791          s2p_do_block((BytePack *) &srcbuf[block_base], basis_bits);
792          @block_stmts
793          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
794      }
795      matcher.StreamScan(chars_avail);
796      matcher.Advance_buffer();
797      tracker.Advance_buffer();
798      PERF_SEC_END(parser_timer, chars_avail);
799
800      int bytes_left = chars_read - chars_avail;
801      memmove(buf, &srcbuf[BUFFER_SIZE - OVERLAP_BUFSIZE], bytes_left + OVERLAP_BUFSIZE);
802      chars_read = fread(&srcbuf[bytes_left],1, BUFFER_SIZE + OVERLAP_BUFSIZE - bytes_left, infile) + bytes_left;
803
804      chars_avail = chars_read;
805      if (chars_avail > BUFFER_SIZE) chars_avail = BUFFER_SIZE;
806      buf_pos += chars_avail;
807      buffer_base = buf_pos;
808      block_segment_num++;
809
810  }
811 
812       
813/* Final Partial Buffer */
814    PERF_SEC_START(parser_timer);
815
816    block_pos = 0;
817    int remaining = chars_avail;
818
819
820
821/* Full Blocks */
822    while (remaining >= BLOCK_SIZE) {
823          block_base = block_pos;
824          s2p_do_block((BytePack *) &srcbuf[block_pos], basis_bits);
825          @block_stmts
826          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
827          block_pos += BLOCK_SIZE;
828          remaining -= BLOCK_SIZE;
829    }
830    block_base = block_pos;
831    if (remaining > 0 || @any_carry) {
832          EOF_mask = sisd_srl(simd_const_1(1),sisd_from_int(BLOCK_SIZE-remaining));
833          s2p_do_final_block((BytePack *) &srcbuf[block_pos], basis_bits, EOF_mask);
834          @final_block_stmts
835          postprocess_do_block(lex, ctCDPI_Callouts, ref_Callouts, check_streams, tag_Callouts, hash_data, chars_avail);
836    }
837    buf_pos += chars_avail;
838    buffer_base = buf_pos;
839
840    matcher.StreamScan(chars_avail);
841    matcher.Advance_buffer();
842    tracker.Advance_buffer();
843
844    PERF_SEC_END(parser_timer, chars_avail);
845    if (matcher.depth != 0) {
846      fprintf(stderr, "tag matching error (depth %i) at position %i\n", matcher.depth, buffer_base);
847      exit(-1);
848    }
849//  print_GIDS();
850//    pbgs_symbol_table.Print_Symbol_Table_Distribution();
851}
852
853
854
855int
856main(int argc, char * argv[]) {
857        char * infilename, * outfilename;
858        FILE *infile, *outfile;
859        struct stat fileinfo;
860
861        if (argc < 2) {
862                printf("Usage: %s <filename> [<outputfile>]\n", argv[0]);
863                exit(-1);
864        }
865
866        infilename = argv[1];
867        stat(infilename, &fileinfo);
868        infile = fopen(infilename, "rb");
869        if (!infile) {
870                fprintf(stderr, "Error: cannot open %s for input.\n", infilename);
871                exit(-1);
872        }
873
874        if (argc < 3) outfile = stdout;
875        else {
876                outfilename = argv[2];
877                outfile = fopen(outfilename, "wb");
878                if (!outfile) {
879                        fprintf(stderr, "Error: cannot open %s for writing.\n", outfilename);
880                        exit(-1);
881                }
882        }
883
884//      PERF_SEC_BIND(1);
885
886        PERF_SEC_INIT(parser_timer);
887
888        do_process(infile, outfile);
889       
890        validate_vecs();
891
892        PERF_SEC_DUMP(parser_timer);
893
894        PERF_SEC_DESTROY(parser_timer);
895
896        fclose(infile);
897        fclose(outfile);
898
899        printf ("Done procressing\n");
900        return(0);
901}
Note: See TracBrowser for help on using the repository browser.